Remove spdlog from Wasserstein code.

Bundled spdlog and fmt are not good for GUDHI integration,
and are not really used.
Most of debug code simply deleted.

48 files changed, 24 insertions, 11705 deletions

diff --git a/wasserstein/include/auction_oracle_kdtree_pure_geom.h b/wasserstein/include/auction_oracle_kdtree_pure_geom.h
index 096583e..ebfab3b 100644
--- a/wasserstein/include/auction_oracle_kdtree_pure_geom.h
+++ b/wasserstein/include/auction_oracle_kdtree_pure_geom.h
@@ -38,7 +38,6 @@ derivative works thereof, in binary and source code form.
 
 namespace ba = boost::adaptors;
 
-#include "spdlog/spdlog.h"
 #include "basic_defs_ws.h"
 #include "auction_oracle_base.h"
 #include "dnn/geometry/euclidean-dynamic.h"
@@ -82,8 +81,6 @@ struct AuctionOracleKDTreePureGeom : AuctionOracleBase<Real_, PointContainer_> {
     DebugOptimalBidR get_optimal_bid_debug(IdxType bidder_idx) const;
     void sanity_check();
 
-    std::shared_ptr<spdlog::logger> console_logger;
-
     std::pair<Real, Real> get_minmax_price() const;
 
 };
diff --git a/wasserstein/include/auction_oracle_kdtree_pure_geom.hpp b/wasserstein/include/auction_oracle_kdtree_pure_geom.hpp
index eaf54cf..4ee7b45 100644
--- a/wasserstein/include/auction_oracle_kdtree_pure_geom.hpp
+++ b/wasserstein/include/auction_oracle_kdtree_pure_geom.hpp
@@ -54,12 +54,8 @@ template <class Real_, class PointContainer_>
 std::ostream& operator<<(std::ostream& output, const AuctionOracleKDTreePureGeom<Real_, PointContainer_>& oracle)
 {
     output << "Oracle " << &oracle << std::endl;
-    output << fmt::format("       max_val_ = {0}\n",
-                          oracle.max_val_);
-
-    output << fmt::format("       prices = {0}\n",
-                          format_container_to_log(oracle.prices));
-
+    output << "max_val_ = " <<  oracle.max_val_ << "\n";
+    output << "prices = " << format_container_to_log(oracle.prices) << "\n";
     output << "end of oracle " << &oracle << std::endl;
     return output;
 }
@@ -90,13 +86,6 @@ AuctionOracleKDTreePureGeom<Real_, PointContainer_>::AuctionOracleKDTreePureGeom
     max_val_ = 3*getFurthestDistance3Approx_pg(this->bidders, this->items, params.internal_p, params.dim);
     max_val_ = std::pow(max_val_, params.wasserstein_power);
     weight_adj_const_ = max_val_;
-
-    console_logger = spdlog::get("console");
-    if (not console_logger) {
-        console_logger = spdlog::stdout_logger_st("console");
-    }
-    console_logger->set_pattern("[%H:%M:%S.%e] %v");
-    console_logger->debug("KDTree Restricted oracle ctor done");
 }
 
 
@@ -181,26 +170,18 @@ template<class Real_, class PointContainer_>
 void AuctionOracleKDTreePureGeom<Real_, PointContainer_>::set_price(IdxType item_idx,
                                                     Real new_price)
 {
-
-    console_logger->debug("Enter set_price, item_idx = {0}, new_price = {1}, old price = {2}", item_idx, new_price, this->prices[item_idx]);
-
     assert(this->prices.size() == this->items.size());
 	// adjust_prices decreases prices,
     // also this variable must be true in reverse phases of FR-auction
 
     this->prices[item_idx] = new_price;
     kdtree_->change_weight( traits.handle(this->items[item_idx]), new_price);
-
-    console_logger->debug("Exit set_price, item_idx = {0}, new_price = {1}", item_idx, new_price);
 }
 
 
 template<class Real_, class PointContainer_>
 void AuctionOracleKDTreePureGeom<Real_, PointContainer_>::adjust_prices(Real delta)
 {
-    //console_logger->debug("Enter adjust_prices, delta = {0}", delta);
-    //std::cerr << *this << std::endl;
-
     if (delta == 0.0)
         return;
 
@@ -209,9 +190,6 @@ void AuctionOracleKDTreePureGeom<Real_, PointContainer_>::adjust_prices(Real del
     }
 
     kdtree_->adjust_weights(delta);
-
-    //std::cerr << *this << std::endl;
-    //console_logger->debug("Exit adjust_prices, delta = {0}", delta);
 }
 
 template<class Real_, class PointContainer_>
diff --git a/wasserstein/include/auction_oracle_kdtree_restricted.h b/wasserstein/include/auction_oracle_kdtree_restricted.h
index 1999147..b17089b 100644
--- a/wasserstein/include/auction_oracle_kdtree_restricted.h
+++ b/wasserstein/include/auction_oracle_kdtree_restricted.h
@@ -37,7 +37,6 @@ derivative works thereof, in binary and source code form.
 #include <set>
 
 
-#include "spdlog/spdlog.h"
 #include "basic_defs_ws.h"
 #include "diagonal_heap.h"
 #include "auction_oracle_base.h"
@@ -104,8 +103,6 @@ struct AuctionOracleKDTreeRestricted : AuctionOracleBase<Real_, PointContainer_>
     void remove_top_diag_index(const size_t item_idx);
     bool is_in_top_diag_indices(const size_t item_idx) const;
 
-    std::shared_ptr<spdlog::logger> console_logger;
-
     std::pair<Real, Real> get_minmax_price() const;
 
 };
diff --git a/wasserstein/include/auction_oracle_kdtree_restricted.hpp b/wasserstein/include/auction_oracle_kdtree_restricted.hpp
index 8613ee1..f0e7ac6 100644
--- a/wasserstein/include/auction_oracle_kdtree_restricted.hpp
+++ b/wasserstein/include/auction_oracle_kdtree_restricted.hpp
@@ -54,30 +54,16 @@ template <class Real_, class PointContainer_>
 std::ostream& operator<<(std::ostream& output, const AuctionOracleKDTreeRestricted<Real_, PointContainer_>& oracle)
 {
     output << "Oracle " << &oracle << std::endl;
-    output << fmt::format("       max_val_ = {0}, best_diagonal_items_computed_ = {1}, best_diagonal_item_value_ = {2}, second_best_diagonal_item_idx_ = {3}, second_best_diagonal_item_value_ = {4}\n",
-                          oracle.max_val_,
-                          oracle.best_diagonal_items_computed_,
-                          oracle.best_diagonal_item_value_,
-                          oracle.second_best_diagonal_item_idx_,
-                          oracle.second_best_diagonal_item_value_);
-
-    output << fmt::format("       prices = {0}\n",
-                          format_container_to_log(oracle.prices));
-
-    output << fmt::format("       diag_items_heap_ = {0}\n",
-                          losses_heap_to_string(oracle.diag_items_heap_));
-
-
-    output << fmt::format("       top_diag_indices_ = {0}\n",
-                          format_container_to_log(oracle.top_diag_indices_));
-
-    output << fmt::format("       top_diag_counter_ = {0}\n",
-                          oracle.top_diag_counter_);
-
-    output << fmt::format("       top_diag_lookup_ = {0}\n",
-                          format_container_to_log(oracle.top_diag_lookup_));
-
-
+    output << "max_val_ = " << oracle.max_val_ << ", ";
+    output << "best_diagonal_items_computed_ = " << oracle.best_diagonal_items_computed_ << ", ";
+    output << "best_diagonal_item_value_ = " << oracle.best_diagonal_item_value_ << ", ";
+    output << "second_best_diagonal_item_idx_ = " << oracle.second_best_diagonal_item_idx_ << ", ";
+    output << "second_best_diagonal_item_value_ = " << oracle.second_best_diagonal_item_value_ << ", ";
+    output << "prices = " << format_container_to_log(oracle.prices) << "\n";
+    output << "diag_items_heap_ = " << losses_heap_to_string(oracle.diag_items_heap_) << "\n";
+    output << "top_diag_indices_ = " << format_container_to_log(oracle.top_diag_indices_) << "\n";
+    output << "top_diag_counter_ = " << oracle.top_diag_counter_ << "\n";
+    output << "top_diag_lookup_ = " << format_container_to_log(oracle.top_diag_lookup_) << "\n";
     output << "end of oracle " << &oracle << std::endl;
     return output;
 }
@@ -129,13 +115,6 @@ AuctionOracleKDTreeRestricted<Real_, PointContainer_>::AuctionOracleKDTreeRestri
     max_val_ = 3*getFurthestDistance3Approx<>(_bidders, _items, params.internal_p);
     max_val_ = std::pow(max_val_, params.wasserstein_power);
     weight_adj_const_ = max_val_;
-
-    console_logger = spdlog::get("console");
-    if (not console_logger) {
-        console_logger = spdlog::stdout_logger_st("console");
-    }
-    console_logger->set_pattern("[%H:%M:%S.%e] %v");
-    console_logger->debug("KDTree Restricted oracle ctor done");
 }
 
 
@@ -201,7 +180,6 @@ void AuctionOracleKDTreeRestricted<Real_, PointContainer_>::reset_top_diag_count
 template<class Real_, class PointContainer_>
 void AuctionOracleKDTreeRestricted<Real_, PointContainer_>::recompute_top_diag_items(bool hard)
 {
-    console_logger->debug("Enter recompute_top_diag_items, hard = {0}", hard);
     assert(hard or top_diag_indices_.empty());
 
     if (hard) {
@@ -229,7 +207,6 @@ void AuctionOracleKDTreeRestricted<Real_, PointContainer_>::recompute_top_diag_i
 
     best_diagonal_items_computed_ = true;
     reset_top_diag_counter();
-    console_logger->debug("Exit recompute_top_diag_items, hard = {0}", hard);
 }
 
 template<class Real_, class PointContainer_>
@@ -371,14 +348,6 @@ IdxValPair<Real_> AuctionOracleKDTreeRestricted<Real_, PointContainer_>::get_opt
 #ifdef DEBUG_KDTREE_RESTR_ORACLE
     auto db = get_optimal_bid_debug(bidder_idx);
     assert(fabs(db.best_item_value - best_item_value) < 0.000001);
-    if (fabs(db.second_best_item_value - second_best_item_value) >= 0.000001) {
-        console_logger->debug("Bidder_idx = {0}, best_item_idx = {1}, true_best_item_idx = {2}", bidder_idx, best_item_idx, db.best_item_idx);
-        console_logger->debug("second_best_item_idx = {0}, true second_best_item_idx = {1}", second_best_item_idx, db.second_best_item_idx);
-        console_logger->debug("second_best_value = {0}, true second_best_item_value = {1}", second_best_item_value, db.second_best_item_value);
-        console_logger->debug("prices = {0}", format_container_to_log(this->prices));
-        console_logger->debug("top_diag_indices_ = {0}", format_container_to_log(top_diag_indices_));
-        console_logger->debug("second_best_diagonal_item_value_ = {0}", second_best_diagonal_item_value_);
-    }
     assert(fabs(db.second_best_item_value - second_best_item_value) < 0.000001);
     //std::cout << "bid OK" << std::endl;
 #endif
@@ -392,9 +361,6 @@ value_{ij} = a_{ij} + price_j
 template<class Real_, class PointContainer_>
 void AuctionOracleKDTreeRestricted<Real_, PointContainer_>::recompute_second_best_diag()
 {
-
-    console_logger->debug("Enter recompute_second_best_diag");
-
     if (top_diag_indices_.size() > 1) {
         second_best_diagonal_item_value_ = best_diagonal_item_value_;
         second_best_diagonal_item_idx_ = top_diag_indices_[0];
@@ -409,8 +375,6 @@ void AuctionOracleKDTreeRestricted<Real_, PointContainer_>::recompute_second_bes
             second_best_diagonal_item_idx_ = diag_iter->first;
         }
     }
-
-    console_logger->debug("Exit recompute_second_best_diag, second_best_diagonal_item_value_ = {0}, second_best_diagonal_item_idx_ = {1}", second_best_diagonal_item_value_, second_best_diagonal_item_idx_);
 }
 
 
@@ -419,9 +383,6 @@ void AuctionOracleKDTreeRestricted<Real_, PointContainer_>::set_price(IdxType it
                                                     Real new_price,
                                                     const bool update_diag)
 {
-
-    console_logger->debug("Enter set_price, item_idx = {0}, new_price = {1}, old price = {2}, update_diag = {3}", item_idx, new_price, this->prices[item_idx], update_diag);
-
     assert(this->prices.size() == this->items.size());
     assert( 0 < diag_heap_handles_.size() and diag_heap_handles_.size() <= this->items.size());
 	// adjust_prices decreases prices,
@@ -454,17 +415,12 @@ void AuctionOracleKDTreeRestricted<Real_, PointContainer_>::set_price(IdxType it
             }
         }
     }
-
-    console_logger->debug("Exit set_price, item_idx = {0}, new_price = {1}", item_idx, new_price);
 }
 
 
 template<class Real_, class PointContainer_>
 void AuctionOracleKDTreeRestricted<Real_, PointContainer_>::adjust_prices(Real delta)
 {
-    //console_logger->debug("Enter adjust_prices, delta = {0}", delta);
-    //std::cerr << *this << std::endl;
-
     if (delta == 0.0)
         return;
 
@@ -488,9 +444,6 @@ void AuctionOracleKDTreeRestricted<Real_, PointContainer_>::adjust_prices(Real d
 	}
     best_diagonal_item_value_ -= delta;
     second_best_diagonal_item_value_ -= delta;
-
-    //std::cerr << *this << std::endl;
-    //console_logger->debug("Exit adjust_prices, delta = {0}", delta);
 }
 
 template<class Real_, class PointContainer_>
@@ -571,21 +524,8 @@ void AuctionOracleKDTreeRestricted<Real_, PointContainer_>::sanity_check()
             }
         }
 
-        if (true_best_diag_value != best_diagonal_item_value_) {
-            console_logger->debug("best_diagonal_item_value_ = {0}, true value = {1}", best_diagonal_item_value_, true_best_diag_value);
-            std::cerr << *this;
-            //console_logger->debug("{0}", *this);
-        }
-
         assert(true_best_diag_value == best_diagonal_item_value_);
-
         assert(true_second_best_diag_idx != k_invalid_index);
-
-        if (true_second_best_diag_value != second_best_diagonal_item_value_) {
-            console_logger->debug("second_best_diagonal_item_value_ = {0}, true value = {1}", second_best_diagonal_item_value_, true_second_best_diag_value);
-            //console_logger->debug("{0}", *this);
-        }
-
         assert(true_second_best_diag_value == second_best_diagonal_item_value_);
     }
 #endif
diff --git a/wasserstein/include/auction_oracle_stupid_sparse_restricted.h b/wasserstein/include/auction_oracle_stupid_sparse_restricted.h
index c932396..df63daf 100644
--- a/wasserstein/include/auction_oracle_stupid_sparse_restricted.h
+++ b/wasserstein/include/auction_oracle_stupid_sparse_restricted.h
@@ -99,8 +99,6 @@ struct AuctionOracleStupidSparseRestricted : AuctionOracleBase<Real_, PointConta
     void remove_top_diag_index(const size_t item_idx);
     bool is_in_top_diag_indices(const size_t item_idx) const;
 
-    std::shared_ptr<spdlog::logger> console_logger;
-
     std::pair<Real, Real> get_minmax_price() const;
 
 };
diff --git a/wasserstein/include/auction_oracle_stupid_sparse_restricted.hpp b/wasserstein/include/auction_oracle_stupid_sparse_restricted.hpp
index 8f4504d..9df2874 100644
--- a/wasserstein/include/auction_oracle_stupid_sparse_restricted.hpp
+++ b/wasserstein/include/auction_oracle_stupid_sparse_restricted.hpp
@@ -52,31 +52,17 @@ namespace ws {
 template <int k_max_nn, class Real_, class PointContainer_>
 std::ostream& operator<<(std::ostream& output, const AuctionOracleStupidSparseRestricted<k_max_nn, Real_, PointContainer_>& oracle)
 {
-    output << "Oracle " << &oracle << std::endl;
-    output << fmt::format("       max_val_ = {0}, best_diagonal_items_computed_ = {1}, best_diagonal_item_value_ = {2}, second_best_diagonal_item_idx_ = {3}, second_best_diagonal_item_value_ = {4}\n",
-                          oracle.max_val_,
-                          oracle.best_diagonal_items_computed_,
-                          oracle.best_diagonal_item_value_,
-                          oracle.second_best_diagonal_item_idx_,
-                          oracle.second_best_diagonal_item_value_);
-
-    output << fmt::format("       prices = {0}\n",
-                          format_container_to_log(oracle.prices));
-
-    output << fmt::format("       diag_items_heap_ = {0}\n",
-                          losses_heap_to_string(oracle.diag_items_heap_));
-
-
-    output << fmt::format("       top_diag_indices_ = {0}\n",
-                          format_container_to_log(oracle.top_diag_indices_));
-
-    output << fmt::format("       top_diag_counter_ = {0}\n",
-                          oracle.top_diag_counter_);
-
-    output << fmt::format("       top_diag_lookup_ = {0}\n",
-                          format_container_to_log(oracle.top_diag_lookup_));
-
-
+    output << "Oracle: " << &oracle << std::endl;
+    output << "max_val_ = " << oracle.max_val_ << ", ";
+    output << "best_diagonal_items_computed_ = " << oracle.best_diagonal_items_computed_ << ", ";
+    output << "best_diagonal_item_value_ = " << oracle.best_diagonal_item_value_ << ", ";
+    output << "second_best_diagonal_item_idx_ = " << oracle.second_best_diagonal_item_idx_ << ", ";
+    output << "second_best_diagonal_item_value_ = " << oracle.second_best_diagonal_item_value_ << ", ";
+    output << "prices = " << format_container_to_log(oracle.prices) << "\n";
+    output << "diag_items_heap_ = " << losses_heap_to_string(oracle.diag_items_heap_) << "\n";
+    output << "top_diag_indices_ = " << format_container_to_log(oracle.top_diag_indices_) << "\n";
+    output << "top_diag_counter_ = " << oracle.top_diag_counter_ << "\n";
+    output << "top_diag_lookup_ = " << format_container_to_log(oracle.top_diag_lookup_) << "\n";
     output << "end of oracle " << &oracle << std::endl;
     return output;
 }
@@ -146,13 +132,6 @@ AuctionOracleStupidSparseRestricted<k_max_nn, Real_, PointContainer_>::AuctionOr
     }
     max_val_ = 3*getFurthestDistance3Approx<>(_bidders, _items, params.internal_p);
     max_val_ = std::pow(max_val_, params.wasserstein_power);
-
-    console_logger = spdlog::get("console");
-    if (not console_logger) {
-        console_logger = spdlog::stdout_logger_st("console");
-    }
-    console_logger->set_pattern("[%H:%M:%S.%e] %v");
-    console_logger->info("Stupid sparse oracle ctor done, k = {0}", k_max_nn);
 }
 
 
@@ -218,7 +197,6 @@ void AuctionOracleStupidSparseRestricted<k_max_nn, Real_, PointContainer_>::rese
 template<int k_max_nn, class Real_, class PointContainer_>
 void AuctionOracleStupidSparseRestricted<k_max_nn, Real_, PointContainer_>::recompute_top_diag_items(bool hard)
 {
-    console_logger->debug("Enter recompute_top_diag_items, hard = {0}", hard);
     assert(hard or top_diag_indices_.empty());
 
     if (hard) {
@@ -246,7 +224,6 @@ void AuctionOracleStupidSparseRestricted<k_max_nn, Real_, PointContainer_>::reco
 
     best_diagonal_items_computed_ = true;
     reset_top_diag_counter();
-    console_logger->debug("Exit recompute_top_diag_items, hard = {0}", hard);
 }
 
 template<int k_max_nn, class Real_, class PointContainer_>
@@ -365,9 +342,6 @@ IdxValPair<Real_> AuctionOracleStupidSparseRestricted<k_max_nn, Real_, PointCont
 template<int k_max_nn, class Real_, class PointContainer_>
 void AuctionOracleStupidSparseRestricted<k_max_nn, Real_, PointContainer_>::recompute_second_best_diag()
 {
-
-    console_logger->debug("Enter recompute_second_best_diag");
-
     if (top_diag_indices_.size() > 1) {
         second_best_diagonal_item_value_ = best_diagonal_item_value_;
         second_best_diagonal_item_idx_ = top_diag_indices_[0];
@@ -382,8 +356,6 @@ void AuctionOracleStupidSparseRestricted<k_max_nn, Real_, PointContainer_>::reco
             second_best_diagonal_item_idx_ = diag_iter->first;
         }
     }
-
-    console_logger->debug("Exit recompute_second_best_diag, second_best_diagonal_item_value_ = {0}, second_best_diagonal_item_idx_ = {1}", second_best_diagonal_item_value_, second_best_diagonal_item_idx_);
 }
 
 
@@ -392,9 +364,6 @@ void AuctionOracleStupidSparseRestricted<k_max_nn, Real_, PointContainer_>::set_
                                                     Real new_price,
                                                     const bool update_diag)
 {
-
-    console_logger->debug("Enter set_price, item_idx = {0}, new_price = {1}, old price = {2}, update_diag = {3}", item_idx, new_price, this->prices[item_idx], update_diag);
-
     assert(this->prices.size() == this->items.size());
     assert( 0 < diag_heap_handles_.size() and diag_heap_handles_.size() <= this->items.size());
 	// adjust_prices decreases prices,
@@ -423,17 +392,12 @@ void AuctionOracleStupidSparseRestricted<k_max_nn, Real_, PointContainer_>::set_
             }
         }
     }
-
-    console_logger->debug("Exit set_price, item_idx = {0}, new_price = {1}", item_idx, new_price);
 }
 
 
 template<int k_max_nn, class Real_, class PointContainer_>
 void AuctionOracleStupidSparseRestricted<k_max_nn, Real_, PointContainer_>::adjust_prices(Real delta)
 {
-    //console_logger->debug("Enter adjust_prices, delta = {0}", delta);
-    //std::cerr << *this << std::endl;
-
     if (delta == 0.0)
         return;
 
@@ -455,9 +419,6 @@ void AuctionOracleStupidSparseRestricted<k_max_nn, Real_, PointContainer_>::adju
 	}
     best_diagonal_item_value_ -= delta;
     second_best_diagonal_item_value_ -= delta;
-
-    //std::cerr << *this << std::endl;
-    //console_logger->debug("Exit adjust_prices, delta = {0}", delta);
 }
 
 template<int k_max_nn, class Real_, class PointContainer_>
@@ -542,20 +503,12 @@ void AuctionOracleStupidSparseRestricted<k_max_nn, Real_, PointContainer_>::sani
         }
 
         if (true_best_diag_value != best_diagonal_item_value_) {
-            console_logger->debug("best_diagonal_item_value_ = {0}, true value = {1}", best_diagonal_item_value_, true_best_diag_value);
             std::cerr << *this;
-            //console_logger->debug("{0}", *this);
         }
 
         assert(true_best_diag_value == best_diagonal_item_value_);
 
         assert(true_second_best_diag_idx != k_invalid_index);
-
-        if (true_second_best_diag_value != second_best_diagonal_item_value_) {
-            console_logger->debug("second_best_diagonal_item_value_ = {0}, true value = {1}", second_best_diagonal_item_value_, true_second_best_diag_value);
-            //console_logger->debug("{0}", *this);
-        }
-
         assert(true_second_best_diag_value == second_best_diagonal_item_value_);
     }
 #endif
diff --git a/wasserstein/include/auction_runner_fr.h b/wasserstein/include/auction_runner_fr.h
index 1abca20..0c67b65 100644
--- a/wasserstein/include/auction_runner_fr.h
+++ b/wasserstein/include/auction_runner_fr.h
@@ -196,7 +196,6 @@ private:
     std::unordered_set<size_t> never_assigned_bidders;
     std::unordered_set<size_t> never_assigned_items;
 
-    std::shared_ptr<spdlog::logger> console_logger;
 #ifdef LOG_AUCTION
     std::unordered_set<size_t> unassigned_normal_bidders;
     std::unordered_set<size_t> unassigned_diag_bidders;
@@ -248,22 +247,6 @@ private:
     std::vector<std::vector<size_t>> forward_price_change_cnt_vec;
     std::vector<std::vector<size_t>> reverse_price_change_cnt_vec;
 
-    const char* forward_plot_logger_name = "forward_plot_logger";
-    const char* reverse_plot_logger_name = "reverse_plot_logger";
-    const char* forward_price_stat_logger_name = "forward_price_stat_logger";
-    const char* reverse_price_stat_logger_name = "reverse_price_stat_logger";
-
-    std::string forward_plot_logger_file_name;
-    std::string reverse_plot_logger_file_name;
-    std::string forward_price_stat_logger_file_name;
-    std::string reverse_price_stat_logger_file_name;
-
-    std::shared_ptr<spdlog::logger> forward_plot_logger;
-    std::shared_ptr<spdlog::logger> reverse_plot_logger;
-    std::shared_ptr<spdlog::logger> forward_price_stat_logger;
-    std::shared_ptr<spdlog::logger> reverse_price_stat_logger;
-
-
     size_t parallel_threshold = 5000;
     int num_parallelizable_rounds { 0 };
     int num_parallelizable_forward_rounds { 0 };
diff --git a/wasserstein/include/auction_runner_fr.hpp b/wasserstein/include/auction_runner_fr.hpp
index 07c1459..b0b65d0 100644
--- a/wasserstein/include/auction_runner_fr.hpp
+++ b/wasserstein/include/auction_runner_fr.hpp
@@ -127,70 +127,6 @@ AuctionRunnerFR<R, AO>::AuctionRunnerFR(const std::vector<DgmPoint>& A,
 #ifdef ORDERED_BY_PERSISTENCE
     batch_size = 5000;
 #endif
-
-    console_logger = spdlog::get("console");
-    if (not console_logger) {
-        console_logger = spdlog::stdout_logger_st("console");
-    }
-    console_logger->set_pattern("[%H:%M:%S.%e] %v");
-    console_logger->info("Forward-reverse runnder, max_num_phases = {0}, max_bids_per_round = {1}, gamma_threshold = {2}, unassigned_threshold = {3}",
-                          max_num_phases,
-                          max_bids_per_round,
-                          gamma_threshold,
-                          unassigned_threshold);
-
-
-//    check_epsilon_css();
-#ifdef LOG_AUCTION
-    parallel_threshold = bidders.size() / 100;
-    forward_plot_logger_file_name = log_filename_prefix + "_forward_plot.txt";
-    forward_plot_logger = spdlog::get(forward_plot_logger_name);
-    if (not forward_plot_logger) {
-        forward_plot_logger = spdlog::basic_logger_st(forward_plot_logger_name, forward_plot_logger_file_name);
-    }
-    forward_plot_logger->info("New forward plot starts here, diagram size = {0}, gamma_threshold = {1}, epsilon_common_ratio = {2}",
-                              bidders.size(),
-                              gamma_threshold,
-                              epsilon_common_ratio);
-    forward_plot_logger->set_pattern("%v");
-
-    reverse_plot_logger_file_name = log_filename_prefix + "_reverse_plot.txt";
-    reverse_plot_logger = spdlog::get(reverse_plot_logger_name);
-    if (not reverse_plot_logger) {
-        reverse_plot_logger = spdlog::basic_logger_st(reverse_plot_logger_name, reverse_plot_logger_file_name);
-    }
-    reverse_plot_logger->info("New reverse plot starts here, diagram size = {0}, gamma_threshold = {1}, epsilon_common_ratio = {2}",
-                              bidders.size(),
-                              gamma_threshold,
-                              epsilon_common_ratio);
-    reverse_plot_logger->set_pattern("%v");
-
-
-
-    forward_price_stat_logger_file_name = log_filename_prefix + "_forward_price_change_stat";
-    forward_price_stat_logger = spdlog::get(forward_price_stat_logger_name);
-    if (not forward_price_stat_logger) {
-        forward_price_stat_logger = spdlog::basic_logger_st(forward_price_stat_logger_name,
-                                                            forward_price_stat_logger_file_name);
-    }
-    forward_price_stat_logger->info("New forward price statistics starts here, diagram size = {0}, gamma_threshold = {1}, epsilon_common_ratio = {2}",
-                                     bidders.size(),
-                                     gamma_threshold,
-                                     epsilon_common_ratio);
-    forward_price_stat_logger->set_pattern("%v");
-
-    reverse_price_stat_logger_file_name = log_filename_prefix + "_reverse_price_change_stat";
-    reverse_price_stat_logger = spdlog::get(reverse_price_stat_logger_name);
-    if (not reverse_price_stat_logger) {
-        reverse_price_stat_logger = spdlog::basic_logger_st(reverse_price_stat_logger_name,
-                                                            reverse_price_stat_logger_file_name);
-    }
-    reverse_price_stat_logger->info("New reverse price statistics starts here, diagram size = {0}, gamma_threshold = {1}, epsilon_common_ratio = {2}",
-                                     bidders.size(),
-                                     gamma_threshold,
-                                     epsilon_common_ratio);
-    reverse_price_stat_logger->set_pattern("%v");
-#endif
 }
 
 template<class R, class AO>
@@ -270,7 +206,6 @@ void AuctionRunnerFR<R, AO>::reset_round_stat()
 template<class R, class AO>
 void AuctionRunnerFR<R, AO>::assign_forward(IdxType item_idx, IdxType bidder_idx)
 {
-    console_logger->debug("Enter assign_forward, item_idx = {0}, bidder_idx = {1}", item_idx, bidder_idx);
     sanity_check();
     // only unassigned bidders submit bids
     assert(bidders_to_items[bidder_idx] == k_invalid_index);
@@ -357,14 +292,12 @@ void AuctionRunnerFR<R, AO>::assign_forward(IdxType item_idx, IdxType bidder_idx
 #endif
 
     sanity_check();
-    console_logger->debug("Exit assign_forward, item_idx = {0}, bidder_idx = {1}", item_idx, bidder_idx);
 }
 
 
 template<class R, class AO>
 void AuctionRunnerFR<R, AO>::assign_reverse(IdxType item_idx, IdxType bidder_idx)
 {
-    console_logger->debug("Enter assign_reverse, item_idx = {0}, bidder_idx = {1}", item_idx, bidder_idx);
     // only unassigned items submit bids in reverse phase
     assert(items_to_bidders[item_idx] == k_invalid_index);
 
@@ -447,7 +380,6 @@ void AuctionRunnerFR<R, AO>::assign_reverse(IdxType item_idx, IdxType bidder_idx
     }
 
 #endif
-    console_logger->debug("Exit assign_reverse, item_idx = {0}, bidder_idx = {1}", item_idx, bidder_idx);
 }
 
 template<class R, class AO>
@@ -465,7 +397,6 @@ AuctionRunnerFR<R, AO>::get_item_bidder_cost(const size_t item_idx, const size_t
 template<class R, class AO>
 void AuctionRunnerFR<R, AO>::assign_to_best_bidder(IdxType item_idx)
 {
-    console_logger->debug("Enter assign_to_best_bidder, item_idx = {0}", item_idx);
     assert( item_idx >= 0 and item_idx < static_cast<IdxType>(num_items) );
     assert( forward_bid_table[item_idx].first != k_invalid_index);
 
@@ -482,13 +413,11 @@ void AuctionRunnerFR<R, AO>::assign_to_best_bidder(IdxType item_idx)
     forward_price_change_cnt_vec.back()[item_idx]++;
     reverse_price_change_cnt_vec.back()[best_bidder_idx]++;
 #endif
-    console_logger->debug("Exit assign_to_best_bidder, item_idx = {0}", item_idx);
 }
 
 template<class R, class AO>
 void AuctionRunnerFR<R, AO>::assign_to_best_item(IdxType bidder_idx)
 {
-    console_logger->debug("Enter assign_to_best_item, bidder_idx = {0}", bidder_idx);
     check_epsilon_css();
     assert( bidder_idx >= 0 and bidder_idx < static_cast<IdxType>(num_bidders) );
     assert( reverse_bid_table[bidder_idx].first != k_invalid_index);
@@ -506,7 +435,6 @@ void AuctionRunnerFR<R, AO>::assign_to_best_item(IdxType bidder_idx)
     reverse_price_change_cnt_vec.back()[bidder_idx]++;
 #endif
     check_epsilon_css();
-    console_logger->debug("Exit assign_to_best_item, bidder_idx = {0}", bidder_idx);
 }
 
 template<class R, class AO>
@@ -647,20 +575,10 @@ AuctionRunnerFR<R, AO>::get_relative_error(const bool debug_output) const
     // cost minus n epsilon
     Real reduced_cost = partial_cost - num_bidders * get_epsilon();
     if ( reduced_cost < 0) {
-#ifdef LOG_AUCTION
-        if (debug_output) {
-            console_logger->debug("Epsilon too large, reduced_cost = {0}", reduced_cost);
-        }
-#endif
         result = k_max_relative_error;
     } else {
         Real denominator = std::pow(reduced_cost, 1.0 / wasserstein_power) - gamma;
         if (denominator <= 0) {
-#ifdef LOG_AUCTION
-            if (debug_output) {
-                console_logger->debug("Epsilon too large, reduced_cost = {0}, denominator = {1}, gamma = {2}", reduced_cost, denominator, gamma);
-            }
-#endif
             result = k_max_relative_error;
         } else {
             Real numerator = 2 * gamma +
@@ -668,16 +586,6 @@ AuctionRunnerFR<R, AO>::get_relative_error(const bool debug_output) const
                              std::pow(reduced_cost, 1.0 / wasserstein_power);
 
             result = numerator / denominator;
-#ifdef LOG_AUCTION
-            if (debug_output) {
-                console_logger->debug("Reduced_cost = {0}, denominator = {1}, numerator {2}, error = {3},  gamma = {4}",
-                                      reduced_cost,
-                                      denominator,
-                                      numerator,
-                                      result,
-                                      gamma);
-            }
-#endif
         }
     }
     return result;
@@ -686,7 +594,6 @@ AuctionRunnerFR<R, AO>::get_relative_error(const bool debug_output) const
 template<class R, class AO>
 void AuctionRunnerFR<R, AO>::flush_assignment()
 {
-    console_logger->debug("Enter flush_assignment");
     for(auto& b2i : bidders_to_items) {
         b2i = k_invalid_index;
     }
@@ -751,7 +658,6 @@ void AuctionRunnerFR<R, AO>::flush_assignment()
     never_assigned_items = unassigned_items;
 #endif
     check_epsilon_css();
-    console_logger->debug("Exit flush_assignment");
 }
 
 template<class R, class AO>
@@ -814,10 +720,8 @@ void AuctionRunnerFR<R, AO>::run_auction_phase()
     while(continue_phase()) {
         forward_oracle.recompute_top_diag_items(true);
         forward_oracle.sanity_check();
-        console_logger->debug("forward_oracle recompute_top_diag_items done");
         run_forward_auction_phase();
         reverse_oracle.recompute_top_diag_items(true);
-        console_logger->debug("reverse_oracle recompute_top_diag_items done");
         reverse_oracle.sanity_check();
         run_reverse_auction_phase();
     }
@@ -831,87 +735,9 @@ void AuctionRunnerFR<R, AO>::run_auction_phases(const int max_num_phases, const
     assert( reverse_oracle.get_epsilon() > 0 );
     for(int phase_num = 0; phase_num < max_num_phases; ++phase_num) {
         flush_assignment();
-        console_logger->info("Phase {0} started: eps = {1}",
-                              num_phase,
-                              get_epsilon());
 
         run_auction_phase();
         Real current_result = partial_cost;
-#ifdef LOG_AUCTION
-        console_logger->info("Phase {0} done: current_result = {1}, eps = {2}, unassigned_threshold = {3}, unassigned = {4}, error = {5}, gamma = {6}",
-                              num_phase,
-                              partial_cost,
-                              get_epsilon(),
-                              format_int<>(unassigned_threshold),
-                              unassigned_bidders.size(),
-                              get_relative_error(false),
-                              get_gamma());
-
-        console_logger->info("Phase {0} done: num_rounds / num_parallelizable_rounds = {1} / {2} = {3}, cumulative rounds = {4}",
-                              num_phase,
-                              format_int(num_rounds_non_cumulative),
-                              format_int(num_parallelizable_rounds),
-                              static_cast<double>(num_parallelizable_rounds) / static_cast<double>(num_rounds_non_cumulative),
-                              format_int(num_rounds)
-                              );
-
-        console_logger->info("parallelizable_forward_rounds / num_forward_rounds = {0} / {1} = {2}",
-                         format_int<>(num_parallelizable_forward_rounds),
-                         format_int<>(num_forward_rounds_non_cumulative),
-                         static_cast<double>(num_parallelizable_forward_rounds) / static_cast<double>(num_forward_rounds_non_cumulative)
-                        );
-
-        num_parallelizable_forward_rounds = 0;
-        num_forward_rounds_non_cumulative = 0;
-
-        console_logger->info("parallelizable_reverse_rounds / num_reverse_rounds = {0} / {1} = {2}",
-                         format_int<>(num_parallelizable_reverse_rounds),
-                         format_int<>(num_reverse_rounds_non_cumulative),
-                         static_cast<double>(num_parallelizable_reverse_rounds) / static_cast<double>(num_reverse_rounds_non_cumulative)
-                        );
-
-        num_parallelizable_reverse_rounds = 0;
-        num_reverse_rounds_non_cumulative = 0;
-
-        console_logger->info("num_parallel_bids / num_total_bids = {0} / {1} = {2}, num_parallel_assignments / num_total_assignments = {3} / {4} = {5}",
-                         format_int<>(num_parallel_bids),
-                         format_int<>(num_total_bids),
-                         static_cast<double>(num_parallel_bids) / static_cast<double>(num_total_bids),
-                         format_int<>(num_parallel_assignments),
-                         format_int<>(num_total_assignments),
-                         static_cast<double>(num_parallel_assignments) / static_cast<double>(num_total_assignments)
-                        );
-
-        auto forward_min_max_price = forward_oracle.get_minmax_price();
-        auto reverse_min_max_price = reverse_oracle.get_minmax_price();
-
-        console_logger->info("forward min price = {0}, max price = {1}; reverse min price = {2}, reverse max price = {3}",
-                             forward_min_max_price.first,
-                             forward_min_max_price.second,
-                             reverse_min_max_price.first,
-                             reverse_min_max_price.second
-                             );
-
-        for(size_t item_idx = 0; item_idx < num_items; ++item_idx) {
-            forward_price_stat_logger->info("{0} {1} {2} {3} {4}",
-                                            phase_num,
-                                            item_idx,
-                                            items[item_idx].getRealX(),
-                                            items[item_idx].getRealY(),
-                                            forward_price_change_cnt_vec.back()[item_idx]
-                                           );
-        }
-
-        for(size_t bidder_idx = 0; bidder_idx < num_bidders; ++bidder_idx) {
-            reverse_price_stat_logger->info("{0} {1} {2} {3} {4}",
-                                            phase_num,
-                                            bidder_idx,
-                                            bidders[bidder_idx].getRealX(),
-                                            bidders[bidder_idx].getRealY(),
-                                            reverse_price_change_cnt_vec.back()[bidder_idx]
-                                           );
-        }
-#endif
 
         if (get_relative_error(true) <= delta) {
             break;
@@ -923,9 +749,6 @@ void AuctionRunnerFR<R, AO>::run_auction_phases(const int max_num_phases, const
 
         if (phase_can_be_final()) {
             unassigned_threshold = 0;
-#ifdef LOG_AUCTION
-            console_logger->info("Unassigned threshold set to zero!");
-#endif
         }
     }
 }
@@ -1038,7 +861,6 @@ void AuctionRunnerFR<R, AO>::remove_unassigned_bidder(const size_t bidder_idx)
 template<class R, class AO>
 void AuctionRunnerFR<R, AO>::remove_unassigned_item(const size_t item_idx)
 {
-    console_logger->debug("Enter remove_unassigned_item, unassigned_items.size = {0}", unassigned_items.size());
     unassigned_items_persistence -= get_cost_to_diagonal(items[item_idx]);
 
     never_assigned_items.erase(item_idx);
@@ -1059,7 +881,6 @@ void AuctionRunnerFR<R, AO>::remove_unassigned_item(const size_t item_idx)
         all_assigned_round_found = true;
     }
 #endif
-    console_logger->debug("Exit remove_unassigned_item, unassigned_items.size = {0}", unassigned_items.size());
 }
 
 template<class R, class AO>
@@ -1076,7 +897,6 @@ void AuctionRunnerFR<R, AO>::decrease_epsilon()
 template<class R, class AO>
 void AuctionRunnerFR<R, AO>::run_reverse_auction_phase()
 {
-    console_logger->debug("Enter run_reverse_auction_phase");
     size_t original_unassigned_items = unassigned_items.size();
 //    const size_t min_reverse_matching_increment = std::max( static_cast<size_t>(1), static_cast<size_t>(original_unassigned_items / 10));
     size_t min_reverse_matching_increment = 1;
@@ -1084,7 +904,6 @@ void AuctionRunnerFR<R, AO>::run_reverse_auction_phase()
     while (continue_reverse(original_unassigned_items, min_reverse_matching_increment)) {
         num_rounds++;
         num_rounds_non_cumulative++;
-        console_logger->debug("started round = {0}, reverse, unassigned = {1}", num_rounds, unassigned_items.size());
 
         check_epsilon_css();
 #ifdef LOG_AUCTION
@@ -1123,38 +942,6 @@ void AuctionRunnerFR<R, AO>::run_reverse_auction_phase()
         }
 
         check_epsilon_css();
-
-        console_logger->debug("ended round = {0}, reverse, unassigned = {1}", num_rounds, unassigned_items.size());
-
-#ifdef LOG_AUCTION
-
-        reverse_plot_logger->info("{0} {1} {2} {3} {4} {5} {6} {7} {8} {9} {10} {11} {12} {13} {14} {15} {16} {17} {18} {19} {20} {21} {22}",
-                                  num_phase,
-                                  num_rounds,
-                                  num_reverse_rounds,
-                                  unassigned_bidders.size(),
-                                  get_gamma(),
-                                  partial_cost,
-                                  reverse_oracle.get_epsilon(),
-                                  num_normal_reverse_bids_submitted,
-                                  num_diag_reverse_bids_submitted,
-                                  num_reverse_diag_to_diag_assignments,
-                                  num_reverse_diag_to_normal_assignments,
-                                  num_reverse_normal_to_diag_assignments,
-                                  num_reverse_normal_to_normal_assignments,
-                                  num_reverse_diag_from_diag_thefts,
-                                  num_reverse_diag_from_normal_thefts,
-                                  num_reverse_normal_from_diag_thefts,
-                                  num_reverse_normal_from_normal_thefts,
-                                  unassigned_normal_bidders.size(),
-                                  unassigned_diag_bidders.size(),
-                                  unassigned_normal_items.size(),
-                                  unassigned_diag_items.size(),
-                                  reverse_oracle.get_heap_top_size(),
-                                  get_relative_error(false)
-                                 );
-        sanity_check();
-#endif
     }
 }
 
@@ -1164,7 +951,6 @@ void AuctionRunnerFR<R, AO>::run_forward_bidding_step(const Range& active_bidder
 {
     clear_forward_bid_table();
     for(const auto bidder_idx : active_bidders) {
-        console_logger->debug("current bidder (forward): {0}, persistence = {1}", bidders[bidder_idx], bidders[bidder_idx].persistence_lp(1.0));
         submit_forward_bid(bidder_idx, forward_oracle.get_optimal_bid(bidder_idx));
         if (++num_forward_bids_submitted >= max_bids_per_round) {
             break;
@@ -1183,7 +969,6 @@ void AuctionRunnerFR<R, AO>::run_reverse_bidding_step(const Range& active_items)
                 [ki = k_invalid_index, kl = k_lowest_bid_value](const IdxValPairR& b) { return static_cast<size_t>(b.first) == ki and b.second == kl; }));
 
     for(const auto item_idx : active_items) {
-        console_logger->debug("current bidder (reverse): {0}, persistence = {1}", items[item_idx], items[item_idx].persistence_lp(1.0));
         submit_reverse_bid(item_idx, reverse_oracle.get_optimal_bid(item_idx));
         if (++num_reverse_bids_submitted >= max_bids_per_round) {
             break;
@@ -1199,7 +984,6 @@ void AuctionRunnerFR<R, AO>::run_forward_auction_phase()
 //    const size_t min_forward_matching_increment = std::max( static_cast<size_t>(1), static_cast<size_t>(original_unassigned_bidders / 10));
     const size_t min_forward_matching_increment = 1;
     while (continue_forward(original_unassigned_bidders, min_forward_matching_increment)) {
-        console_logger->debug("started round = {0}, forward, unassigned = {1}", num_rounds, unassigned_bidders.size());
         check_epsilon_css();
         num_rounds++;
 #ifdef LOG_AUCTION
@@ -1238,7 +1022,6 @@ void AuctionRunnerFR<R, AO>::run_forward_auction_phase()
             assign_to_best_bidder(item_idx);
         }
 
-        console_logger->debug("ended round = {0}, forward, unassigned = {1}", num_rounds, unassigned_bidders.size());
         check_epsilon_css();
 
 #ifdef LOG_AUCTION
@@ -1348,10 +1131,6 @@ void AuctionRunnerFR<R, AO>::sanity_check()
 
 #ifdef ORDERED_BY_PERSISTENCE
     assert(unassigned_bidders.size() == unassigned_bidders_by_persistence.size());
-    if (unassigned_items.size() != unassigned_items_by_persistence.size()) {
-        console_logger->error("unassigned_items.size() = {0}, unassigned_items_by_persistence.size() = {1}",  unassigned_items.size(),unassigned_items_by_persistence.size());
-        console_logger->error("unassigned_items = {0}, unassigned_items_by_persistence = {1}",  format_container_to_log(unassigned_items),format_pair_container_to_log(unassigned_items_by_persistence));
-    }
     assert(unassigned_items.size() == unassigned_items_by_persistence.size());
 
     for(size_t bidder_idx = 0; bidder_idx < num_bidders; ++bidder_idx) {
@@ -1393,17 +1172,6 @@ void AuctionRunnerFR<R, AO>::check_epsilon_css()
         for(size_t i = 0; i < num_items; ++i) {
             if(((is_bidder_normal(b) and is_item_diagonal(i)) or (is_bidder_diagonal(b) and is_item_normal(i))) and b != i)
                 continue;
-            if (b_prices[b] + i_prices[i] + eps < -get_item_bidder_cost(i, b) - 0.000001) {
-                console_logger->debug("b = {0}, i = {1}, eps = {2}, b_price = {3}, i_price[i] = {4}, cost = {5}, b_price + i_price + eps = {6}",
-                                       b,
-                                       i,
-                                       eps,
-                                       b_prices[b],
-                                       i_prices[i],
-                                       get_item_bidder_cost(i, b),
-                                       b_prices[b] + i_prices[i] + eps
-                                      );
-            }
             assert(b_prices[b] + i_prices[i] + eps >= -get_item_bidder_cost(i, b) - 0.000001);
         }
     }
diff --git a/wasserstein/include/auction_runner_gs.h b/wasserstein/include/auction_runner_gs.h
index f8b5a8b..8ad95c2 100644
--- a/wasserstein/include/auction_runner_gs.h
+++ b/wasserstein/include/auction_runner_gs.h
@@ -32,7 +32,6 @@ derivative works thereof, in binary and source code form.
 #include <memory>
 #include <unordered_set>
 
-#include "spdlog/spdlog.h"
 #include "auction_oracle.h"
 
 namespace hera {
diff --git a/wasserstein/include/basic_defs_ws.h b/wasserstein/include/basic_defs_ws.h
index 1712ccf..bdcfd75 100644
--- a/wasserstein/include/basic_defs_ws.h
+++ b/wasserstein/include/basic_defs_ws.h
@@ -45,12 +45,6 @@ derivative works thereof, in binary and source code form.
 #include <ciso646>
 #endif
 
-#ifndef FOR_R_TDA
-#include "spdlog/spdlog.h"
-#include "spdlog/fmt/fmt.h"
-#include "spdlog/fmt/ostr.h"
-#endif
-
 #include "hera_infinity.h"
 #include "dnn/geometry/euclidean-dynamic.h"
 #include "def_debug_ws.h"
@@ -107,7 +101,7 @@ namespace ws
     template<class R>
     inline std::ostream& operator<<(std::ostream& output, const IdxValPair<R> p)
     {
-        output << fmt::format("({0}, {1})", p.first, p.second);
+        output << "(" << p.first << ", " << p.second << ")";
         return output;
     }
 
@@ -214,16 +208,6 @@ namespace ws
     inline std::ostream& operator<<(std::ostream& output, const DiagramPoint<Real> p);
 #endif
 
-    template<class Real>
-    inline void format_arg(fmt::BasicFormatter<char> &f, const char *&format_str, const DiagramPoint<Real>&p) {
-        if (p.is_diagonal()) {
-            f.writer().write("({0},{1}, DIAG)", p.x, p.y);
-        } else {
-            f.writer().write("({0},{1}, NORM)", p.x, p.y);
-        }
-    }
-
-
     template<class Real, class Pt>
     struct DistImpl
     {
diff --git a/wasserstein/include/spdlog/async_logger.h b/wasserstein/include/spdlog/async_logger.h
deleted file mode 100644
index 9d7e08f..0000000
--- a/wasserstein/include/spdlog/async_logger.h
+++ /dev/null
@@ -1,82 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-// Very fast asynchronous logger (millions of logs per second on an average desktop)
-// Uses pre allocated lockfree queue for maximum throughput even under large number of threads.
-// Creates a single back thread to pop messages from the queue and log them.
-//
-// Upon each log write the logger:
-//    1. Checks if its log level is enough to log the message
-//    2. Push a new copy of the message to a queue (or block the caller until space is available in the queue)
-//    3. will throw spdlog_ex upon log exceptions
-// Upon destruction, logs all remaining messages in the queue before destructing..
-
-#include "spdlog/common.h"
-#include "spdlog/logger.h"
-
-#include <chrono>
-#include <functional>
-#include <string>
-#include <memory>
-
-namespace spdlog
-{
-
-namespace details
-{
-class async_log_helper;
-}
-
-class async_logger SPDLOG_FINAL :public logger
-{
-public:
-    template<class It>
-    async_logger(const std::string& name,
-                 const It& begin,
-                 const It& end,
-                 size_t queue_size,
-                 const async_overflow_policy overflow_policy =  async_overflow_policy::block_retry,
-                 const std::function<void()>& worker_warmup_cb = nullptr,
-                 const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero(),
-                 const std::function<void()>& worker_teardown_cb = nullptr);
-
-    async_logger(const std::string& logger_name,
-                 sinks_init_list sinks,
-                 size_t queue_size,
-                 const async_overflow_policy overflow_policy = async_overflow_policy::block_retry,
-                 const std::function<void()>& worker_warmup_cb = nullptr,
-                 const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero(),
-                 const std::function<void()>& worker_teardown_cb = nullptr);
-
-    async_logger(const std::string& logger_name,
-                 sink_ptr single_sink,
-                 size_t queue_size,
-                 const async_overflow_policy overflow_policy =  async_overflow_policy::block_retry,
-                 const std::function<void()>& worker_warmup_cb = nullptr,
-                 const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero(),
-                 const std::function<void()>& worker_teardown_cb = nullptr);
-
-    //Wait for the queue to be empty, and flush synchronously
-    //Warning: this can potentially last forever as we wait it to complete
-    void flush() override;
-
-    // Error handler
-    virtual void set_error_handler(log_err_handler) override;
-    virtual log_err_handler error_handler() override;
-
-protected:
-    void _sink_it(details::log_msg& msg) override;
-    void _set_formatter(spdlog::formatter_ptr msg_formatter) override;
-    void _set_pattern(const std::string& pattern, pattern_time_type pattern_time) override;
-
-private:
-    std::unique_ptr<details::async_log_helper> _async_log_helper;
-};
-}
-
-
-#include "spdlog/details/async_logger_impl.h"
diff --git a/wasserstein/include/spdlog/common.h b/wasserstein/include/spdlog/common.h
deleted file mode 100644
index 7e352fa..0000000
--- a/wasserstein/include/spdlog/common.h
+++ /dev/null
@@ -1,160 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include <string>
-#include <initializer_list>
-#include <chrono>
-#include <memory>
-#include <atomic>
-#include <exception>
-#include<functional>
-
-#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
-#include <codecvt>
-#include <locale>
-#endif
-
-#include "spdlog/details/null_mutex.h"
-
-//visual studio upto 2013 does not support noexcept nor constexpr
-#if defined(_MSC_VER) && (_MSC_VER < 1900)
-#define SPDLOG_NOEXCEPT throw()
-#define SPDLOG_CONSTEXPR
-#else
-#define SPDLOG_NOEXCEPT noexcept
-#define SPDLOG_CONSTEXPR constexpr
-#endif
-
-// See tweakme.h
-#if !defined(SPDLOG_FINAL)
-#define SPDLOG_FINAL
-#endif
-
-#if defined(__GNUC__)  || defined(__clang__)
-#define SPDLOG_DEPRECATED __attribute__((deprecated))
-#elif defined(_MSC_VER)
-#define SPDLOG_DEPRECATED __declspec(deprecated)
-#else
-#define SPDLOG_DEPRECATED
-#endif
-
-
-#include "spdlog/fmt/fmt.h"
-
-namespace spdlog
-{
-
-class formatter;
-
-namespace sinks
-{
-class sink;
-}
-
-using log_clock = std::chrono::system_clock;
-using sink_ptr = std::shared_ptr < sinks::sink >;
-using sinks_init_list = std::initializer_list < sink_ptr >;
-using formatter_ptr = std::shared_ptr<spdlog::formatter>;
-#if defined(SPDLOG_NO_ATOMIC_LEVELS)
-using level_t = details::null_atomic_int;
-#else
-using level_t = std::atomic<int>;
-#endif
-
-using log_err_handler = std::function<void(const std::string &err_msg)>;
-
-//Log level enum
-namespace level
-{
-typedef enum
-{
-    trace = 0,
-    debug = 1,
-    info = 2,
-    warn = 3,
-    err = 4,
-    critical = 5,
-    off = 6
-} level_enum;
-
-#if !defined(SPDLOG_LEVEL_NAMES)
-#define SPDLOG_LEVEL_NAMES { "trace", "debug", "info",  "warning", "error", "critical", "off" };
-#endif
-static const char* level_names[] SPDLOG_LEVEL_NAMES
-
-static const char* short_level_names[] { "T", "D", "I", "W", "E", "C", "O" };
-
-inline const char* to_str(spdlog::level::level_enum l)
-{
-    return level_names[l];
-}
-
-inline const char* to_short_str(spdlog::level::level_enum l)
-{
-    return short_level_names[l];
-}
-} //level
-
-
-//
-// Async overflow policy - block by default.
-//
-enum class async_overflow_policy
-{
-    block_retry, // Block / yield / sleep until message can be enqueued
-    discard_log_msg // Discard the message it enqueue fails
-};
-
-//
-// Pattern time - specific time getting to use for pattern_formatter.
-// local time by default
-//
-enum class pattern_time_type
-{
-    local, // log localtime
-    utc    // log utc
-};
-
-//
-// Log exception
-//
-namespace details
-{
-namespace os
-{
-std::string errno_str(int err_num);
-}
-}
-class spdlog_ex: public std::exception
-{
-public:
-    spdlog_ex(const std::string& msg):_msg(msg)
-    {}
-    spdlog_ex(const std::string& msg, int last_errno)
-    {
-        _msg = msg + ": " + details::os::errno_str(last_errno);
-    }
-    const char* what() const SPDLOG_NOEXCEPT override
-    {
-        return _msg.c_str();
-    }
-private:
-    std::string _msg;
-
-};
-
-//
-// wchar support for windows file names (SPDLOG_WCHAR_FILENAMES must be defined)
-//
-#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
-using filename_t = std::wstring;
-#else
-using filename_t = std::string;
-#endif
-
-
-} //spdlog
diff --git a/wasserstein/include/spdlog/details/async_log_helper.h b/wasserstein/include/spdlog/details/async_log_helper.h
deleted file mode 100644
index 6145dfa..0000000
--- a/wasserstein/include/spdlog/details/async_log_helper.h
+++ /dev/null
@@ -1,399 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-// async log helper :
-// Process logs asynchronously using a back thread.
-//
-// If the internal queue of log messages reaches its max size,
-// then the client call will block until there is more room.
-//
-
-#pragma once
-
-#include "spdlog/common.h"
-#include "spdlog/sinks/sink.h"
-#include "spdlog/details/mpmc_bounded_q.h"
-#include "spdlog/details/log_msg.h"
-#include "spdlog/details/os.h"
-#include "spdlog/formatter.h"
-
-#include <chrono>
-#include <exception>
-#include <functional>
-#include <memory>
-#include <string>
-#include <thread>
-#include <utility>
-#include <vector>
-
-namespace spdlog
-{
-namespace details
-{
-
-class async_log_helper
-{
-    // Async msg to move to/from the queue
-    // Movable only. should never be copied
-    enum class async_msg_type
-    {
-        log,
-        flush,
-        terminate
-    };
-    struct async_msg
-    {
-        std::string logger_name;
-        level::level_enum level;
-        log_clock::time_point time;
-        size_t thread_id;
-        std::string txt;
-        async_msg_type msg_type;
-        size_t msg_id;
-
-        async_msg() = default;
-        ~async_msg() = default;
-
-
-async_msg(async_msg&& other) SPDLOG_NOEXCEPT:
-        logger_name(std::move(other.logger_name)),
-                    level(std::move(other.level)),
-                    time(std::move(other.time)),
-                    thread_id(other.thread_id),
-                    txt(std::move(other.txt)),
-                    msg_type(std::move(other.msg_type)),
-                    msg_id(other.msg_id)
-        {}
-
-        async_msg(async_msg_type m_type):
-            level(level::info),
-            thread_id(0),
-            msg_type(m_type),
-            msg_id(0)
-        {}
-
-        async_msg& operator=(async_msg&& other) SPDLOG_NOEXCEPT
-        {
-            logger_name = std::move(other.logger_name);
-            level = other.level;
-            time = std::move(other.time);
-            thread_id = other.thread_id;
-            txt = std::move(other.txt);
-            msg_type = other.msg_type;
-            msg_id = other.msg_id;
-            return *this;
-        }
-
-        // never copy or assign. should only be moved..
-        async_msg(const async_msg&) = delete;
-        async_msg& operator=(const async_msg& other) = delete;
-
-        // construct from log_msg
-        async_msg(const details::log_msg& m):
-            level(m.level),
-            time(m.time),
-            thread_id(m.thread_id),
-            txt(m.raw.data(), m.raw.size()),
-            msg_type(async_msg_type::log),
-            msg_id(m.msg_id)
-        {
-#ifndef SPDLOG_NO_NAME
-            logger_name = *m.logger_name;
-#endif
-        }
-
-
-        // copy into log_msg
-        void fill_log_msg(log_msg &msg)
-        {
-            msg.logger_name = &logger_name;
-            msg.level = level;
-            msg.time = time;
-            msg.thread_id = thread_id;
-            msg.raw << txt;
-            msg.msg_id = msg_id;
-        }
-    };
-
-public:
-
-    using item_type = async_msg;
-    using q_type = details::mpmc_bounded_queue<item_type>;
-
-    using clock = std::chrono::steady_clock;
-
-
-    async_log_helper(formatter_ptr formatter,
-                     const std::vector<sink_ptr>& sinks,
-                     size_t queue_size,
-                     const log_err_handler err_handler,
-                     const async_overflow_policy overflow_policy = async_overflow_policy::block_retry,
-                     const std::function<void()>& worker_warmup_cb = nullptr,
-                     const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero(),
-                     const std::function<void()>& worker_teardown_cb = nullptr);
-
-    void log(const details::log_msg& msg);
-
-    // stop logging and join the back thread
-    ~async_log_helper();
-
-    void set_formatter(formatter_ptr);
-
-    void flush(bool wait_for_q);
-
-    void set_error_handler(spdlog::log_err_handler err_handler);
-
-private:
-    formatter_ptr _formatter;
-    std::vector<std::shared_ptr<sinks::sink>> _sinks;
-
-    // queue of messages to log
-    q_type _q;
-
-    log_err_handler _err_handler;
-
-    bool _flush_requested;
-
-    bool _terminate_requested;
-
-
-    // overflow policy
-    const async_overflow_policy _overflow_policy;
-
-    // worker thread warmup callback - one can set thread priority, affinity, etc
-    const std::function<void()> _worker_warmup_cb;
-
-    // auto periodic sink flush parameter
-    const std::chrono::milliseconds _flush_interval_ms;
-
-    // worker thread teardown callback
-    const std::function<void()> _worker_teardown_cb;
-
-    // worker thread
-    std::thread _worker_thread;
-
-    void push_msg(async_msg&& new_msg);
-
-    // worker thread main loop
-    void worker_loop();
-
-    // pop next message from the queue and process it. will set the last_pop to the pop time
-    // return false if termination of the queue is required
-    bool process_next_msg(log_clock::time_point& last_pop, log_clock::time_point& last_flush);
-
-    void handle_flush_interval(log_clock::time_point& now, log_clock::time_point& last_flush);
-
-    // sleep,yield or return immediately using the time passed since last message as a hint
-    static void sleep_or_yield(const spdlog::log_clock::time_point& now, const log_clock::time_point& last_op_time);
-
-    // wait until the queue is empty
-    void wait_empty_q();
-
-};
-}
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// async_sink class implementation
-///////////////////////////////////////////////////////////////////////////////
-inline spdlog::details::async_log_helper::async_log_helper(
-    formatter_ptr formatter,
-    const std::vector<sink_ptr>& sinks,
-    size_t queue_size,
-    log_err_handler err_handler,
-    const async_overflow_policy overflow_policy,
-    const std::function<void()>& worker_warmup_cb,
-    const std::chrono::milliseconds& flush_interval_ms,
-    const std::function<void()>& worker_teardown_cb):
-    _formatter(formatter),
-    _sinks(sinks),
-    _q(queue_size),
-    _err_handler(err_handler),
-    _flush_requested(false),
-    _terminate_requested(false),
-    _overflow_policy(overflow_policy),
-    _worker_warmup_cb(worker_warmup_cb),
-    _flush_interval_ms(flush_interval_ms),
-    _worker_teardown_cb(worker_teardown_cb),
-    _worker_thread(&async_log_helper::worker_loop, this)
-{}
-
-// Send to the worker thread termination message(level=off)
-// and wait for it to finish gracefully
-inline spdlog::details::async_log_helper::~async_log_helper()
-{
-    try
-    {
-        push_msg(async_msg(async_msg_type::terminate));
-        _worker_thread.join();
-    }
-    catch (...) // don't crash in destructor
-    {
-    }
-}
-
-
-//Try to push and block until succeeded (if the policy is not to discard when the queue is full)
-inline void spdlog::details::async_log_helper::log(const details::log_msg& msg)
-{
-    push_msg(async_msg(msg));
-}
-
-inline void spdlog::details::async_log_helper::push_msg(details::async_log_helper::async_msg&& new_msg)
-{
-    if (!_q.enqueue(std::move(new_msg)) && _overflow_policy != async_overflow_policy::discard_log_msg)
-    {
-        auto last_op_time = details::os::now();
-        auto now = last_op_time;
-        do
-        {
-            now = details::os::now();
-            sleep_or_yield(now, last_op_time);
-        }
-        while (!_q.enqueue(std::move(new_msg)));
-    }
-}
-
-// optionally wait for the queue be empty and request flush from the sinks
-inline void spdlog::details::async_log_helper::flush(bool wait_for_q)
-{
-    push_msg(async_msg(async_msg_type::flush));
-    if (wait_for_q)
-        wait_empty_q(); //return only make after the above flush message was processed
-}
-
-inline void spdlog::details::async_log_helper::worker_loop()
-{
-    if (_worker_warmup_cb) _worker_warmup_cb();
-    auto last_pop = details::os::now();
-    auto last_flush = last_pop;
-    auto active = true;
-    while (active)
-    {
-        try
-        {
-            active = process_next_msg(last_pop, last_flush);
-        }
-        catch (const std::exception &ex)
-        {
-            _err_handler(ex.what());
-        }
-        catch (...)
-        {
-            _err_handler("Unknown exception");
-        }
-    }
-    if (_worker_teardown_cb) _worker_teardown_cb();
-
-
-}
-
-// process next message in the queue
-// return true if this thread should still be active (while no terminate msg was received)
-inline bool spdlog::details::async_log_helper::process_next_msg(log_clock::time_point& last_pop, log_clock::time_point& last_flush)
-{
-    async_msg incoming_async_msg;
-
-    if (_q.dequeue(incoming_async_msg))
-    {
-        last_pop = details::os::now();
-        switch (incoming_async_msg.msg_type)
-        {
-        case async_msg_type::flush:
-            _flush_requested = true;
-            break;
-
-        case async_msg_type::terminate:
-            _flush_requested = true;
-            _terminate_requested = true;
-            break;
-
-        default:
-            log_msg incoming_log_msg;
-            incoming_async_msg.fill_log_msg(incoming_log_msg);
-            _formatter->format(incoming_log_msg);
-            for (auto &s : _sinks)
-            {
-                if (s->should_log(incoming_log_msg.level))
-                {
-                    s->log(incoming_log_msg);
-                }
-            }
-        }
-        return true;
-    }
-
-    // Handle empty queue..
-    // This is the only place where the queue can terminate or flush to avoid losing messages already in the queue
-    else
-    {
-        auto now = details::os::now();
-        handle_flush_interval(now, last_flush);
-        sleep_or_yield(now, last_pop);
-        return !_terminate_requested;
-    }
-}
-
-// flush all sinks if _flush_interval_ms has expired
-inline void spdlog::details::async_log_helper::handle_flush_interval(log_clock::time_point& now, log_clock::time_point& last_flush)
-{
-    auto should_flush = _flush_requested || (_flush_interval_ms != std::chrono::milliseconds::zero() && now - last_flush >= _flush_interval_ms);
-    if (should_flush)
-    {
-        for (auto &s : _sinks)
-            s->flush();
-        now = last_flush = details::os::now();
-        _flush_requested = false;
-    }
-}
-
-inline void spdlog::details::async_log_helper::set_formatter(formatter_ptr msg_formatter)
-{
-    _formatter = msg_formatter;
-}
-
-
-// spin, yield or sleep. use the time passed since last message as a hint
-inline void spdlog::details::async_log_helper::sleep_or_yield(const spdlog::log_clock::time_point& now, const spdlog::log_clock::time_point& last_op_time)
-{
-    using namespace std::this_thread;
-    using std::chrono::milliseconds;
-    using std::chrono::microseconds;
-
-    auto time_since_op = now - last_op_time;
-
-    // spin upto 50 micros
-    if (time_since_op <= microseconds(50))
-        return;
-
-    // yield upto 150 micros
-    if (time_since_op <= microseconds(100))
-        return std::this_thread::yield();
-
-    // sleep for 20 ms upto 200 ms
-    if (time_since_op <= milliseconds(200))
-        return sleep_for(milliseconds(20));
-
-    // sleep for 200 ms
-    return sleep_for(milliseconds(200));
-}
-
-// wait for the queue to be empty
-inline void spdlog::details::async_log_helper::wait_empty_q()
-{
-    auto last_op = details::os::now();
-    while (_q.approx_size() > 0)
-    {
-        sleep_or_yield(details::os::now(), last_op);
-    }
-}
-
-inline void spdlog::details::async_log_helper::set_error_handler(spdlog::log_err_handler err_handler)
-{
-    _err_handler = err_handler;
-}
-
-
-
diff --git a/wasserstein/include/spdlog/details/async_logger_impl.h b/wasserstein/include/spdlog/details/async_logger_impl.h
deleted file mode 100644
index 33486c2..0000000
--- a/wasserstein/include/spdlog/details/async_logger_impl.h
+++ /dev/null
@@ -1,105 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-// Async Logger implementation
-// Use an async_sink (queue per logger) to perform the logging in a worker thread
-
-#include "spdlog/details/async_log_helper.h"
-#include "spdlog/async_logger.h"
-
-#include <string>
-#include <functional>
-#include <chrono>
-#include <memory>
-
-template<class It>
-inline spdlog::async_logger::async_logger(const std::string& logger_name,
-        const It& begin,
-        const It& end,
-        size_t queue_size,
-        const  async_overflow_policy overflow_policy,
-        const std::function<void()>& worker_warmup_cb,
-        const std::chrono::milliseconds& flush_interval_ms,
-        const std::function<void()>& worker_teardown_cb) :
-    logger(logger_name, begin, end),
-    _async_log_helper(new details::async_log_helper(_formatter, _sinks, queue_size, _err_handler, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb))
-{
-}
-
-inline spdlog::async_logger::async_logger(const std::string& logger_name,
-        sinks_init_list sinks_list,
-        size_t queue_size,
-        const  async_overflow_policy overflow_policy,
-        const std::function<void()>& worker_warmup_cb,
-        const std::chrono::milliseconds& flush_interval_ms,
-        const std::function<void()>& worker_teardown_cb) :
-    async_logger(logger_name, sinks_list.begin(), sinks_list.end(), queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb) {}
-
-inline spdlog::async_logger::async_logger(const std::string& logger_name,
-        sink_ptr single_sink,
-        size_t queue_size,
-        const  async_overflow_policy overflow_policy,
-        const std::function<void()>& worker_warmup_cb,
-        const std::chrono::milliseconds& flush_interval_ms,
-        const std::function<void()>& worker_teardown_cb) :
-    async_logger(logger_name,
-{
-    single_sink
-}, queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb) {}
-
-
-inline void spdlog::async_logger::flush()
-{
-    _async_log_helper->flush(true);
-}
-
-// Error handler
-inline void spdlog::async_logger::set_error_handler(spdlog::log_err_handler err_handler)
-{
-    _err_handler = err_handler;
-    _async_log_helper->set_error_handler(err_handler);
-
-}
-inline spdlog::log_err_handler spdlog::async_logger::error_handler()
-{
-    return _err_handler;
-}
-
-
-inline void spdlog::async_logger::_set_formatter(spdlog::formatter_ptr msg_formatter)
-{
-    _formatter = msg_formatter;
-    _async_log_helper->set_formatter(_formatter);
-}
-
-inline void spdlog::async_logger::_set_pattern(const std::string& pattern, pattern_time_type pattern_time)
-{
-    _formatter = std::make_shared<pattern_formatter>(pattern, pattern_time);
-    _async_log_helper->set_formatter(_formatter);
-}
-
-
-inline void spdlog::async_logger::_sink_it(details::log_msg& msg)
-{
-    try
-    {
-#if defined(SPDLOG_ENABLE_MESSAGE_COUNTER)
-        msg.msg_id = _msg_counter.fetch_add(1, std::memory_order_relaxed);
-#endif
-        _async_log_helper->log(msg);
-        if (_should_flush_on(msg))
-            _async_log_helper->flush(false); // do async flush
-    }
-    catch (const std::exception &ex)
-    {
-        _err_handler(ex.what());
-    }
-    catch (...)
-    {
-        _err_handler("Unknown exception");
-    }
-}
diff --git a/wasserstein/include/spdlog/details/file_helper.h b/wasserstein/include/spdlog/details/file_helper.h
deleted file mode 100644
index d0d730e..0000000
--- a/wasserstein/include/spdlog/details/file_helper.h
+++ /dev/null
@@ -1,117 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-// Helper class for file sink
-// When failing to open a file, retry several times(5) with small delay between the tries(10 ms)
-// Throw spdlog_ex exception on errors
-
-#include "spdlog/details/os.h"
-#include "spdlog/details/log_msg.h"
-
-#include <chrono>
-#include <cstdio>
-#include <string>
-#include <thread>
-#include <cerrno>
-
-namespace spdlog
-{
-namespace details
-{
-
-class file_helper
-{
-
-public:
-    const int open_tries = 5;
-    const int open_interval = 10;
-
-    explicit file_helper() :
-        _fd(nullptr)
-    {}
-
-    file_helper(const file_helper&) = delete;
-    file_helper& operator=(const file_helper&) = delete;
-
-    ~file_helper()
-    {
-        close();
-    }
-
-
-    void open(const filename_t& fname, bool truncate = false)
-    {
-
-        close();
-        auto *mode = truncate ? SPDLOG_FILENAME_T("wb") : SPDLOG_FILENAME_T("ab");
-        _filename = fname;
-        for (int tries = 0; tries < open_tries; ++tries)
-        {
-            if (!os::fopen_s(&_fd, fname, mode))
-                return;
-
-            std::this_thread::sleep_for(std::chrono::milliseconds(open_interval));
-        }
-
-        throw spdlog_ex("Failed opening file " + os::filename_to_str(_filename) + " for writing", errno);
-    }
-
-    void reopen(bool truncate)
-    {
-        if (_filename.empty())
-            throw spdlog_ex("Failed re opening file - was not opened before");
-        open(_filename, truncate);
-
-    }
-
-    void flush()
-    {
-        std::fflush(_fd);
-    }
-
-    void close()
-    {
-        if (_fd)
-        {
-            std::fclose(_fd);
-            _fd = nullptr;
-        }
-    }
-
-    void write(const log_msg& msg)
-    {
-
-        size_t msg_size = msg.formatted.size();
-        auto data = msg.formatted.data();
-        if (std::fwrite(data, 1, msg_size, _fd) != msg_size)
-            throw spdlog_ex("Failed writing to file " + os::filename_to_str(_filename), errno);
-    }
-
-    size_t size()
-    {
-        if (!_fd)
-            throw spdlog_ex("Cannot use size() on closed file " + os::filename_to_str(_filename));
-        return os::filesize(_fd);
-    }
-
-    const filename_t& filename() const
-    {
-        return _filename;
-    }
-
-    static bool file_exists(const filename_t& name)
-    {
-
-        return os::file_exists(name);
-    }
-
-private:
-    FILE* _fd;
-    filename_t _filename;
-};
-}
-}
diff --git a/wasserstein/include/spdlog/details/log_msg.h b/wasserstein/include/spdlog/details/log_msg.h
deleted file mode 100644
index 0d7ce4b..0000000
--- a/wasserstein/include/spdlog/details/log_msg.h
+++ /dev/null
@@ -1,50 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include "spdlog/common.h"
-#include "spdlog/details/os.h"
-
-
-#include <string>
-#include <utility>
-
-namespace spdlog
-{
-namespace details
-{
-struct log_msg
-{
-    log_msg() = default;
-    log_msg(const std::string *loggers_name, level::level_enum lvl) :
-        logger_name(loggers_name),
-        level(lvl),
-        msg_id(0)
-    {
-#ifndef SPDLOG_NO_DATETIME
-        time = os::now();
-#endif
-
-#ifndef SPDLOG_NO_THREAD_ID
-        thread_id = os::thread_id();
-#endif
-    }
-
-    log_msg(const log_msg& other)  = delete;
-    log_msg& operator=(log_msg&& other) = delete;
-    log_msg(log_msg&& other) = delete;
-
-
-    const std::string *logger_name;
-    level::level_enum level;
-    log_clock::time_point time;
-    size_t thread_id;
-    fmt::MemoryWriter raw;
-    fmt::MemoryWriter formatted;
-    size_t msg_id;
-};
-}
-}
diff --git a/wasserstein/include/spdlog/details/logger_impl.h b/wasserstein/include/spdlog/details/logger_impl.h
deleted file mode 100644
index 79c4ef6..0000000
--- a/wasserstein/include/spdlog/details/logger_impl.h
+++ /dev/null
@@ -1,563 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include "spdlog/logger.h"
-#include "spdlog/sinks/stdout_sinks.h"
-
-#include <memory>
-#include <string>
-
-
-// create logger with given name, sinks and the default pattern formatter
-// all other ctors will call this one
-template<class It>
-inline spdlog::logger::logger(const std::string& logger_name, const It& begin, const It& end):
-    _name(logger_name),
-    _sinks(begin, end),
-    _formatter(std::make_shared<pattern_formatter>("%+")),
-    _level(level::info),
-    _flush_level(level::off),
-    _last_err_time(0),
-    _msg_counter(1)  // message counter will start from 1. 0-message id will be reserved for controll messages
-{
-    _err_handler = [this](const std::string &msg)
-    {
-        this->_default_err_handler(msg);
-    };
-}
-
-// ctor with sinks as init list
-inline spdlog::logger::logger(const std::string& logger_name, sinks_init_list sinks_list):
-    logger(logger_name, sinks_list.begin(), sinks_list.end())
-{}
-
-
-// ctor with single sink
-inline spdlog::logger::logger(const std::string& logger_name, spdlog::sink_ptr single_sink):
-    logger(logger_name,
-{
-    single_sink
-})
-{}
-
-
-inline spdlog::logger::~logger() = default;
-
-
-inline void spdlog::logger::set_formatter(spdlog::formatter_ptr msg_formatter)
-{
-    _set_formatter(msg_formatter);
-}
-
-inline void spdlog::logger::set_pattern(const std::string& pattern, pattern_time_type pattern_time)
-{
-    _set_pattern(pattern, pattern_time);
-}
-
-
-template <typename... Args>
-inline void spdlog::logger::log(level::level_enum lvl, const char* fmt, const Args&... args)
-{
-    if (!should_log(lvl)) return;
-
-    try
-    {
-        details::log_msg log_msg(&_name, lvl);
-        log_msg.raw.write(fmt, args...);
-        _sink_it(log_msg);
-    }
-    catch (const std::exception &ex)
-    {
-        _err_handler(ex.what());
-    }
-    catch (...)
-    {
-        _err_handler("Unknown exception");
-    }
-}
-
-template <typename... Args>
-inline void spdlog::logger::log(level::level_enum lvl, const char* msg)
-{
-    if (!should_log(lvl)) return;
-    try
-    {
-        details::log_msg log_msg(&_name, lvl);
-        log_msg.raw << msg;
-        _sink_it(log_msg);
-    }
-    catch (const std::exception &ex)
-    {
-        _err_handler(ex.what());
-    }
-    catch (...)
-    {
-        _err_handler("Unknown exception");
-    }
-
-}
-
-template<typename T>
-inline void spdlog::logger::log(level::level_enum lvl, const T& msg)
-{
-    if (!should_log(lvl)) return;
-    try
-    {
-        details::log_msg log_msg(&_name, lvl);
-        log_msg.raw << msg;
-        _sink_it(log_msg);
-    }
-    catch (const std::exception &ex)
-    {
-        _err_handler(ex.what());
-    }
-    catch (...)
-    {
-        _err_handler("Unknown exception");
-    }
-}
-
-
-template <typename Arg1, typename... Args>
-inline void spdlog::logger::trace(const char* fmt, const Arg1 &arg1, const Args&... args)
-{
-    log(level::trace, fmt, arg1, args...);
-}
-
-template <typename Arg1, typename... Args>
-inline void spdlog::logger::debug(const char* fmt, const Arg1 &arg1, const Args&... args)
-{
-    log(level::debug, fmt, arg1, args...);
-}
-
-template <typename Arg1, typename... Args>
-inline void spdlog::logger::info(const char* fmt, const Arg1 &arg1, const Args&... args)
-{
-    log(level::info, fmt, arg1, args...);
-}
-
-template <typename Arg1, typename... Args>
-inline void spdlog::logger::warn(const char* fmt, const Arg1 &arg1, const Args&... args)
-{
-    log(level::warn, fmt, arg1, args...);
-}
-
-template <typename Arg1, typename... Args>
-inline void spdlog::logger::error(const char* fmt, const Arg1 &arg1, const Args&... args)
-{
-    log(level::err, fmt, arg1, args...);
-}
-
-template <typename Arg1, typename... Args>
-inline void spdlog::logger::critical(const char* fmt, const Arg1 &arg1, const Args&... args)
-{
-    log(level::critical, fmt, arg1, args...);
-}
-
-template <typename... Args>
-inline void spdlog::logger::log_if(const bool flag, level::level_enum lvl, const char* msg)
-{
-    if (flag)
-    {
-        log(lvl, msg);
-    }
-}
-
-template<typename T>
-inline void spdlog::logger::log_if(const bool flag, level::level_enum lvl, const T& msg)
-{
-    if (flag)
-    {
-        log(lvl, msg);
-    }
-}
-
-template <typename Arg1, typename... Args>
-inline void spdlog::logger::trace_if(const bool flag, const char* fmt, const Arg1 &arg1, const Args&... args)
-{
-    if (flag)
-    {
-        log(level::trace, fmt, arg1, args...);
-    }
-}
-
-template <typename Arg1, typename... Args>
-inline void spdlog::logger::debug_if(const bool flag, const char* fmt, const Arg1 &arg1, const Args&... args)
-{
-    if (flag)
-    {
-        log(level::debug, fmt, arg1, args...);
-    }
-}
-
-template <typename Arg1, typename... Args>
-inline void spdlog::logger::info_if(const bool flag, const char* fmt, const Arg1 &arg1, const Args&... args)
-{
-    if (flag)
-    {
-        log(level::info, fmt, arg1, args...);
-    }
-}
-
-template <typename Arg1, typename... Args>
-inline void spdlog::logger::warn_if(const bool flag, const char* fmt, const Arg1& arg1, const Args&... args)
-{
-    if (flag)
-    {
-        log(level::warn, fmt, arg1, args...);
-    }
-}
-
-template <typename Arg1, typename... Args>
-inline void spdlog::logger::error_if(const bool flag, const char* fmt, const Arg1 &arg1, const Args&... args)
-{
-    if (flag)
-    {
-        log(level::err, fmt, arg1, args...);
-    }
-}
-
-template <typename Arg1, typename... Args>
-inline void spdlog::logger::critical_if(const bool flag, const char* fmt, const Arg1 &arg1, const Args&... args)
-{
-    if (flag)
-    {
-        log(level::critical, fmt, arg1, args...);
-    }
-}
-
-
-template<typename T>
-inline void spdlog::logger::trace(const T& msg)
-{
-    log(level::trace, msg);
-}
-
-template<typename T>
-inline void spdlog::logger::debug(const T& msg)
-{
-    log(level::debug, msg);
-}
-
-
-template<typename T>
-inline void spdlog::logger::info(const T& msg)
-{
-    log(level::info, msg);
-}
-
-
-template<typename T>
-inline void spdlog::logger::warn(const T& msg)
-{
-    log(level::warn, msg);
-}
-
-template<typename T>
-inline void spdlog::logger::error(const T& msg)
-{
-    log(level::err, msg);
-}
-
-template<typename T>
-inline void spdlog::logger::critical(const T& msg)
-{
-    log(level::critical, msg);
-}
-
-template<typename T>
-inline void spdlog::logger::trace_if(const bool flag, const T& msg)
-{
-    if (flag)
-    {
-        log(level::trace, msg);
-    }
-}
-
-template<typename T>
-inline void spdlog::logger::debug_if(const bool flag, const T& msg)
-{
-    if (flag)
-    {
-        log(level::debug, msg);
-    }
-}
-
-template<typename T>
-inline void spdlog::logger::info_if(const bool flag, const T& msg)
-{
-    if (flag)
-    {
-        log(level::info, msg);
-    }
-}
-
-template<typename T>
-inline void spdlog::logger::warn_if(const bool flag, const T& msg)
-{
-    if (flag)
-    {
-        log(level::warn, msg);
-    }
-}
-
-template<typename T>
-inline void spdlog::logger::error_if(const bool flag, const T& msg)
-{
-    if (flag)
-    {
-        log(level::err, msg);
-    }
-}
-
-template<typename T>
-inline void spdlog::logger::critical_if(const bool flag, const T& msg)
-{
-    if (flag)
-    {
-        log(level::critical, msg);
-    }
-}
-
-
-#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
-#include <codecvt>
-
-template <typename... Args>
-inline void spdlog::logger::log(level::level_enum lvl, const wchar_t* msg)
-{
-    std::wstring_convert<std::codecvt_utf8<wchar_t> > conv;
-
-    log(lvl, conv.to_bytes(msg));
-}
-
-template <typename... Args>
-inline void spdlog::logger::log(level::level_enum lvl, const wchar_t* fmt, const Args&... args)
-{
-    fmt::WMemoryWriter wWriter;
-
-    wWriter.write(fmt, args...);
-    log(lvl, wWriter.c_str());
-}
-
-template <typename... Args>
-inline void spdlog::logger::trace(const wchar_t* fmt, const Args&... args)
-{
-    log(level::trace, fmt, args...);
-}
-
-template <typename... Args>
-inline void spdlog::logger::debug(const wchar_t* fmt, const Args&... args)
-{
-    log(level::debug, fmt, args...);
-}
-
-template <typename... Args>
-inline void spdlog::logger::info(const wchar_t* fmt, const Args&... args)
-{
-    log(level::info, fmt, args...);
-}
-
-
-template <typename... Args>
-inline void spdlog::logger::warn(const wchar_t* fmt, const Args&... args)
-{
-    log(level::warn, fmt, args...);
-}
-
-template <typename... Args>
-inline void spdlog::logger::error(const wchar_t* fmt, const Args&... args)
-{
-    log(level::err, fmt, args...);
-}
-
-template <typename... Args>
-inline void spdlog::logger::critical(const wchar_t* fmt, const Args&... args)
-{
-    log(level::critical, fmt, args...);
-}
-
-//
-// conditional logging
-//
-
-template <typename... Args>
-inline void spdlog::logger::log_if(const bool flag, level::level_enum lvl, const wchar_t* msg)
-{
-    if (flag)
-    {
-        log(lvl, msg);
-    }
-}
-
-template <typename... Args>
-inline void spdlog::logger::log_if(const bool flag, level::level_enum lvl, const wchar_t* fmt, const Args&... args)
-{
-    if (flag)
-    {
-        log(lvl, fmt, args);
-    }
-}
-
-template <typename... Args>
-inline void spdlog::logger::trace_if(const bool flag, const wchar_t* fmt, const Args&... args)
-{
-    if (flag)
-    {
-        log(level::trace, fmt, args...);
-    }
-}
-
-template <typename... Args>
-inline void spdlog::logger::debug_if(const bool flag, const wchar_t* fmt, const Args&... args)
-{
-    if (flag)
-    {
-        log(level::debug, fmt, args...);
-    }
-}
-
-template <typename... Args>
-inline void spdlog::logger::info_if(const bool flag, const wchar_t* fmt, const Args&... args)
-{
-    if (flag)
-    {
-        log(level::info, fmt, args...);
-    }
-}
-
-
-template <typename... Args>
-inline void spdlog::logger::warn_if(const bool flag, const wchar_t* fmt, const Args&... args)
-{
-    if (flag)
-    {
-        log(level::warn, fmt, args...);
-    }
-}
-
-template <typename... Args>
-inline void spdlog::logger::error_if(const bool flag, const wchar_t* fmt, const Args&... args)
-{
-    if (flag)
-    {
-        log(level::err, fmt, args...);
-    }
-}
-
-template <typename... Args>
-inline void spdlog::logger::critical_if(const bool flag, const wchar_t* fmt, const Args&... args)
-{
-    if (flag)
-    {
-        log(level::critical, fmt, args...);
-    }
-}
-
-#endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT
-
-
-
-//
-// name and level
-//
-inline const std::string& spdlog::logger::name() const
-{
-    return _name;
-}
-
-inline void spdlog::logger::set_level(spdlog::level::level_enum log_level)
-{
-    _level.store(log_level);
-}
-
-inline void spdlog::logger::set_error_handler(spdlog::log_err_handler err_handler)
-{
-    _err_handler = err_handler;
-}
-
-inline spdlog::log_err_handler spdlog::logger::error_handler()
-{
-    return _err_handler;
-}
-
-
-inline void spdlog::logger::flush_on(level::level_enum log_level)
-{
-    _flush_level.store(log_level);
-}
-
-inline spdlog::level::level_enum spdlog::logger::level() const
-{
-    return static_cast<spdlog::level::level_enum>(_level.load(std::memory_order_relaxed));
-}
-
-inline bool spdlog::logger::should_log(spdlog::level::level_enum msg_level) const
-{
-    return msg_level >= _level.load(std::memory_order_relaxed);
-}
-
-//
-// protected virtual called at end of each user log call (if enabled) by the line_logger
-//
-inline void spdlog::logger::_sink_it(details::log_msg& msg)
-{
-#if defined(SPDLOG_ENABLE_MESSAGE_COUNTER)
-    msg.msg_id = _msg_counter.fetch_add(1, std::memory_order_relaxed);
-#endif
-    _formatter->format(msg);
-    for (auto &sink : _sinks)
-    {
-        if( sink->should_log( msg.level))
-        {
-            sink->log(msg);
-        }
-    }
-
-    if(_should_flush_on(msg))
-        flush();
-}
-
-inline void spdlog::logger::_set_pattern(const std::string& pattern, pattern_time_type pattern_time)
-{
-    _formatter = std::make_shared<pattern_formatter>(pattern, pattern_time);
-}
-inline void spdlog::logger::_set_formatter(formatter_ptr msg_formatter)
-{
-    _formatter = msg_formatter;
-}
-
-inline void spdlog::logger::flush()
-{
-    for (auto& sink : _sinks)
-        sink->flush();
-}
-
-inline void spdlog::logger::_default_err_handler(const std::string &msg)
-{
-    auto now = time(nullptr);
-    if (now - _last_err_time < 60)
-        return;
-    auto tm_time = details::os::localtime(now);
-    char date_buf[100];
-    std::strftime(date_buf, sizeof(date_buf), "%Y-%m-%d %H:%M:%S", &tm_time);
-    details::log_msg  err_msg;
-    err_msg.formatted.write("[*** LOG ERROR ***] [{}] [{}] [{}]{}", name(), msg, date_buf, details::os::eol);
-    sinks::stderr_sink_mt::instance()->log(err_msg);
-    _last_err_time = now;
-}
-
-inline bool spdlog::logger::_should_flush_on(const details::log_msg &msg)
-{
-    const auto flush_level = _flush_level.load(std::memory_order_relaxed);
-    return (msg.level >= flush_level) && (msg.level != level::off);
-}
-
-inline const std::vector<spdlog::sink_ptr>& spdlog::logger::sinks() const
-{
-    return _sinks;
-}
diff --git a/wasserstein/include/spdlog/details/mpmc_bounded_q.h b/wasserstein/include/spdlog/details/mpmc_bounded_q.h
deleted file mode 100644
index afd4c88..0000000
--- a/wasserstein/include/spdlog/details/mpmc_bounded_q.h
+++ /dev/null
@@ -1,172 +0,0 @@
-/*
-A modified version of Bounded MPMC queue by Dmitry Vyukov.
-
-Original code from:
-http://www.1024cores.net/home/lock-free-algorithms/queues/bounded-mpmc-queue
-
-licensed by Dmitry Vyukov under the terms below:
-
-Simplified BSD license
-
-Copyright (c) 2010-2011 Dmitry Vyukov. All rights reserved.
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-1. Redistributions of source code must retain the above copyright notice, this list of
-conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice, this list
-of conditions and the following disclaimer in the documentation and/or other materials
-provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY DMITRY VYUKOV "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
-SHALL DMITRY VYUKOV OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
-OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
-OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
-ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-The views and conclusions contained in the software and documentation are those of the authors and
-should not be interpreted as representing official policies, either expressed or implied, of Dmitry Vyukov.
-*/
-
-/*
-The code in its current form adds the license below:
-
-Copyright(c) 2015 Gabi Melman.
-Distributed under the MIT License (http://opensource.org/licenses/MIT)
-
-*/
-
-#pragma once
-
-#include "spdlog/common.h"
-
-#include <atomic>
-#include <utility>
-
-namespace spdlog
-{
-namespace details
-{
-
-template<typename T>
-class mpmc_bounded_queue
-{
-public:
-
-    using item_type = T;
-    mpmc_bounded_queue(size_t buffer_size)
-        :max_size_(buffer_size),
-         buffer_(new cell_t [buffer_size]),
-         buffer_mask_(buffer_size - 1)
-    {
-        //queue size must be power of two
-        if(!((buffer_size >= 2) && ((buffer_size & (buffer_size - 1)) == 0)))
-            throw spdlog_ex("async logger queue size must be power of two");
-
-        for (size_t i = 0; i != buffer_size; i += 1)
-            buffer_[i].sequence_.store(i, std::memory_order_relaxed);
-        enqueue_pos_.store(0, std::memory_order_relaxed);
-        dequeue_pos_.store(0, std::memory_order_relaxed);
-    }
-
-    ~mpmc_bounded_queue()
-    {
-        delete [] buffer_;
-    }
-
-
-    bool enqueue(T&& data)
-    {
-        cell_t* cell;
-        size_t pos = enqueue_pos_.load(std::memory_order_relaxed);
-        for (;;)
-        {
-            cell = &buffer_[pos & buffer_mask_];
-            size_t seq = cell->sequence_.load(std::memory_order_acquire);
-            intptr_t dif = (intptr_t)seq - (intptr_t)pos;
-            if (dif == 0)
-            {
-                if (enqueue_pos_.compare_exchange_weak(pos, pos + 1, std::memory_order_relaxed))
-                    break;
-            }
-            else if (dif < 0)
-            {
-                return false;
-            }
-            else
-            {
-                pos = enqueue_pos_.load(std::memory_order_relaxed);
-            }
-        }
-        cell->data_ = std::move(data);
-        cell->sequence_.store(pos + 1, std::memory_order_release);
-        return true;
-    }
-
-    bool dequeue(T& data)
-    {
-        cell_t* cell;
-        size_t pos = dequeue_pos_.load(std::memory_order_relaxed);
-        for (;;)
-        {
-            cell = &buffer_[pos & buffer_mask_];
-            size_t seq =
-                cell->sequence_.load(std::memory_order_acquire);
-            intptr_t dif = (intptr_t)seq - (intptr_t)(pos + 1);
-            if (dif == 0)
-            {
-                if (dequeue_pos_.compare_exchange_weak(pos, pos + 1, std::memory_order_relaxed))
-                    break;
-            }
-            else if (dif < 0)
-                return false;
-            else
-                pos = dequeue_pos_.load(std::memory_order_relaxed);
-        }
-        data = std::move(cell->data_);
-        cell->sequence_.store(pos + buffer_mask_ + 1, std::memory_order_release);
-        return true;
-    }
-
-    size_t approx_size()
-    {
-        size_t first_pos = dequeue_pos_.load(std::memory_order_relaxed);
-        size_t last_pos = enqueue_pos_.load(std::memory_order_relaxed);
-        if (last_pos <= first_pos)
-            return 0;
-        auto size = last_pos - first_pos;
-        return size < max_size_ ? size : max_size_;
-    }
-
-private:
-    struct cell_t
-    {
-        std::atomic<size_t>   sequence_;
-        T                     data_;
-    };
-
-    size_t const max_size_;
-
-    static size_t const     cacheline_size = 64;
-    typedef char            cacheline_pad_t [cacheline_size];
-
-    cacheline_pad_t         pad0_;
-    cell_t* const           buffer_;
-    size_t const            buffer_mask_;
-    cacheline_pad_t         pad1_;
-    std::atomic<size_t>     enqueue_pos_;
-    cacheline_pad_t         pad2_;
-    std::atomic<size_t>     dequeue_pos_;
-    cacheline_pad_t         pad3_;
-
-    mpmc_bounded_queue(mpmc_bounded_queue const&) = delete;
-    void operator= (mpmc_bounded_queue const&) = delete;
-};
-
-} // ns details
-} // ns spdlog
diff --git a/wasserstein/include/spdlog/details/null_mutex.h b/wasserstein/include/spdlog/details/null_mutex.h
deleted file mode 100644
index 67b0aee..0000000
--- a/wasserstein/include/spdlog/details/null_mutex.h
+++ /dev/null
@@ -1,45 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include <atomic>
-// null, no cost dummy "mutex" and dummy "atomic" int
-
-namespace spdlog
-{
-namespace details
-{
-struct null_mutex
-{
-    void lock() {}
-    void unlock() {}
-    bool try_lock()
-    {
-        return true;
-    }
-};
-
-struct null_atomic_int
-{
-    int value;
-    null_atomic_int() = default;
-
-    null_atomic_int(int val):value(val)
-    {}
-
-    int load(std::memory_order) const
-    {
-        return value;
-    }
-
-    void store(int val)
-    {
-        value = val;
-    }
-};
-
-}
-}
diff --git a/wasserstein/include/spdlog/details/os.h b/wasserstein/include/spdlog/details/os.h
deleted file mode 100644
index 735f601..0000000
--- a/wasserstein/include/spdlog/details/os.h
+++ /dev/null
@@ -1,469 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-#pragma once
-
-#include "spdlog/common.h"
-
-#include <cstdio>
-#include <ctime>
-#include <functional>
-#include <string>
-#include <chrono>
-#include <thread>
-#include <algorithm>
-#include <cstring>
-#include <cstdlib>
-#include <sys/stat.h>
-#include <sys/types.h>
-
-#ifdef _WIN32
-
-#ifndef NOMINMAX
-#define NOMINMAX //prevent windows redefining min/max
-#endif
-
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN
-#endif
-#include <windows.h>
-#include <process.h> //  _get_pid support
-#include <io.h> // _get_osfhandle and _isatty support
-
-#ifdef __MINGW32__
-#include <share.h>
-#endif
-
-#else // unix
-
-#include <unistd.h>
-#include <fcntl.h>
-
-#ifdef __linux__
-#include <sys/syscall.h> //Use gettid() syscall under linux to get thread id
-
-#elif __FreeBSD__
-#include <sys/thr.h> //Use thr_self() syscall under FreeBSD to get thread id
-#endif
-
-#endif //unix
-
-#ifndef __has_feature       // Clang - feature checking macros.
-#define __has_feature(x) 0  // Compatibility with non-clang compilers.
-#endif
-
-
-namespace spdlog
-{
-namespace details
-{
-namespace os
-{
-
-inline spdlog::log_clock::time_point now()
-{
-
-#if defined __linux__ && defined SPDLOG_CLOCK_COARSE
-    timespec ts;
-    ::clock_gettime(CLOCK_REALTIME_COARSE, &ts);
-    return std::chrono::time_point<log_clock, typename log_clock::duration>(
-               std::chrono::duration_cast<typename log_clock::duration>(
-                   std::chrono::seconds(ts.tv_sec) + std::chrono::nanoseconds(ts.tv_nsec)));
-
-
-#else
-    return log_clock::now();
-#endif
-
-}
-inline std::tm localtime(const std::time_t &time_tt)
-{
-
-#ifdef _WIN32
-    std::tm tm;
-    localtime_s(&tm, &time_tt);
-#else
-    std::tm tm;
-    localtime_r(&time_tt, &tm);
-#endif
-    return tm;
-}
-
-inline std::tm localtime()
-{
-    std::time_t now_t = time(nullptr);
-    return localtime(now_t);
-}
-
-
-inline std::tm gmtime(const std::time_t &time_tt)
-{
-
-#ifdef _WIN32
-    std::tm tm;
-    gmtime_s(&tm, &time_tt);
-#else
-    std::tm tm;
-    gmtime_r(&time_tt, &tm);
-#endif
-    return tm;
-}
-
-inline std::tm gmtime()
-{
-    std::time_t now_t = time(nullptr);
-    return gmtime(now_t);
-}
-inline bool operator==(const std::tm& tm1, const std::tm& tm2)
-{
-    return (tm1.tm_sec == tm2.tm_sec &&
-            tm1.tm_min == tm2.tm_min &&
-            tm1.tm_hour == tm2.tm_hour &&
-            tm1.tm_mday == tm2.tm_mday &&
-            tm1.tm_mon == tm2.tm_mon &&
-            tm1.tm_year == tm2.tm_year &&
-            tm1.tm_isdst == tm2.tm_isdst);
-}
-
-inline bool operator!=(const std::tm& tm1, const std::tm& tm2)
-{
-    return !(tm1 == tm2);
-}
-
-// eol definition
-#if !defined (SPDLOG_EOL)
-#ifdef _WIN32
-#define SPDLOG_EOL "\r\n"
-#else
-#define SPDLOG_EOL "\n"
-#endif
-#endif
-
-SPDLOG_CONSTEXPR static const char* eol = SPDLOG_EOL;
-SPDLOG_CONSTEXPR static int eol_size = sizeof(SPDLOG_EOL) - 1;
-
-inline void prevent_child_fd(FILE *f)
-{
-#ifdef _WIN32
-    auto file_handle = (HANDLE)_get_osfhandle(_fileno(f));
-    if (!::SetHandleInformation(file_handle, HANDLE_FLAG_INHERIT, 0))
-        throw spdlog_ex("SetHandleInformation failed", errno);
-#else
-    auto fd = fileno(f);
-    if (fcntl(fd, F_SETFD, FD_CLOEXEC) == -1)
-        throw spdlog_ex("fcntl with FD_CLOEXEC failed", errno);
-#endif
-}
-
-
-//fopen_s on non windows for writing
-inline int fopen_s(FILE** fp, const filename_t& filename, const filename_t& mode)
-{
-#ifdef _WIN32
-#ifdef SPDLOG_WCHAR_FILENAMES
-    *fp = _wfsopen((filename.c_str()), mode.c_str(), _SH_DENYWR);
-#else
-    *fp = _fsopen((filename.c_str()), mode.c_str(), _SH_DENYWR);
-#endif
-#else //unix
-    *fp = fopen((filename.c_str()), mode.c_str());
-#endif
-
-#ifdef SPDLOG_PREVENT_CHILD_FD
-    if (*fp != nullptr)
-        prevent_child_fd(*fp);
-#endif
-    return *fp == nullptr;
-}
-
-
-inline int remove(const filename_t &filename)
-{
-#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
-    return _wremove(filename.c_str());
-#else
-    return std::remove(filename.c_str());
-#endif
-}
-
-inline int rename(const filename_t& filename1, const filename_t& filename2)
-{
-#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
-    return _wrename(filename1.c_str(), filename2.c_str());
-#else
-    return std::rename(filename1.c_str(), filename2.c_str());
-#endif
-}
-
-
-//Return if file exists
-inline bool file_exists(const filename_t& filename)
-{
-#ifdef _WIN32
-#ifdef SPDLOG_WCHAR_FILENAMES
-    auto attribs = GetFileAttributesW(filename.c_str());
-#else
-    auto attribs = GetFileAttributesA(filename.c_str());
-#endif
-    return (attribs != INVALID_FILE_ATTRIBUTES && !(attribs & FILE_ATTRIBUTE_DIRECTORY));
-#else //common linux/unix all have the stat system call
-    struct stat buffer;
-    return (stat(filename.c_str(), &buffer) == 0);
-#endif
-}
-
-
-
-
-//Return file size according to open FILE* object
-inline size_t filesize(FILE *f)
-{
-    if (f == nullptr)
-        throw spdlog_ex("Failed getting file size. fd is null");
-#ifdef _WIN32
-    int fd = _fileno(f);
-#if _WIN64 //64 bits
-    struct _stat64 st;
-    if (_fstat64(fd, &st) == 0)
-        return st.st_size;
-
-#else //windows 32 bits
-    long ret = _filelength(fd);
-    if (ret >= 0)
-        return static_cast<size_t>(ret);
-#endif
-
-#else // unix
-    int fd = fileno(f);
-    //64 bits(but not in osx, where fstat64 is deprecated)
-#if !defined(__FreeBSD__) && !defined(__APPLE__) && (defined(__x86_64__) || defined(__ppc64__))
-    struct stat64 st;
-    if (fstat64(fd, &st) == 0)
-        return static_cast<size_t>(st.st_size);
-#else // unix 32 bits or osx
-    struct stat st;
-    if (fstat(fd, &st) == 0)
-        return static_cast<size_t>(st.st_size);
-#endif
-#endif
-    throw spdlog_ex("Failed getting file size from fd", errno);
-}
-
-
-
-
-//Return utc offset in minutes or throw spdlog_ex on failure
-inline int utc_minutes_offset(const std::tm& tm = details::os::localtime())
-{
-
-#ifdef _WIN32
-#if _WIN32_WINNT < _WIN32_WINNT_WS08
-    TIME_ZONE_INFORMATION tzinfo;
-    auto rv = GetTimeZoneInformation(&tzinfo);
-#else
-    DYNAMIC_TIME_ZONE_INFORMATION tzinfo;
-    auto rv = GetDynamicTimeZoneInformation(&tzinfo);
-#endif
-    if (rv == TIME_ZONE_ID_INVALID)
-        throw spdlog::spdlog_ex("Failed getting timezone info. ", errno);
-
-    int offset = -tzinfo.Bias;
-    if (tm.tm_isdst)
-        offset -= tzinfo.DaylightBias;
-    else
-        offset -= tzinfo.StandardBias;
-    return offset;
-#else
-
-#if defined(sun) || defined(__sun)
-    // 'tm_gmtoff' field is BSD extension and it's missing on SunOS/Solaris
-    struct helper
-    {
-        static long int calculate_gmt_offset(const std::tm & localtm = details::os::localtime(), const std::tm & gmtm = details::os::gmtime())
-        {
-            int local_year = localtm.tm_year + (1900 - 1);
-            int gmt_year = gmtm.tm_year + (1900 - 1);
-
-            long int days = (
-                                // difference in day of year
-                                localtm.tm_yday - gmtm.tm_yday
-
-                                // + intervening leap days
-                                + ((local_year >> 2) - (gmt_year >> 2))
-                                - (local_year / 100 - gmt_year / 100)
-                                + ((local_year / 100 >> 2) - (gmt_year / 100 >> 2))
-
-                                // + difference in years * 365 */
-                                + (long int)(local_year - gmt_year) * 365
-                            );
-
-            long int hours = (24 * days) + (localtm.tm_hour - gmtm.tm_hour);
-            long int mins = (60 * hours) + (localtm.tm_min - gmtm.tm_min);
-            long int secs = (60 * mins) + (localtm.tm_sec - gmtm.tm_sec);
-
-            return secs;
-        }
-    };
-
-    long int offset_seconds = helper::calculate_gmt_offset(tm);
-#else
-    long int offset_seconds = tm.tm_gmtoff;
-#endif
-
-    return static_cast<int>(offset_seconds / 60);
-#endif
-}
-
-//Return current thread id as size_t
-//It exists because the std::this_thread::get_id() is much slower(espcially under VS 2013)
-inline size_t _thread_id()
-{
-#ifdef _WIN32
-    return  static_cast<size_t>(::GetCurrentThreadId());
-#elif __linux__
-# if defined(__ANDROID__) && defined(__ANDROID_API__) && (__ANDROID_API__ < 21)
-#  define SYS_gettid __NR_gettid
-# endif
-    return  static_cast<size_t>(syscall(SYS_gettid));
-#elif __FreeBSD__
-    long tid;
-    thr_self(&tid);
-    return static_cast<size_t>(tid);
-#elif __APPLE__
-    uint64_t tid;
-    pthread_threadid_np(nullptr, &tid);
-    return static_cast<size_t>(tid);
-#else //Default to standard C++11 (other Unix)
-    return static_cast<size_t>(std::hash<std::thread::id>()(std::this_thread::get_id()));
-#endif
-}
-
-//Return current thread id as size_t (from thread local storage)
-inline size_t thread_id()
-{
-#if defined(_MSC_VER) && (_MSC_VER < 1900) || defined(__clang__) && !__has_feature(cxx_thread_local)
-    return _thread_id();
-#else
-    static thread_local const size_t tid = _thread_id();
-    return tid;
-#endif
-}
-
-
-
-
-// wchar support for windows file names (SPDLOG_WCHAR_FILENAMES must be defined)
-#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
-#define SPDLOG_FILENAME_T(s) L ## s
-inline std::string filename_to_str(const filename_t& filename)
-{
-    std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t> c;
-    return c.to_bytes(filename);
-}
-#else
-#define SPDLOG_FILENAME_T(s) s
-inline std::string filename_to_str(const filename_t& filename)
-{
-    return filename;
-}
-#endif
-
-inline std::string errno_to_string(char[256], char* res)
-{
-    return std::string(res);
-}
-
-inline std::string errno_to_string(char buf[256], int res)
-{
-    if (res == 0)
-    {
-        return std::string(buf);
-    }
-    else
-    {
-        return "Unknown error";
-    }
-}
-
-// Return errno string (thread safe)
-inline std::string errno_str(int err_num)
-{
-    char buf[256];
-    SPDLOG_CONSTEXPR auto buf_size = sizeof(buf);
-
-#ifdef _WIN32
-    if (strerror_s(buf, buf_size, err_num) == 0)
-        return std::string(buf);
-    else
-        return "Unknown error";
-
-#elif defined(__FreeBSD__) || defined(__APPLE__) || defined(ANDROID) || defined(__SUNPRO_CC) || \
-      ((_POSIX_C_SOURCE >= 200112L) && ! defined(_GNU_SOURCE)) // posix version
-
-    if (strerror_r(err_num, buf, buf_size) == 0)
-        return std::string(buf);
-    else
-        return "Unknown error";
-
-#else  // gnu version (might not use the given buf, so its retval pointer must be used)
-    auto err = strerror_r(err_num, buf, buf_size); // let compiler choose type
-    return errno_to_string(buf, err); // use overloading to select correct stringify function
-#endif
-}
-
-inline int pid()
-{
-
-#ifdef _WIN32
-    return ::_getpid();
-#else
-    return static_cast<int>(::getpid());
-#endif
-
-}
-
-
-// Detrmine if the terminal supports colors
-// Source: https://github.com/agauniyal/rang/
-inline bool is_color_terminal()
-{
-#ifdef _WIN32
-    return true;
-#else
-    static constexpr const char* Terms[] =
-    {
-        "ansi", "color", "console", "cygwin", "gnome", "konsole", "kterm",
-        "linux", "msys", "putty", "rxvt", "screen", "vt100", "xterm"
-    };
-
-    const char *env_p = std::getenv("TERM");
-    if (env_p == nullptr)
-    {
-        return false;
-    }
-
-    static const bool result = std::any_of(
-                                   std::begin(Terms), std::end(Terms), [&](const char* term)
-    {
-        return std::strstr(env_p, term) != nullptr;
-    });
-    return result;
-#endif
-}
-
-
-// Detrmine if the terminal attached
-// Source: https://github.com/agauniyal/rang/
-inline bool in_terminal(FILE* file)
-{
-
-#ifdef _WIN32
-    return _isatty(_fileno(file)) ? true : false;
-#else
-    return isatty(fileno(file)) ? true : false;
-#endif
-}
-} //os
-} //details
-} //spdlog
diff --git a/wasserstein/include/spdlog/details/pattern_formatter_impl.h b/wasserstein/include/spdlog/details/pattern_formatter_impl.h
deleted file mode 100644
index c1ce719..0000000
--- a/wasserstein/include/spdlog/details/pattern_formatter_impl.h
+++ /dev/null
@@ -1,690 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include "spdlog/formatter.h"
-#include "spdlog/details/log_msg.h"
-#include "spdlog/details/os.h"
-#include "spdlog/fmt/fmt.h"
-
-#include <chrono>
-#include <ctime>
-#include <memory>
-#include <mutex>
-#include <string>
-#include <thread>
-#include <utility>
-#include <vector>
-#include <array>
-
-namespace spdlog
-{
-namespace details
-{
-class flag_formatter
-{
-public:
-    virtual ~flag_formatter()
-    {}
-    virtual void format(details::log_msg& msg, const std::tm& tm_time) = 0;
-};
-
-///////////////////////////////////////////////////////////////////////
-// name & level pattern appenders
-///////////////////////////////////////////////////////////////////////
-namespace
-{
-class name_formatter:public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm&) override
-    {
-        msg.formatted << *msg.logger_name;
-    }
-};
-}
-
-// log level appender
-class level_formatter:public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm&) override
-    {
-        msg.formatted << level::to_str(msg.level);
-    }
-};
-
-// short log level appender
-class short_level_formatter:public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm&) override
-    {
-        msg.formatted << level::to_short_str(msg.level);
-    }
-};
-
-///////////////////////////////////////////////////////////////////////
-// Date time pattern appenders
-///////////////////////////////////////////////////////////////////////
-
-static const char* ampm(const tm& t)
-{
-    return t.tm_hour >= 12 ? "PM" : "AM";
-}
-
-static int to12h(const tm& t)
-{
-    return t.tm_hour > 12 ? t.tm_hour - 12 : t.tm_hour;
-}
-
-//Abbreviated weekday name
-using days_array = std::array<std::string, 7>;
-static const days_array& days()
-{
-    static const days_array arr{ { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" } };
-    return arr;
-}
-class a_formatter:public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-        msg.formatted << days()[tm_time.tm_wday];
-    }
-};
-// message counter formatter
-class i_formatter SPDLOG_FINAL:public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm&) override
-    {
-        msg.formatted << '#' << msg.msg_id;
-    }
-};
-//Full weekday name
-static const days_array& full_days()
-{
-    static const days_array arr{ { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" } };
-    return arr;
-}
-class A_formatter SPDLOG_FINAL :public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-        msg.formatted << full_days()[tm_time.tm_wday];
-    }
-};
-
-//Abbreviated month
-using months_array = std::array<std::string, 12>;
-static const months_array& months()
-{
-    static const months_array arr{ { "Jan", "Feb", "Mar", "Apr", "May", "June", "July", "Aug", "Sept", "Oct", "Nov", "Dec" } };
-    return arr;
-}
-class b_formatter:public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-        msg.formatted << months()[tm_time.tm_mon];
-    }
-};
-
-//Full month name
-static const months_array& full_months()
-{
-    static const months_array arr{ { "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" } };
-    return arr;
-}
-class B_formatter SPDLOG_FINAL :public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-        msg.formatted << full_months()[tm_time.tm_mon];
-    }
-};
-
-
-//write 2 ints seperated by sep with padding of 2
-static fmt::MemoryWriter& pad_n_join(fmt::MemoryWriter& w, int v1, int v2, char sep)
-{
-    w << fmt::pad(v1, 2, '0') << sep << fmt::pad(v2, 2, '0');
-    return w;
-}
-
-//write 3 ints seperated by sep with padding of 2
-static fmt::MemoryWriter& pad_n_join(fmt::MemoryWriter& w, int v1, int v2, int v3, char sep)
-{
-    w << fmt::pad(v1, 2, '0') << sep << fmt::pad(v2, 2, '0') << sep << fmt::pad(v3, 2, '0');
-    return w;
-}
-
-
-//Date and time representation (Thu Aug 23 15:35:46 2014)
-class c_formatter SPDLOG_FINAL:public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-        msg.formatted << days()[tm_time.tm_wday] << ' ' << months()[tm_time.tm_mon] << ' ' << tm_time.tm_mday << ' ';
-        pad_n_join(msg.formatted, tm_time.tm_hour, tm_time.tm_min, tm_time.tm_sec, ':') << ' ' << tm_time.tm_year + 1900;
-    }
-};
-
-
-// year - 2 digit
-class C_formatter SPDLOG_FINAL:public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-        msg.formatted << fmt::pad(tm_time.tm_year % 100, 2, '0');
-    }
-};
-
-
-
-// Short MM/DD/YY date, equivalent to %m/%d/%y 08/23/01
-class D_formatter SPDLOG_FINAL:public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-        pad_n_join(msg.formatted, tm_time.tm_mon + 1, tm_time.tm_mday, tm_time.tm_year % 100, '/');
-    }
-};
-
-
-// year - 4 digit
-class Y_formatter SPDLOG_FINAL:public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-        msg.formatted << tm_time.tm_year + 1900;
-    }
-};
-
-// month 1-12
-class m_formatter SPDLOG_FINAL:public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-        msg.formatted << fmt::pad(tm_time.tm_mon + 1, 2, '0');
-    }
-};
-
-// day of month 1-31
-class d_formatter SPDLOG_FINAL:public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-        msg.formatted << fmt::pad(tm_time.tm_mday, 2, '0');
-    }
-};
-
-// hours in 24 format  0-23
-class H_formatter SPDLOG_FINAL:public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-        msg.formatted << fmt::pad(tm_time.tm_hour, 2, '0');
-    }
-};
-
-// hours in 12 format  1-12
-class I_formatter SPDLOG_FINAL:public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-        msg.formatted << fmt::pad(to12h(tm_time), 2, '0');
-    }
-};
-
-// minutes 0-59
-class M_formatter SPDLOG_FINAL:public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-        msg.formatted << fmt::pad(tm_time.tm_min, 2, '0');
-    }
-};
-
-// seconds 0-59
-class S_formatter SPDLOG_FINAL:public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-        msg.formatted << fmt::pad(tm_time.tm_sec, 2, '0');
-    }
-};
-
-// milliseconds
-class e_formatter SPDLOG_FINAL:public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm&) override
-    {
-        auto duration = msg.time.time_since_epoch();
-        auto millis = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count() % 1000;
-        msg.formatted << fmt::pad(static_cast<int>(millis), 3, '0');
-    }
-};
-
-// microseconds
-class f_formatter SPDLOG_FINAL:public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm&) override
-    {
-        auto duration = msg.time.time_since_epoch();
-        auto micros = std::chrono::duration_cast<std::chrono::microseconds>(duration).count() % 1000000;
-        msg.formatted << fmt::pad(static_cast<int>(micros), 6, '0');
-    }
-};
-
-// nanoseconds
-class F_formatter SPDLOG_FINAL:public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm&) override
-    {
-        auto duration = msg.time.time_since_epoch();
-        auto ns = std::chrono::duration_cast<std::chrono::nanoseconds>(duration).count() % 1000000000;
-        msg.formatted << fmt::pad(static_cast<int>(ns), 9, '0');
-    }
-};
-
-// AM/PM
-class p_formatter SPDLOG_FINAL:public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-        msg.formatted << ampm(tm_time);
-    }
-};
-
-
-// 12 hour clock 02:55:02 pm
-class r_formatter SPDLOG_FINAL:public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-        pad_n_join(msg.formatted, to12h(tm_time), tm_time.tm_min, tm_time.tm_sec, ':') << ' ' << ampm(tm_time);
-    }
-};
-
-// 24-hour HH:MM time, equivalent to %H:%M
-class R_formatter SPDLOG_FINAL:public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-        pad_n_join(msg.formatted, tm_time.tm_hour, tm_time.tm_min, ':');
-    }
-};
-
-// ISO 8601 time format (HH:MM:SS), equivalent to %H:%M:%S
-class T_formatter SPDLOG_FINAL:public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-        pad_n_join(msg.formatted, tm_time.tm_hour, tm_time.tm_min, tm_time.tm_sec, ':');
-    }
-};
-
-// ISO 8601 offset from UTC in timezone (+-HH:MM)
-class z_formatter SPDLOG_FINAL:public flag_formatter
-{
-public:
-    const std::chrono::seconds cache_refresh = std::chrono::seconds(5);
-
-    z_formatter():_last_update(std::chrono::seconds(0)), _offset_minutes(0)
-    {}
-    z_formatter(const z_formatter&) = delete;
-    z_formatter& operator=(const z_formatter&) = delete;
-
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-#ifdef _WIN32
-        int total_minutes = get_cached_offset(msg, tm_time);
-#else
-        // No need to chache under gcc,
-        // it is very fast (already stored in tm.tm_gmtoff)
-        int total_minutes = os::utc_minutes_offset(tm_time);
-#endif
-        bool is_negative = total_minutes < 0;
-        char sign;
-        if (is_negative)
-        {
-            total_minutes = -total_minutes;
-            sign = '-';
-        }
-        else
-        {
-            sign = '+';
-        }
-
-        int h = total_minutes / 60;
-        int m = total_minutes % 60;
-        msg.formatted << sign;
-        pad_n_join(msg.formatted, h, m, ':');
-    }
-private:
-    log_clock::time_point _last_update;
-    int _offset_minutes;
-    std::mutex _mutex;
-
-    int get_cached_offset(const log_msg& msg, const std::tm& tm_time)
-    {
-        using namespace std::chrono;
-        std::lock_guard<std::mutex> l(_mutex);
-        if (msg.time - _last_update >= cache_refresh)
-        {
-            _offset_minutes = os::utc_minutes_offset(tm_time);
-            _last_update = msg.time;
-        }
-        return _offset_minutes;
-    }
-};
-
-
-
-// Thread id
-class t_formatter SPDLOG_FINAL:public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm&) override
-    {
-        msg.formatted << msg.thread_id;
-    }
-};
-
-// Current pid
-class pid_formatter SPDLOG_FINAL:public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm&) override
-    {
-        msg.formatted << details::os::pid();
-    }
-};
-
-
-class v_formatter SPDLOG_FINAL:public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm&) override
-    {
-        msg.formatted << fmt::StringRef(msg.raw.data(), msg.raw.size());
-    }
-};
-
-class ch_formatter SPDLOG_FINAL:public flag_formatter
-{
-public:
-    explicit ch_formatter(char ch): _ch(ch)
-    {}
-    void format(details::log_msg& msg, const std::tm&) override
-    {
-        msg.formatted << _ch;
-    }
-private:
-    char _ch;
-};
-
-
-//aggregate user chars to display as is
-class aggregate_formatter SPDLOG_FINAL:public flag_formatter
-{
-public:
-    aggregate_formatter()
-    {}
-    void add_ch(char ch)
-    {
-        _str += ch;
-    }
-    void format(details::log_msg& msg, const std::tm&) override
-    {
-        msg.formatted << _str;
-    }
-private:
-    std::string _str;
-};
-
-// Full info formatter
-// pattern: [%Y-%m-%d %H:%M:%S.%e] [%n] [%l] %v
-class full_formatter SPDLOG_FINAL:public flag_formatter
-{
-    void format(details::log_msg& msg, const std::tm& tm_time) override
-    {
-#ifndef SPDLOG_NO_DATETIME
-        auto duration = msg.time.time_since_epoch();
-        auto millis = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count() % 1000;
-
-        /* Slower version(while still very fast - about 3.2 million lines/sec under 10 threads),
-        msg.formatted.write("[{:d}-{:02d}-{:02d} {:02d}:{:02d}:{:02d}.{:03d}] [{}] [{}] {} ",
-        tm_time.tm_year + 1900,
-        tm_time.tm_mon + 1,
-        tm_time.tm_mday,
-        tm_time.tm_hour,
-        tm_time.tm_min,
-        tm_time.tm_sec,
-        static_cast<int>(millis),
-        msg.logger_name,
-        level::to_str(msg.level),
-        msg.raw.str());*/
-
-
-        // Faster (albeit uglier) way to format the line (5.6 million lines/sec under 10 threads)
-        msg.formatted << '[' << static_cast<unsigned int>(tm_time.tm_year + 1900) << '-'
-                      << fmt::pad(static_cast<unsigned int>(tm_time.tm_mon + 1), 2, '0') << '-'
-                      << fmt::pad(static_cast<unsigned int>(tm_time.tm_mday), 2, '0') << ' '
-                      << fmt::pad(static_cast<unsigned int>(tm_time.tm_hour), 2, '0') << ':'
-                      << fmt::pad(static_cast<unsigned int>(tm_time.tm_min), 2, '0') << ':'
-                      << fmt::pad(static_cast<unsigned int>(tm_time.tm_sec), 2, '0') << '.'
-                      << fmt::pad(static_cast<unsigned int>(millis), 3, '0') << "] ";
-
-        //no datetime needed
-#else
-        (void)tm_time;
-#endif
-
-#ifndef SPDLOG_NO_NAME
-        msg.formatted << '[' << *msg.logger_name << "] ";
-#endif
-
-        msg.formatted << '[' << level::to_str(msg.level) << "] ";
-        msg.formatted << fmt::StringRef(msg.raw.data(), msg.raw.size());
-    }
-};
-
-
-
-}
-}
-///////////////////////////////////////////////////////////////////////////////
-// pattern_formatter inline impl
-///////////////////////////////////////////////////////////////////////////////
-inline spdlog::pattern_formatter::pattern_formatter(const std::string& pattern, pattern_time_type pattern_time)
-    : _pattern_time(pattern_time)
-{
-    compile_pattern(pattern);
-}
-
-inline void spdlog::pattern_formatter::compile_pattern(const std::string& pattern)
-{
-    auto end = pattern.end();
-    std::unique_ptr<details::aggregate_formatter> user_chars;
-    for (auto it = pattern.begin(); it != end; ++it)
-    {
-        if (*it == '%')
-        {
-            if (user_chars) //append user chars found so far
-                _formatters.push_back(std::move(user_chars));
-
-            if (++it != end)
-                handle_flag(*it);
-            else
-                break;
-        }
-        else // chars not following the % sign should be displayed as is
-        {
-            if (!user_chars)
-                user_chars = std::unique_ptr<details::aggregate_formatter>(new details::aggregate_formatter());
-            user_chars->add_ch(*it);
-        }
-    }
-    if (user_chars) //append raw chars found so far
-    {
-        _formatters.push_back(std::move(user_chars));
-    }
-
-}
-inline void spdlog::pattern_formatter::handle_flag(char flag)
-{
-    switch (flag)
-    {
-    // logger name
-    case 'n':
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::name_formatter()));
-        break;
-
-    case 'l':
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::level_formatter()));
-        break;
-
-    case 'L':
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::short_level_formatter()));
-        break;
-
-    case('t'):
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::t_formatter()));
-        break;
-
-    case('v'):
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::v_formatter()));
-        break;
-
-    case('a'):
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::a_formatter()));
-        break;
-
-    case('A'):
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::A_formatter()));
-        break;
-
-    case('b'):
-    case('h'):
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::b_formatter()));
-        break;
-
-    case('B'):
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::B_formatter()));
-        break;
-    case('c'):
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::c_formatter()));
-        break;
-
-    case('C'):
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::C_formatter()));
-        break;
-
-    case('Y'):
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::Y_formatter()));
-        break;
-
-    case('D'):
-    case('x'):
-
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::D_formatter()));
-        break;
-
-    case('m'):
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::m_formatter()));
-        break;
-
-    case('d'):
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::d_formatter()));
-        break;
-
-    case('H'):
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::H_formatter()));
-        break;
-
-    case('I'):
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::I_formatter()));
-        break;
-
-    case('M'):
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::M_formatter()));
-        break;
-
-    case('S'):
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::S_formatter()));
-        break;
-
-    case('e'):
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::e_formatter()));
-        break;
-
-    case('f'):
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::f_formatter()));
-        break;
-    case('F'):
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::F_formatter()));
-        break;
-
-    case('p'):
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::p_formatter()));
-        break;
-
-    case('r'):
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::r_formatter()));
-        break;
-
-    case('R'):
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::R_formatter()));
-        break;
-
-    case('T'):
-    case('X'):
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::T_formatter()));
-        break;
-
-    case('z'):
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::z_formatter()));
-        break;
-
-    case ('+'):
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::full_formatter()));
-        break;
-
-    case ('P'):
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::pid_formatter()));
-        break;
-
-#if defined(SPDLOG_ENABLE_MESSAGE_COUNTER)
-    case ('i'):
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::i_formatter()));
-        break;
-#endif
-
-    default: //Unknown flag appears as is
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::ch_formatter('%')));
-        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::ch_formatter(flag)));
-        break;
-    }
-}
-
-inline std::tm spdlog::pattern_formatter::get_time(details::log_msg& msg)
-{
-    if (_pattern_time == pattern_time_type::local)
-        return details::os::localtime(log_clock::to_time_t(msg.time));
-    else
-        return details::os::gmtime(log_clock::to_time_t(msg.time));
-}
-
-inline void spdlog::pattern_formatter::format(details::log_msg& msg)
-{
-
-#ifndef SPDLOG_NO_DATETIME
-    auto tm_time = get_time(msg);
-#else
-    std::tm tm_time;
-#endif
-    for (auto &f : _formatters)
-    {
-        f->format(msg, tm_time);
-    }
-    //write eol
-    msg.formatted.write(details::os::eol, details::os::eol_size);
-}
diff --git a/wasserstein/include/spdlog/details/registry.h b/wasserstein/include/spdlog/details/registry.h
deleted file mode 100644
index b518990..0000000
--- a/wasserstein/include/spdlog/details/registry.h
+++ /dev/null
@@ -1,214 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-// Loggers registy of unique name->logger pointer
-// An attempt to create a logger with an already existing name will be ignored
-// If user requests a non existing logger, nullptr will be returned
-// This class is thread safe
-
-#include "spdlog/details/null_mutex.h"
-#include "spdlog/logger.h"
-#include "spdlog/async_logger.h"
-#include "spdlog/common.h"
-
-#include <chrono>
-#include <functional>
-#include <memory>
-#include <mutex>
-#include <string>
-#include <unordered_map>
-
-namespace spdlog
-{
-namespace details
-{
-template <class Mutex> class registry_t
-{
-public:
-
-    void register_logger(std::shared_ptr<logger> logger)
-    {
-        std::lock_guard<Mutex> lock(_mutex);
-        auto logger_name = logger->name();
-        throw_if_exists(logger_name);
-        _loggers[logger_name] = logger;
-    }
-
-
-    std::shared_ptr<logger> get(const std::string& logger_name)
-    {
-        std::lock_guard<Mutex> lock(_mutex);
-        auto found = _loggers.find(logger_name);
-        return found == _loggers.end() ? nullptr : found->second;
-    }
-
-    template<class It>
-    std::shared_ptr<logger> create(const std::string& logger_name, const It& sinks_begin, const It& sinks_end)
-    {
-        std::lock_guard<Mutex> lock(_mutex);
-        throw_if_exists(logger_name);
-        std::shared_ptr<logger> new_logger;
-        if (_async_mode)
-            new_logger = std::make_shared<async_logger>(logger_name, sinks_begin, sinks_end, _async_q_size, _overflow_policy, _worker_warmup_cb, _flush_interval_ms, _worker_teardown_cb);
-        else
-            new_logger = std::make_shared<logger>(logger_name, sinks_begin, sinks_end);
-
-        if (_formatter)
-            new_logger->set_formatter(_formatter);
-
-        if (_err_handler)
-            new_logger->set_error_handler(_err_handler);
-
-        new_logger->set_level(_level);
-
-
-        //Add to registry
-        _loggers[logger_name] = new_logger;
-        return new_logger;
-    }
-
-    template<class It>
-    std::shared_ptr<async_logger> create_async(const std::string& logger_name, size_t queue_size, const async_overflow_policy overflow_policy, const std::function<void()>& worker_warmup_cb, const std::chrono::milliseconds& flush_interval_ms, const std::function<void()>& worker_teardown_cb, const It& sinks_begin, const It& sinks_end)
-    {
-        std::lock_guard<Mutex> lock(_mutex);
-        throw_if_exists(logger_name);
-        auto new_logger = std::make_shared<async_logger>(logger_name, sinks_begin, sinks_end, queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb);
-
-        if (_formatter)
-            new_logger->set_formatter(_formatter);
-
-        if (_err_handler)
-            new_logger->set_error_handler(_err_handler);
-
-        new_logger->set_level(_level);
-
-        //Add to registry
-        _loggers[logger_name] = new_logger;
-        return new_logger;
-    }
-
-    void apply_all(std::function<void(std::shared_ptr<logger>)> fun)
-    {
-        std::lock_guard<Mutex> lock(_mutex);
-        for (auto &l : _loggers)
-            fun(l.second);
-    }
-
-    void drop(const std::string& logger_name)
-    {
-        std::lock_guard<Mutex> lock(_mutex);
-        _loggers.erase(logger_name);
-    }
-
-    void drop_all()
-    {
-        std::lock_guard<Mutex> lock(_mutex);
-        _loggers.clear();
-    }
-    std::shared_ptr<logger> create(const std::string& logger_name, sinks_init_list sinks)
-    {
-        return create(logger_name, sinks.begin(), sinks.end());
-    }
-
-    std::shared_ptr<logger> create(const std::string& logger_name, sink_ptr sink)
-    {
-        return create(logger_name, { sink });
-    }
-
-    std::shared_ptr<async_logger> create_async(const std::string& logger_name, size_t queue_size, const async_overflow_policy overflow_policy, const std::function<void()>& worker_warmup_cb, const std::chrono::milliseconds& flush_interval_ms, const std::function<void()>& worker_teardown_cb, sinks_init_list sinks)
-    {
-        return create_async(logger_name, queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb, sinks.begin(), sinks.end());
-    }
-
-    std::shared_ptr<async_logger> create_async(const std::string& logger_name, size_t queue_size, const async_overflow_policy overflow_policy, const std::function<void()>& worker_warmup_cb, const std::chrono::milliseconds& flush_interval_ms, const std::function<void()>& worker_teardown_cb, sink_ptr sink)
-    {
-        return create_async(logger_name, queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb, { sink });
-    }
-
-    void formatter(formatter_ptr f)
-    {
-        std::lock_guard<Mutex> lock(_mutex);
-        _formatter = f;
-        for (auto& l : _loggers)
-            l.second->set_formatter(_formatter);
-    }
-
-    void set_pattern(const std::string& pattern)
-    {
-        std::lock_guard<Mutex> lock(_mutex);
-        _formatter = std::make_shared<pattern_formatter>(pattern);
-        for (auto& l : _loggers)
-            l.second->set_formatter(_formatter);
-    }
-
-    void set_level(level::level_enum log_level)
-    {
-        std::lock_guard<Mutex> lock(_mutex);
-        for (auto& l : _loggers)
-            l.second->set_level(log_level);
-        _level = log_level;
-    }
-
-    void set_error_handler(log_err_handler handler)
-    {
-        for (auto& l : _loggers)
-            l.second->set_error_handler(handler);
-        _err_handler = handler;
-    }
-
-    void set_async_mode(size_t q_size, const async_overflow_policy overflow_policy, const std::function<void()>& worker_warmup_cb, const std::chrono::milliseconds& flush_interval_ms, const std::function<void()>& worker_teardown_cb)
-    {
-        std::lock_guard<Mutex> lock(_mutex);
-        _async_mode = true;
-        _async_q_size = q_size;
-        _overflow_policy = overflow_policy;
-        _worker_warmup_cb = worker_warmup_cb;
-        _flush_interval_ms = flush_interval_ms;
-        _worker_teardown_cb = worker_teardown_cb;
-    }
-
-    void set_sync_mode()
-    {
-        std::lock_guard<Mutex> lock(_mutex);
-        _async_mode = false;
-    }
-
-    static registry_t<Mutex>& instance()
-    {
-        static registry_t<Mutex> s_instance;
-        return s_instance;
-    }
-
-private:
-    registry_t<Mutex>() {}
-    registry_t<Mutex>(const registry_t<Mutex>&) = delete;
-    registry_t<Mutex>& operator=(const registry_t<Mutex>&) = delete;
-
-    void throw_if_exists(const std::string &logger_name)
-    {
-        if (_loggers.find(logger_name) != _loggers.end())
-            throw spdlog_ex("logger with name '" + logger_name + "' already exists");
-    }
-    Mutex _mutex;
-    std::unordered_map <std::string, std::shared_ptr<logger>> _loggers;
-    formatter_ptr _formatter;
-    level::level_enum _level = level::info;
-    log_err_handler _err_handler;
-    bool _async_mode = false;
-    size_t _async_q_size = 0;
-    async_overflow_policy _overflow_policy = async_overflow_policy::block_retry;
-    std::function<void()> _worker_warmup_cb = nullptr;
-    std::chrono::milliseconds _flush_interval_ms;
-    std::function<void()> _worker_teardown_cb = nullptr;
-};
-#ifdef SPDLOG_NO_REGISTRY_MUTEX
-typedef registry_t<spdlog::details::null_mutex> registry;
-#else
-typedef registry_t<std::mutex> registry;
-#endif
-}
-}
diff --git a/wasserstein/include/spdlog/details/spdlog_impl.h b/wasserstein/include/spdlog/details/spdlog_impl.h
deleted file mode 100644
index 7fe9ab4..0000000
--- a/wasserstein/include/spdlog/details/spdlog_impl.h
+++ /dev/null
@@ -1,263 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-//
-// Global registry functions
-//
-#include "spdlog/spdlog.h"
-#include "spdlog/details/registry.h"
-#include "spdlog/sinks/file_sinks.h"
-#include "spdlog/sinks/stdout_sinks.h"
-#ifdef SPDLOG_ENABLE_SYSLOG
-#include "spdlog/sinks/syslog_sink.h"
-#endif
-
-#ifdef _WIN32
-#include "spdlog/sinks/wincolor_sink.h"
-#else
-#include "spdlog/sinks/ansicolor_sink.h"
-#endif
-
-
-#ifdef __ANDROID__
-#include "spdlog/sinks/android_sink.h"
-#endif
-
-#include <chrono>
-#include <functional>
-#include <memory>
-#include <string>
-
-inline void spdlog::register_logger(std::shared_ptr<logger> logger)
-{
-    return details::registry::instance().register_logger(logger);
-}
-
-inline std::shared_ptr<spdlog::logger> spdlog::get(const std::string& name)
-{
-    return details::registry::instance().get(name);
-}
-
-inline void spdlog::drop(const std::string &name)
-{
-    details::registry::instance().drop(name);
-}
-
-// Create multi/single threaded simple file logger
-inline std::shared_ptr<spdlog::logger> spdlog::basic_logger_mt(const std::string& logger_name, const filename_t& filename, bool truncate)
-{
-    return create<spdlog::sinks::simple_file_sink_mt>(logger_name, filename, truncate);
-}
-
-inline std::shared_ptr<spdlog::logger> spdlog::basic_logger_st(const std::string& logger_name, const filename_t& filename, bool truncate)
-{
-    return create<spdlog::sinks::simple_file_sink_st>(logger_name, filename, truncate);
-}
-
-// Create multi/single threaded rotating file logger
-inline std::shared_ptr<spdlog::logger> spdlog::rotating_logger_mt(const std::string& logger_name, const filename_t& filename, size_t max_file_size, size_t max_files)
-{
-    return create<spdlog::sinks::rotating_file_sink_mt>(logger_name, filename, max_file_size, max_files);
-}
-
-inline std::shared_ptr<spdlog::logger> spdlog::rotating_logger_st(const std::string& logger_name, const filename_t& filename, size_t max_file_size, size_t max_files)
-{
-    return create<spdlog::sinks::rotating_file_sink_st>(logger_name, filename, max_file_size, max_files);
-}
-
-// Create file logger which creates new file at midnight):
-inline std::shared_ptr<spdlog::logger> spdlog::daily_logger_mt(const std::string& logger_name, const filename_t& filename, int hour, int minute)
-{
-    return create<spdlog::sinks::daily_file_sink_mt>(logger_name, filename, hour, minute);
-}
-
-inline std::shared_ptr<spdlog::logger> spdlog::daily_logger_st(const std::string& logger_name, const filename_t& filename, int hour, int minute)
-{
-    return create<spdlog::sinks::daily_file_sink_st>(logger_name, filename, hour, minute);
-}
-
-
-//
-// stdout/stderr loggers
-//
-inline std::shared_ptr<spdlog::logger> spdlog::stdout_logger_mt(const std::string& logger_name)
-{
-    return spdlog::details::registry::instance().create(logger_name, spdlog::sinks::stdout_sink_mt::instance());
-}
-
-inline std::shared_ptr<spdlog::logger> spdlog::stdout_logger_st(const std::string& logger_name)
-{
-    return spdlog::details::registry::instance().create(logger_name, spdlog::sinks::stdout_sink_st::instance());
-}
-
-inline std::shared_ptr<spdlog::logger> spdlog::stderr_logger_mt(const std::string& logger_name)
-{
-    return spdlog::details::registry::instance().create(logger_name, spdlog::sinks::stderr_sink_mt::instance());
-}
-
-inline std::shared_ptr<spdlog::logger> spdlog::stderr_logger_st(const std::string& logger_name)
-{
-    return spdlog::details::registry::instance().create(logger_name, spdlog::sinks::stderr_sink_st::instance());
-}
-
-//
-// stdout/stderr color loggers
-//
-#ifdef _WIN32
-inline std::shared_ptr<spdlog::logger> spdlog::stdout_color_mt(const std::string& logger_name)
-{
-    auto sink = std::make_shared<spdlog::sinks::wincolor_stdout_sink_mt>();
-    return spdlog::details::registry::instance().create(logger_name, sink);
-}
-
-inline std::shared_ptr<spdlog::logger> spdlog::stdout_color_st(const std::string& logger_name)
-{
-    auto sink = std::make_shared<spdlog::sinks::wincolor_stdout_sink_st>();
-    return spdlog::details::registry::instance().create(logger_name, sink);
-}
-
-inline std::shared_ptr<spdlog::logger> spdlog::stderr_color_mt(const std::string& logger_name)
-{
-    auto sink = std::make_shared<spdlog::sinks::wincolor_stderr_sink_mt>();
-    return spdlog::details::registry::instance().create(logger_name, sink);
-}
-
-
-inline std::shared_ptr<spdlog::logger> spdlog::stderr_color_st(const std::string& logger_name)
-{
-    auto sink = std::make_shared<spdlog::sinks::wincolor_stderr_sink_st>();
-    return spdlog::details::registry::instance().create(logger_name, sink);
-}
-
-#else //ansi terminal colors
-
-inline std::shared_ptr<spdlog::logger> spdlog::stdout_color_mt(const std::string& logger_name)
-{
-    auto sink = std::make_shared<spdlog::sinks::ansicolor_stdout_sink_mt>();
-    return spdlog::details::registry::instance().create(logger_name, sink);
-}
-
-inline std::shared_ptr<spdlog::logger> spdlog::stdout_color_st(const std::string& logger_name)
-{
-    auto sink = std::make_shared<spdlog::sinks::ansicolor_stdout_sink_st>();
-    return spdlog::details::registry::instance().create(logger_name, sink);
-}
-
-inline std::shared_ptr<spdlog::logger> spdlog::stderr_color_mt(const std::string& logger_name)
-{
-    auto sink = std::make_shared<spdlog::sinks::ansicolor_stderr_sink_mt>();
-    return spdlog::details::registry::instance().create(logger_name, sink);
-}
-
-inline std::shared_ptr<spdlog::logger> spdlog::stderr_color_st(const std::string& logger_name)
-{
-    auto sink = std::make_shared<spdlog::sinks::ansicolor_stderr_sink_st>();
-    return spdlog::details::registry::instance().create(logger_name, sink);
-}
-#endif
-
-#ifdef SPDLOG_ENABLE_SYSLOG
-// Create syslog logger
-inline std::shared_ptr<spdlog::logger> spdlog::syslog_logger(const std::string& logger_name, const std::string& syslog_ident, int syslog_option)
-{
-    return create<spdlog::sinks::syslog_sink>(logger_name, syslog_ident, syslog_option);
-}
-#endif
-
-#ifdef __ANDROID__
-inline std::shared_ptr<spdlog::logger> spdlog::android_logger(const std::string& logger_name, const std::string& tag)
-{
-    return create<spdlog::sinks::android_sink>(logger_name, tag);
-}
-#endif
-
-// Create and register a logger a single sink
-inline std::shared_ptr<spdlog::logger> spdlog::create(const std::string& logger_name, const spdlog::sink_ptr& sink)
-{
-    return details::registry::instance().create(logger_name, sink);
-}
-
-//Create logger with multiple sinks
-
-inline std::shared_ptr<spdlog::logger> spdlog::create(const std::string& logger_name, spdlog::sinks_init_list sinks)
-{
-    return details::registry::instance().create(logger_name, sinks);
-}
-
-
-template <typename Sink, typename... Args>
-inline std::shared_ptr<spdlog::logger> spdlog::create(const std::string& logger_name, Args... args)
-{
-    sink_ptr sink = std::make_shared<Sink>(args...);
-    return details::registry::instance().create(logger_name, { sink });
-}
-
-
-template<class It>
-inline std::shared_ptr<spdlog::logger> spdlog::create(const std::string& logger_name, const It& sinks_begin, const It& sinks_end)
-{
-    return details::registry::instance().create(logger_name, sinks_begin, sinks_end);
-}
-
-// Create and register an async logger with a single sink
-inline std::shared_ptr<spdlog::logger> spdlog::create_async(const std::string& logger_name, const sink_ptr& sink, size_t queue_size, const async_overflow_policy overflow_policy, const std::function<void()>& worker_warmup_cb, const std::chrono::milliseconds& flush_interval_ms, const std::function<void()>& worker_teardown_cb)
-{
-    return details::registry::instance().create_async(logger_name, queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb, sink);
-}
-
-// Create and register an async logger with multiple sinks
-inline std::shared_ptr<spdlog::logger> spdlog::create_async(const std::string& logger_name, sinks_init_list sinks, size_t queue_size, const async_overflow_policy overflow_policy, const std::function<void()>& worker_warmup_cb, const std::chrono::milliseconds& flush_interval_ms, const std::function<void()>& worker_teardown_cb )
-{
-    return details::registry::instance().create_async(logger_name, queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb, sinks);
-}
-
-template<class It>
-inline std::shared_ptr<spdlog::logger> spdlog::create_async(const std::string& logger_name, const It& sinks_begin, const It& sinks_end, size_t queue_size, const async_overflow_policy overflow_policy, const std::function<void()>& worker_warmup_cb, const std::chrono::milliseconds& flush_interval_ms, const std::function<void()>& worker_teardown_cb)
-{
-    return details::registry::instance().create_async(logger_name, queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb, sinks_begin, sinks_end);
-}
-
-inline void spdlog::set_formatter(spdlog::formatter_ptr f)
-{
-    details::registry::instance().formatter(f);
-}
-
-inline void spdlog::set_pattern(const std::string& format_string)
-{
-    return details::registry::instance().set_pattern(format_string);
-}
-
-inline void spdlog::set_level(level::level_enum log_level)
-{
-    return details::registry::instance().set_level(log_level);
-}
-
-inline void spdlog::set_error_handler(log_err_handler handler)
-{
-    return details::registry::instance().set_error_handler(handler);
-}
-
-
-inline void spdlog::set_async_mode(size_t queue_size, const async_overflow_policy overflow_policy, const std::function<void()>& worker_warmup_cb, const std::chrono::milliseconds& flush_interval_ms, const std::function<void()>& worker_teardown_cb)
-{
-    details::registry::instance().set_async_mode(queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb);
-}
-
-inline void spdlog::set_sync_mode()
-{
-    details::registry::instance().set_sync_mode();
-}
-
-inline void spdlog::apply_all(std::function<void(std::shared_ptr<logger>)> fun)
-{
-    details::registry::instance().apply_all(fun);
-}
-
-inline void spdlog::drop_all()
-{
-    details::registry::instance().drop_all();
-}
diff --git a/wasserstein/include/spdlog/fmt/bundled/format.cc b/wasserstein/include/spdlog/fmt/bundled/format.cc
deleted file mode 100644
index 2bd774e..0000000
--- a/wasserstein/include/spdlog/fmt/bundled/format.cc
+++ /dev/null
@@ -1,940 +0,0 @@
-/*
- Formatting library for C++
-
- Copyright (c) 2012 - 2016, Victor Zverovich
- All rights reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice, this
-    list of conditions and the following disclaimer.
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
- ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "format.h"
-
-#include <string.h>
-
-#include <cctype>
-#include <cerrno>
-#include <climits>
-#include <cmath>
-#include <cstdarg>
-#include <cstddef>  // for std::ptrdiff_t
-
-#if defined(_WIN32) && defined(__MINGW32__)
-# include <cstring>
-#endif
-
-#if FMT_USE_WINDOWS_H
-# if defined(NOMINMAX) || defined(FMT_WIN_MINMAX)
-#  include <windows.h>
-# else
-#  define NOMINMAX
-#  include <windows.h>
-#  undef NOMINMAX
-# endif
-#endif
-
-using fmt::internal::Arg;
-
-#if FMT_EXCEPTIONS
-# define FMT_TRY try
-# define FMT_CATCH(x) catch (x)
-#else
-# define FMT_TRY if (true)
-# define FMT_CATCH(x) if (false)
-#endif
-
-#ifdef _MSC_VER
-# pragma warning(push)
-# pragma warning(disable: 4127)  // conditional expression is constant
-# pragma warning(disable: 4702)  // unreachable code
-// Disable deprecation warning for strerror. The latter is not called but
-// MSVC fails to detect it.
-# pragma warning(disable: 4996)
-#endif
-
-// Dummy implementations of strerror_r and strerror_s called if corresponding
-// system functions are not available.
-static inline fmt::internal::Null<> strerror_r(int, char *, ...) {
-  return fmt::internal::Null<>();
-}
-static inline fmt::internal::Null<> strerror_s(char *, std::size_t, ...) {
-  return fmt::internal::Null<>();
-}
-
-namespace fmt {
-
-FMT_FUNC internal::RuntimeError::~RuntimeError() throw() {}
-FMT_FUNC FormatError::~FormatError() throw() {}
-FMT_FUNC SystemError::~SystemError() throw() {}
-
-namespace {
-
-#ifndef _MSC_VER
-# define FMT_SNPRINTF snprintf
-#else  // _MSC_VER
-inline int fmt_snprintf(char *buffer, size_t size, const char *format, ...) {
-  va_list args;
-  va_start(args, format);
-  int result = vsnprintf_s(buffer, size, _TRUNCATE, format, args);
-  va_end(args);
-  return result;
-}
-# define FMT_SNPRINTF fmt_snprintf
-#endif  // _MSC_VER
-
-#if defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT)
-# define FMT_SWPRINTF snwprintf
-#else
-# define FMT_SWPRINTF swprintf
-#endif // defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT)
-
-// Checks if a value fits in int - used to avoid warnings about comparing
-// signed and unsigned integers.
-template <bool IsSigned>
-struct IntChecker {
-  template <typename T>
-  static bool fits_in_int(T value) {
-    unsigned max = INT_MAX;
-    return value <= max;
-  }
-  static bool fits_in_int(bool) { return true; }
-};
-
-template <>
-struct IntChecker<true> {
-  template <typename T>
-  static bool fits_in_int(T value) {
-    return value >= INT_MIN && value <= INT_MAX;
-  }
-  static bool fits_in_int(int) { return true; }
-};
-
-const char RESET_COLOR[] = "\x1b[0m";
-
-typedef void (*FormatFunc)(Writer &, int, StringRef);
-
-// Portable thread-safe version of strerror.
-// Sets buffer to point to a string describing the error code.
-// This can be either a pointer to a string stored in buffer,
-// or a pointer to some static immutable string.
-// Returns one of the following values:
-//   0      - success
-//   ERANGE - buffer is not large enough to store the error message
-//   other  - failure
-// Buffer should be at least of size 1.
-int safe_strerror(
-    int error_code, char *&buffer, std::size_t buffer_size) FMT_NOEXCEPT {
-  FMT_ASSERT(buffer != 0 && buffer_size != 0, "invalid buffer");
-
-  class StrError {
-   private:
-    int error_code_;
-    char *&buffer_;
-    std::size_t buffer_size_;
-
-    // A noop assignment operator to avoid bogus warnings.
-    void operator=(const StrError &) {}
-
-    // Handle the result of XSI-compliant version of strerror_r.
-    int handle(int result) {
-      // glibc versions before 2.13 return result in errno.
-      return result == -1 ? errno : result;
-    }
-
-    // Handle the result of GNU-specific version of strerror_r.
-    int handle(char *message) {
-      // If the buffer is full then the message is probably truncated.
-      if (message == buffer_ && strlen(buffer_) == buffer_size_ - 1)
-        return ERANGE;
-      buffer_ = message;
-      return 0;
-    }
-
-    // Handle the case when strerror_r is not available.
-    int handle(internal::Null<>) {
-      return fallback(strerror_s(buffer_, buffer_size_, error_code_));
-    }
-
-    // Fallback to strerror_s when strerror_r is not available.
-    int fallback(int result) {
-      // If the buffer is full then the message is probably truncated.
-      return result == 0 && strlen(buffer_) == buffer_size_ - 1 ?
-            ERANGE : result;
-    }
-
-    // Fallback to strerror if strerror_r and strerror_s are not available.
-    int fallback(internal::Null<>) {
-      errno = 0;
-      buffer_ = strerror(error_code_);
-      return errno;
-    }
-
-   public:
-    StrError(int err_code, char *&buf, std::size_t buf_size)
-      : error_code_(err_code), buffer_(buf), buffer_size_(buf_size) {}
-
-    int run() {
-      strerror_r(0, 0, "");  // Suppress a warning about unused strerror_r.
-      return handle(strerror_r(error_code_, buffer_, buffer_size_));
-    }
-  };
-  return StrError(error_code, buffer, buffer_size).run();
-}
-
-void format_error_code(Writer &out, int error_code,
-                       StringRef message) FMT_NOEXCEPT {
-  // Report error code making sure that the output fits into
-  // INLINE_BUFFER_SIZE to avoid dynamic memory allocation and potential
-  // bad_alloc.
-  out.clear();
-  static const char SEP[] = ": ";
-  static const char ERROR_STR[] = "error ";
-  // Subtract 2 to account for terminating null characters in SEP and ERROR_STR.
-  std::size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2;
-  typedef internal::IntTraits<int>::MainType MainType;
-  MainType abs_value = static_cast<MainType>(error_code);
-  if (internal::is_negative(error_code)) {
-    abs_value = 0 - abs_value;
-    ++error_code_size;
-  }
-  error_code_size += internal::count_digits(abs_value);
-  if (message.size() <= internal::INLINE_BUFFER_SIZE - error_code_size)
-    out << message << SEP;
-  out << ERROR_STR << error_code;
-  assert(out.size() <= internal::INLINE_BUFFER_SIZE);
-}
-
-void report_error(FormatFunc func, int error_code,
-                  StringRef message) FMT_NOEXCEPT {
-  MemoryWriter full_message;
-  func(full_message, error_code, message);
-  // Use Writer::data instead of Writer::c_str to avoid potential memory
-  // allocation.
-  std::fwrite(full_message.data(), full_message.size(), 1, stderr);
-  std::fputc('\n', stderr);
-}
-
-// IsZeroInt::visit(arg) returns true iff arg is a zero integer.
-class IsZeroInt : public ArgVisitor<IsZeroInt, bool> {
- public:
-  template <typename T>
-  bool visit_any_int(T value) { return value == 0; }
-};
-
-// Checks if an argument is a valid printf width specifier and sets
-// left alignment if it is negative.
-class WidthHandler : public ArgVisitor<WidthHandler, unsigned> {
- private:
-  FormatSpec &spec_;
-
-  FMT_DISALLOW_COPY_AND_ASSIGN(WidthHandler);
-
- public:
-  explicit WidthHandler(FormatSpec &spec) : spec_(spec) {}
-
-  void report_unhandled_arg() {
-    FMT_THROW(FormatError("width is not integer"));
-  }
-
-  template <typename T>
-  unsigned visit_any_int(T value) {
-    typedef typename internal::IntTraits<T>::MainType UnsignedType;
-    UnsignedType width = static_cast<UnsignedType>(value);
-    if (internal::is_negative(value)) {
-      spec_.align_ = ALIGN_LEFT;
-      width = 0 - width;
-    }
-    if (width > INT_MAX)
-      FMT_THROW(FormatError("number is too big"));
-    return static_cast<unsigned>(width);
-  }
-};
-
-class PrecisionHandler : public ArgVisitor<PrecisionHandler, int> {
- public:
-  void report_unhandled_arg() {
-    FMT_THROW(FormatError("precision is not integer"));
-  }
-
-  template <typename T>
-  int visit_any_int(T value) {
-    if (!IntChecker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
-      FMT_THROW(FormatError("number is too big"));
-    return static_cast<int>(value);
-  }
-};
-
-template <typename T, typename U>
-struct is_same {
-  enum { value = 0 };
-};
-
-template <typename T>
-struct is_same<T, T> {
-  enum { value = 1 };
-};
-
-// An argument visitor that converts an integer argument to T for printf,
-// if T is an integral type. If T is void, the argument is converted to
-// corresponding signed or unsigned type depending on the type specifier:
-// 'd' and 'i' - signed, other - unsigned)
-template <typename T = void>
-class ArgConverter : public ArgVisitor<ArgConverter<T>, void> {
- private:
-  internal::Arg &arg_;
-  wchar_t type_;
-
-  FMT_DISALLOW_COPY_AND_ASSIGN(ArgConverter);
-
- public:
-  ArgConverter(internal::Arg &arg, wchar_t type)
-    : arg_(arg), type_(type) {}
-
-  void visit_bool(bool value) {
-    if (type_ != 's')
-      visit_any_int(value);
-  }
-
-  template <typename U>
-  void visit_any_int(U value) {
-    bool is_signed = type_ == 'd' || type_ == 'i';
-    using internal::Arg;
-    typedef typename internal::Conditional<
-        is_same<T, void>::value, U, T>::type TargetType;
-    if (sizeof(TargetType) <= sizeof(int)) {
-      // Extra casts are used to silence warnings.
-      if (is_signed) {
-        arg_.type = Arg::INT;
-        arg_.int_value = static_cast<int>(static_cast<TargetType>(value));
-      } else {
-        arg_.type = Arg::UINT;
-        typedef typename internal::MakeUnsigned<TargetType>::Type Unsigned;
-        arg_.uint_value = static_cast<unsigned>(static_cast<Unsigned>(value));
-      }
-    } else {
-      if (is_signed) {
-        arg_.type = Arg::LONG_LONG;
-        // glibc's printf doesn't sign extend arguments of smaller types:
-        //   std::printf("%lld", -42);  // prints "4294967254"
-        // but we don't have to do the same because it's a UB.
-        arg_.long_long_value = static_cast<LongLong>(value);
-      } else {
-        arg_.type = Arg::ULONG_LONG;
-        arg_.ulong_long_value =
-            static_cast<typename internal::MakeUnsigned<U>::Type>(value);
-      }
-    }
-  }
-};
-
-// Converts an integer argument to char for printf.
-class CharConverter : public ArgVisitor<CharConverter, void> {
- private:
-  internal::Arg &arg_;
-
-  FMT_DISALLOW_COPY_AND_ASSIGN(CharConverter);
-
- public:
-  explicit CharConverter(internal::Arg &arg) : arg_(arg) {}
-
-  template <typename T>
-  void visit_any_int(T value) {
-    arg_.type = internal::Arg::CHAR;
-    arg_.int_value = static_cast<char>(value);
-  }
-};
-}  // namespace
-
-namespace internal {
-
-template <typename Char>
-class PrintfArgFormatter :
-    public ArgFormatterBase<PrintfArgFormatter<Char>, Char> {
-
-  void write_null_pointer() {
-    this->spec().type_ = 0;
-    this->write("(nil)");
-  }
-
-  typedef ArgFormatterBase<PrintfArgFormatter<Char>, Char> Base;
-
- public:
-  PrintfArgFormatter(BasicWriter<Char> &w, FormatSpec &s)
-  : ArgFormatterBase<PrintfArgFormatter<Char>, Char>(w, s) {}
-
-  void visit_bool(bool value) {
-    FormatSpec &fmt_spec = this->spec();
-    if (fmt_spec.type_ != 's')
-      return this->visit_any_int(value);
-    fmt_spec.type_ = 0;
-    this->write(value);
-  }
-
-  void visit_char(int value) {
-    const FormatSpec &fmt_spec = this->spec();
-    BasicWriter<Char> &w = this->writer();
-    if (fmt_spec.type_ && fmt_spec.type_ != 'c')
-      w.write_int(value, fmt_spec);
-    typedef typename BasicWriter<Char>::CharPtr CharPtr;
-    CharPtr out = CharPtr();
-    if (fmt_spec.width_ > 1) {
-      Char fill = ' ';
-      out = w.grow_buffer(fmt_spec.width_);
-      if (fmt_spec.align_ != ALIGN_LEFT) {
-        std::fill_n(out, fmt_spec.width_ - 1, fill);
-        out += fmt_spec.width_ - 1;
-      } else {
-        std::fill_n(out + 1, fmt_spec.width_ - 1, fill);
-      }
-    } else {
-      out = w.grow_buffer(1);
-    }
-    *out = static_cast<Char>(value);
-  }
-
-  void visit_cstring(const char *value) {
-    if (value)
-      Base::visit_cstring(value);
-    else if (this->spec().type_ == 'p')
-      write_null_pointer();
-    else
-      this->write("(null)");
-  }
-
-  void visit_pointer(const void *value) {
-    if (value)
-      return Base::visit_pointer(value);
-    this->spec().type_ = 0;
-    write_null_pointer();
-  }
-
-  void visit_custom(Arg::CustomValue c) {
-    BasicFormatter<Char> formatter(ArgList(), this->writer());
-    const Char format_str[] = {'}', 0};
-    const Char *format = format_str;
-    c.format(&formatter, c.value, &format);
-  }
-};
-}  // namespace internal
-}  // namespace fmt
-
-FMT_FUNC void fmt::SystemError::init(
-    int err_code, CStringRef format_str, ArgList args) {
-  error_code_ = err_code;
-  MemoryWriter w;
-  internal::format_system_error(w, err_code, format(format_str, args));
-  std::runtime_error &base = *this;
-  base = std::runtime_error(w.str());
-}
-
-template <typename T>
-int fmt::internal::CharTraits<char>::format_float(
-    char *buffer, std::size_t size, const char *format,
-    unsigned width, int precision, T value) {
-  if (width == 0) {
-    return precision < 0 ?
-        FMT_SNPRINTF(buffer, size, format, value) :
-        FMT_SNPRINTF(buffer, size, format, precision, value);
-  }
-  return precision < 0 ?
-      FMT_SNPRINTF(buffer, size, format, width, value) :
-      FMT_SNPRINTF(buffer, size, format, width, precision, value);
-}
-
-template <typename T>
-int fmt::internal::CharTraits<wchar_t>::format_float(
-    wchar_t *buffer, std::size_t size, const wchar_t *format,
-    unsigned width, int precision, T value) {
-  if (width == 0) {
-    return precision < 0 ?
-        FMT_SWPRINTF(buffer, size, format, value) :
-        FMT_SWPRINTF(buffer, size, format, precision, value);
-  }
-  return precision < 0 ?
-      FMT_SWPRINTF(buffer, size, format, width, value) :
-      FMT_SWPRINTF(buffer, size, format, width, precision, value);
-}
-
-template <typename T>
-const char fmt::internal::BasicData<T>::DIGITS[] =
-    "0001020304050607080910111213141516171819"
-    "2021222324252627282930313233343536373839"
-    "4041424344454647484950515253545556575859"
-    "6061626364656667686970717273747576777879"
-    "8081828384858687888990919293949596979899";
-
-#define FMT_POWERS_OF_10(factor) \
-  factor * 10, \
-  factor * 100, \
-  factor * 1000, \
-  factor * 10000, \
-  factor * 100000, \
-  factor * 1000000, \
-  factor * 10000000, \
-  factor * 100000000, \
-  factor * 1000000000
-
-template <typename T>
-const uint32_t fmt::internal::BasicData<T>::POWERS_OF_10_32[] = {
-  0, FMT_POWERS_OF_10(1)
-};
-
-template <typename T>
-const uint64_t fmt::internal::BasicData<T>::POWERS_OF_10_64[] = {
-  0,
-  FMT_POWERS_OF_10(1),
-  FMT_POWERS_OF_10(fmt::ULongLong(1000000000)),
-  // Multiply several constants instead of using a single long long constant
-  // to avoid warnings about C++98 not supporting long long.
-  fmt::ULongLong(1000000000) * fmt::ULongLong(1000000000) * 10
-};
-
-FMT_FUNC void fmt::internal::report_unknown_type(char code, const char *type) {
-  (void)type;
-  if (std::isprint(static_cast<unsigned char>(code))) {
-    FMT_THROW(fmt::FormatError(
-        fmt::format("unknown format code '{}' for {}", code, type)));
-  }
-  FMT_THROW(fmt::FormatError(
-      fmt::format("unknown format code '\\x{:02x}' for {}",
-        static_cast<unsigned>(code), type)));
-}
-
-#if FMT_USE_WINDOWS_H
-
-FMT_FUNC fmt::internal::UTF8ToUTF16::UTF8ToUTF16(fmt::StringRef s) {
-  static const char ERROR_MSG[] = "cannot convert string from UTF-8 to UTF-16";
-  if (s.size() > INT_MAX)
-    FMT_THROW(WindowsError(ERROR_INVALID_PARAMETER, ERROR_MSG));
-  int s_size = static_cast<int>(s.size());
-  int length = MultiByteToWideChar(
-      CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, 0, 0);
-  if (length == 0)
-    FMT_THROW(WindowsError(GetLastError(), ERROR_MSG));
-  buffer_.resize(length + 1);
-  length = MultiByteToWideChar(
-    CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, &buffer_[0], length);
-  if (length == 0)
-    FMT_THROW(WindowsError(GetLastError(), ERROR_MSG));
-  buffer_[length] = 0;
-}
-
-FMT_FUNC fmt::internal::UTF16ToUTF8::UTF16ToUTF8(fmt::WStringRef s) {
-  if (int error_code = convert(s)) {
-    FMT_THROW(WindowsError(error_code,
-        "cannot convert string from UTF-16 to UTF-8"));
-  }
-}
-
-FMT_FUNC int fmt::internal::UTF16ToUTF8::convert(fmt::WStringRef s) {
-  if (s.size() > INT_MAX)
-    return ERROR_INVALID_PARAMETER;
-  int s_size = static_cast<int>(s.size());
-  int length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, 0, 0, 0, 0);
-  if (length == 0)
-    return GetLastError();
-  buffer_.resize(length + 1);
-  length = WideCharToMultiByte(
-    CP_UTF8, 0, s.data(), s_size, &buffer_[0], length, 0, 0);
-  if (length == 0)
-    return GetLastError();
-  buffer_[length] = 0;
-  return 0;
-}
-
-FMT_FUNC void fmt::WindowsError::init(
-    int err_code, CStringRef format_str, ArgList args) {
-  error_code_ = err_code;
-  MemoryWriter w;
-  internal::format_windows_error(w, err_code, format(format_str, args));
-  std::runtime_error &base = *this;
-  base = std::runtime_error(w.str());
-}
-
-FMT_FUNC void fmt::internal::format_windows_error(
-    fmt::Writer &out, int error_code,
-    fmt::StringRef message) FMT_NOEXCEPT {
-  FMT_TRY {
-    MemoryBuffer<wchar_t, INLINE_BUFFER_SIZE> buffer;
-    buffer.resize(INLINE_BUFFER_SIZE);
-    for (;;) {
-      wchar_t *system_message = &buffer[0];
-      int result = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
-                                  0, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-                                  system_message, static_cast<uint32_t>(buffer.size()), 0);
-      if (result != 0) {
-        UTF16ToUTF8 utf8_message;
-        if (utf8_message.convert(system_message) == ERROR_SUCCESS) {
-          out << message << ": " << utf8_message;
-          return;
-        }
-        break;
-      }
-      if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
-        break;  // Can't get error message, report error code instead.
-      buffer.resize(buffer.size() * 2);
-    }
-  } FMT_CATCH(...) {}
-  fmt::format_error_code(out, error_code, message);  // 'fmt::' is for bcc32.
-}
-
-#endif  // FMT_USE_WINDOWS_H
-
-FMT_FUNC void fmt::internal::format_system_error(
-    fmt::Writer &out, int error_code,
-    fmt::StringRef message) FMT_NOEXCEPT {
-  FMT_TRY {
-    MemoryBuffer<char, INLINE_BUFFER_SIZE> buffer;
-    buffer.resize(INLINE_BUFFER_SIZE);
-    for (;;) {
-      char *system_message = &buffer[0];
-      int result = safe_strerror(error_code, system_message, buffer.size());
-      if (result == 0) {
-        out << message << ": " << system_message;
-        return;
-      }
-      if (result != ERANGE)
-        break;  // Can't get error message, report error code instead.
-      buffer.resize(buffer.size() * 2);
-    }
-  } FMT_CATCH(...) {}
-  fmt::format_error_code(out, error_code, message);  // 'fmt::' is for bcc32.
-}
-
-template <typename Char>
-void fmt::internal::ArgMap<Char>::init(const ArgList &args) {
-  if (!map_.empty())
-    return;
-  typedef internal::NamedArg<Char> NamedArg;
-  const NamedArg *named_arg = 0;
-  bool use_values =
-      args.type(ArgList::MAX_PACKED_ARGS - 1) == internal::Arg::NONE;
-  if (use_values) {
-    for (unsigned i = 0;/*nothing*/; ++i) {
-      internal::Arg::Type arg_type = args.type(i);
-      switch (arg_type) {
-      case internal::Arg::NONE:
-        return;
-      case internal::Arg::NAMED_ARG:
-        named_arg = static_cast<const NamedArg*>(args.values_[i].pointer);
-        map_.push_back(Pair(named_arg->name, *named_arg));
-        break;
-      default:
-        /*nothing*/;
-      }
-    }
-    return;
-  }
-  for (unsigned i = 0; i != ArgList::MAX_PACKED_ARGS; ++i) {
-    internal::Arg::Type arg_type = args.type(i);
-    if (arg_type == internal::Arg::NAMED_ARG) {
-      named_arg = static_cast<const NamedArg*>(args.args_[i].pointer);
-      map_.push_back(Pair(named_arg->name, *named_arg));
-    }
-  }
-  for (unsigned i = ArgList::MAX_PACKED_ARGS;/*nothing*/; ++i) {
-    switch (args.args_[i].type) {
-    case internal::Arg::NONE:
-      return;
-    case internal::Arg::NAMED_ARG:
-      named_arg = static_cast<const NamedArg*>(args.args_[i].pointer);
-      map_.push_back(Pair(named_arg->name, *named_arg));
-      break;
-    default:
-      /*nothing*/;
-    }
-  }
-}
-
-template <typename Char>
-void fmt::internal::FixedBuffer<Char>::grow(std::size_t) {
-  FMT_THROW(std::runtime_error("buffer overflow"));
-}
-
-FMT_FUNC Arg fmt::internal::FormatterBase::do_get_arg(
-    unsigned arg_index, const char *&error) {
-  Arg arg = args_[arg_index];
-  switch (arg.type) {
-  case Arg::NONE:
-    error = "argument index out of range";
-    break;
-  case Arg::NAMED_ARG:
-    arg = *static_cast<const internal::Arg*>(arg.pointer);
-    break;
-  default:
-    /*nothing*/;
-  }
-  return arg;
-}
-
-template <typename Char>
-void fmt::internal::PrintfFormatter<Char>::parse_flags(
-    FormatSpec &spec, const Char *&s) {
-  for (;;) {
-    switch (*s++) {
-      case '-':
-        spec.align_ = ALIGN_LEFT;
-        break;
-      case '+':
-        spec.flags_ |= SIGN_FLAG | PLUS_FLAG;
-        break;
-      case '0':
-        spec.fill_ = '0';
-        break;
-      case ' ':
-        spec.flags_ |= SIGN_FLAG;
-        break;
-      case '#':
-        spec.flags_ |= HASH_FLAG;
-        break;
-      default:
-        --s;
-        return;
-    }
-  }
-}
-
-template <typename Char>
-Arg fmt::internal::PrintfFormatter<Char>::get_arg(
-    const Char *s, unsigned arg_index) {
-  (void)s;
-  const char *error = 0;
-  Arg arg = arg_index == UINT_MAX ?
-    next_arg(error) : FormatterBase::get_arg(arg_index - 1, error);
-  if (error)
-    FMT_THROW(FormatError(!*s ? "invalid format string" : error));
-  return arg;
-}
-
-template <typename Char>
-unsigned fmt::internal::PrintfFormatter<Char>::parse_header(
-  const Char *&s, FormatSpec &spec) {
-  unsigned arg_index = UINT_MAX;
-  Char c = *s;
-  if (c >= '0' && c <= '9') {
-    // Parse an argument index (if followed by '$') or a width possibly
-    // preceded with '0' flag(s).
-    unsigned value = parse_nonnegative_int(s);
-    if (*s == '$') {  // value is an argument index
-      ++s;
-      arg_index = value;
-    } else {
-      if (c == '0')
-        spec.fill_ = '0';
-      if (value != 0) {
-        // Nonzero value means that we parsed width and don't need to
-        // parse it or flags again, so return now.
-        spec.width_ = value;
-        return arg_index;
-      }
-    }
-  }
-  parse_flags(spec, s);
-  // Parse width.
-  if (*s >= '0' && *s <= '9') {
-    spec.width_ = parse_nonnegative_int(s);
-  } else if (*s == '*') {
-    ++s;
-    spec.width_ = WidthHandler(spec).visit(get_arg(s));
-  }
-  return arg_index;
-}
-
-template <typename Char>
-void fmt::internal::PrintfFormatter<Char>::format(
-    BasicWriter<Char> &writer, BasicCStringRef<Char> format_str) {
-  const Char *start = format_str.c_str();
-  const Char *s = start;
-  while (*s) {
-    Char c = *s++;
-    if (c != '%') continue;
-    if (*s == c) {
-      write(writer, start, s);
-      start = ++s;
-      continue;
-    }
-    write(writer, start, s - 1);
-
-    FormatSpec spec;
-    spec.align_ = ALIGN_RIGHT;
-
-    // Parse argument index, flags and width.
-    unsigned arg_index = parse_header(s, spec);
-
-    // Parse precision.
-    if (*s == '.') {
-      ++s;
-      if ('0' <= *s && *s <= '9') {
-        spec.precision_ = static_cast<int>(parse_nonnegative_int(s));
-      } else if (*s == '*') {
-        ++s;
-        spec.precision_ = PrecisionHandler().visit(get_arg(s));
-      }
-    }
-
-    Arg arg = get_arg(s, arg_index);
-    if (spec.flag(HASH_FLAG) && IsZeroInt().visit(arg))
-      spec.flags_ &= ~to_unsigned<int>(HASH_FLAG);
-    if (spec.fill_ == '0') {
-      if (arg.type <= Arg::LAST_NUMERIC_TYPE)
-        spec.align_ = ALIGN_NUMERIC;
-      else
-        spec.fill_ = ' ';  // Ignore '0' flag for non-numeric types.
-    }
-
-    // Parse length and convert the argument to the required type.
-    switch (*s++) {
-    case 'h':
-      if (*s == 'h')
-        ArgConverter<signed char>(arg, *++s).visit(arg);
-      else
-        ArgConverter<short>(arg, *s).visit(arg);
-      break;
-    case 'l':
-      if (*s == 'l')
-        ArgConverter<fmt::LongLong>(arg, *++s).visit(arg);
-      else
-        ArgConverter<long>(arg, *s).visit(arg);
-      break;
-    case 'j':
-      ArgConverter<intmax_t>(arg, *s).visit(arg);
-      break;
-    case 'z':
-      ArgConverter<std::size_t>(arg, *s).visit(arg);
-      break;
-    case 't':
-      ArgConverter<std::ptrdiff_t>(arg, *s).visit(arg);
-      break;
-    case 'L':
-      // printf produces garbage when 'L' is omitted for long double, no
-      // need to do the same.
-      break;
-    default:
-      --s;
-      ArgConverter<void>(arg, *s).visit(arg);
-    }
-
-    // Parse type.
-    if (!*s)
-      FMT_THROW(FormatError("invalid format string"));
-    spec.type_ = static_cast<char>(*s++);
-    if (arg.type <= Arg::LAST_INTEGER_TYPE) {
-      // Normalize type.
-      switch (spec.type_) {
-      case 'i': case 'u':
-        spec.type_ = 'd';
-        break;
-      case 'c':
-        // TODO: handle wchar_t
-        CharConverter(arg).visit(arg);
-        break;
-      }
-    }
-
-    start = s;
-
-    // Format argument.
-    internal::PrintfArgFormatter<Char>(writer, spec).visit(arg);
-  }
-  write(writer, start, s);
-}
-
-FMT_FUNC void fmt::report_system_error(
-    int error_code, fmt::StringRef message) FMT_NOEXCEPT {
-  // 'fmt::' is for bcc32.
-  fmt::report_error(internal::format_system_error, error_code, message);
-}
-
-#if FMT_USE_WINDOWS_H
-FMT_FUNC void fmt::report_windows_error(
-    int error_code, fmt::StringRef message) FMT_NOEXCEPT {
-  // 'fmt::' is for bcc32.
-  fmt::report_error(internal::format_windows_error, error_code, message);
-}
-#endif
-
-FMT_FUNC void fmt::print(std::FILE *f, CStringRef format_str, ArgList args) {
-  MemoryWriter w;
-  w.write(format_str, args);
-  std::fwrite(w.data(), 1, w.size(), f);
-}
-
-FMT_FUNC void fmt::print(CStringRef format_str, ArgList args) {
-  print(stdout, format_str, args);
-}
-
-FMT_FUNC void fmt::print_colored(Color c, CStringRef format, ArgList args) {
-  char escape[] = "\x1b[30m";
-  escape[3] = static_cast<char>('0' + c);
-  std::fputs(escape, stdout);
-  print(format, args);
-  std::fputs(RESET_COLOR, stdout);
-}
-
-FMT_FUNC int fmt::fprintf(std::FILE *f, CStringRef format, ArgList args) {
-  MemoryWriter w;
-  printf(w, format, args);
-  std::size_t size = w.size();
-  return std::fwrite(w.data(), 1, size, f) < size ? -1 : static_cast<int>(size);
-}
-
-#ifndef FMT_HEADER_ONLY
-
-template struct fmt::internal::BasicData<void>;
-
-// Explicit instantiations for char.
-
-template void fmt::internal::FixedBuffer<char>::grow(std::size_t);
-
-template void fmt::internal::ArgMap<char>::init(const fmt::ArgList &args);
-
-template void fmt::internal::PrintfFormatter<char>::format(
-  BasicWriter<char> &writer, CStringRef format);
-
-template int fmt::internal::CharTraits<char>::format_float(
-    char *buffer, std::size_t size, const char *format,
-    unsigned width, int precision, double value);
-
-template int fmt::internal::CharTraits<char>::format_float(
-    char *buffer, std::size_t size, const char *format,
-    unsigned width, int precision, long double value);
-
-// Explicit instantiations for wchar_t.
-
-template void fmt::internal::FixedBuffer<wchar_t>::grow(std::size_t);
-
-template void fmt::internal::ArgMap<wchar_t>::init(const fmt::ArgList &args);
-
-template void fmt::internal::PrintfFormatter<wchar_t>::format(
-    BasicWriter<wchar_t> &writer, WCStringRef format);
-
-template int fmt::internal::CharTraits<wchar_t>::format_float(
-    wchar_t *buffer, std::size_t size, const wchar_t *format,
-    unsigned width, int precision, double value);
-
-template int fmt::internal::CharTraits<wchar_t>::format_float(
-    wchar_t *buffer, std::size_t size, const wchar_t *format,
-    unsigned width, int precision, long double value);
-
-#endif  // FMT_HEADER_ONLY
-
-#ifdef _MSC_VER
-# pragma warning(pop)
-#endif
diff --git a/wasserstein/include/spdlog/fmt/bundled/format.h b/wasserstein/include/spdlog/fmt/bundled/format.h
deleted file mode 100644
index 64c949b..0000000
--- a/wasserstein/include/spdlog/fmt/bundled/format.h
+++ /dev/null
@@ -1,4501 +0,0 @@
-/*
- Formatting library for C++
-
- Copyright (c) 2012 - 2016, Victor Zverovich
- All rights reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice, this
-    list of conditions and the following disclaimer.
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
- ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef FMT_FORMAT_H_
-#define FMT_FORMAT_H_
-
-#include <cassert>
-#include <clocale>
-#include <cmath>
-#include <cstdio>
-#include <cstring>
-#include <limits>
-#include <memory>
-#include <stdexcept>
-#include <string>
-#include <vector>
-#include <utility>
-
-#ifdef _SECURE_SCL
-# define FMT_SECURE_SCL _SECURE_SCL
-#else
-# define FMT_SECURE_SCL 0
-#endif
-
-#if FMT_SECURE_SCL
-# include <iterator>
-#endif
-
-#ifdef _MSC_VER
-# define FMT_MSC_VER _MSC_VER
-#else
-# define FMT_MSC_VER 0
-#endif
-
-#if FMT_MSC_VER && FMT_MSC_VER <= 1500
-typedef unsigned __int32 uint32_t;
-typedef unsigned __int64 uint64_t;
-typedef __int64          intmax_t;
-#else
-#include <stdint.h>
-#endif
-
-#if !defined(FMT_HEADER_ONLY) && defined(_WIN32)
-# ifdef FMT_EXPORT
-#  define FMT_API __declspec(dllexport)
-# elif defined(FMT_SHARED)
-#  define FMT_API __declspec(dllimport)
-# endif
-#endif
-#ifndef FMT_API
-# define FMT_API
-#endif
-
-#ifdef __GNUC__
-# define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
-# define FMT_GCC_EXTENSION __extension__
-# if FMT_GCC_VERSION >= 406
-#  pragma GCC diagnostic push
-// Disable the warning about "long long" which is sometimes reported even
-// when using __extension__.
-#  pragma GCC diagnostic ignored "-Wlong-long"
-// Disable the warning about declaration shadowing because it affects too
-// many valid cases.
-#  pragma GCC diagnostic ignored "-Wshadow"
-// Disable the warning about implicit conversions that may change the sign of
-// an integer; silencing it otherwise would require many explicit casts.
-#  pragma GCC diagnostic ignored "-Wsign-conversion"
-# endif
-# if __cplusplus >= 201103L || defined __GXX_EXPERIMENTAL_CXX0X__
-#  define FMT_HAS_GXX_CXX11 1
-# endif
-#else
-# define FMT_GCC_EXTENSION
-#endif
-
-#if defined(__INTEL_COMPILER)
-# define FMT_ICC_VERSION __INTEL_COMPILER
-#elif defined(__ICL)
-# define FMT_ICC_VERSION __ICL
-#endif
-
-#if defined(__clang__) && !defined(FMT_ICC_VERSION)
-# pragma clang diagnostic push
-# pragma clang diagnostic ignored "-Wdocumentation-unknown-command"
-# pragma clang diagnostic ignored "-Wpadded"
-#endif
-
-#ifdef __GNUC_LIBSTD__
-# define FMT_GNUC_LIBSTD_VERSION (__GNUC_LIBSTD__ * 100 + __GNUC_LIBSTD_MINOR__)
-#endif
-
-#ifdef __has_feature
-# define FMT_HAS_FEATURE(x) __has_feature(x)
-#else
-# define FMT_HAS_FEATURE(x) 0
-#endif
-
-#ifdef __has_builtin
-# define FMT_HAS_BUILTIN(x) __has_builtin(x)
-#else
-# define FMT_HAS_BUILTIN(x) 0
-#endif
-
-#ifdef __has_cpp_attribute
-# define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
-#else
-# define FMT_HAS_CPP_ATTRIBUTE(x) 0
-#endif
-
-#ifndef FMT_USE_VARIADIC_TEMPLATES
-// Variadic templates are available in GCC since version 4.4
-// (http://gcc.gnu.org/projects/cxx0x.html) and in Visual C++
-// since version 2013.
-# define FMT_USE_VARIADIC_TEMPLATES \
-   (FMT_HAS_FEATURE(cxx_variadic_templates) || \
-       (FMT_GCC_VERSION >= 404 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1800)
-#endif
-
-#ifndef FMT_USE_RVALUE_REFERENCES
-// Don't use rvalue references when compiling with clang and an old libstdc++
-// as the latter doesn't provide std::move.
-# if defined(FMT_GNUC_LIBSTD_VERSION) && FMT_GNUC_LIBSTD_VERSION <= 402
-#  define FMT_USE_RVALUE_REFERENCES 0
-# else
-#  define FMT_USE_RVALUE_REFERENCES \
-    (FMT_HAS_FEATURE(cxx_rvalue_references) || \
-        (FMT_GCC_VERSION >= 403 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1600)
-# endif
-#endif
-
-#if FMT_USE_RVALUE_REFERENCES
-# include <utility>  // for std::move
-#endif
-
-// Check if exceptions are disabled.
-#if defined(__GNUC__) && !defined(__EXCEPTIONS)
-# define FMT_EXCEPTIONS 0
-#endif
-#if FMT_MSC_VER && !_HAS_EXCEPTIONS
-# define FMT_EXCEPTIONS 0
-#endif
-#ifndef FMT_EXCEPTIONS
-# define FMT_EXCEPTIONS 1
-#endif
-
-#ifndef FMT_THROW
-# if FMT_EXCEPTIONS
-#  define FMT_THROW(x) throw x
-# else
-#  define FMT_THROW(x) assert(false)
-# endif
-#endif
-
-// Define FMT_USE_NOEXCEPT to make fmt use noexcept (C++11 feature).
-#ifndef FMT_USE_NOEXCEPT
-# define FMT_USE_NOEXCEPT 0
-#endif
-
-#ifndef FMT_NOEXCEPT
-# if FMT_EXCEPTIONS
-#  if FMT_USE_NOEXCEPT || FMT_HAS_FEATURE(cxx_noexcept) || \
-    (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || \
-    FMT_MSC_VER >= 1900
-#   define FMT_NOEXCEPT noexcept
-#  else
-#   define FMT_NOEXCEPT throw()
-#  endif
-# else
-#  define FMT_NOEXCEPT
-# endif
-#endif
-
-#ifndef FMT_OVERRIDE
-# if FMT_USE_OVERRIDE || FMT_HAS_FEATURE(cxx_override) || \
-   (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || \
-   FMT_MSC_VER >= 1900
-#  define FMT_OVERRIDE override
-# else
-#  define FMT_OVERRIDE
-# endif
-#endif
-
-
-// A macro to disallow the copy constructor and operator= functions
-// This should be used in the private: declarations for a class
-#ifndef FMT_USE_DELETED_FUNCTIONS
-# define FMT_USE_DELETED_FUNCTIONS 0
-#endif
-
-#if FMT_USE_DELETED_FUNCTIONS || FMT_HAS_FEATURE(cxx_deleted_functions) || \
-  (FMT_GCC_VERSION >= 404 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1800
-# define FMT_DELETED_OR_UNDEFINED  = delete
-# define FMT_DISALLOW_COPY_AND_ASSIGN(TypeName) \
-    TypeName(const TypeName&) = delete; \
-    TypeName& operator=(const TypeName&) = delete
-#else
-# define FMT_DELETED_OR_UNDEFINED
-# define FMT_DISALLOW_COPY_AND_ASSIGN(TypeName) \
-    TypeName(const TypeName&); \
-    TypeName& operator=(const TypeName&)
-#endif
-
-#ifndef FMT_USE_USER_DEFINED_LITERALS
-// All compilers which support UDLs also support variadic templates. This
-// makes the fmt::literals implementation easier. However, an explicit check
-// for variadic templates is added here just in case.
-// For Intel's compiler both it and the system gcc/msc must support UDLs.
-# define FMT_USE_USER_DEFINED_LITERALS \
-   FMT_USE_VARIADIC_TEMPLATES && FMT_USE_RVALUE_REFERENCES && \
-   (FMT_HAS_FEATURE(cxx_user_literals) || \
-     (FMT_GCC_VERSION >= 407 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900) && \
-   (!defined(FMT_ICC_VERSION) || FMT_ICC_VERSION >= 1500)
-#endif
-
-#ifndef FMT_ASSERT
-# define FMT_ASSERT(condition, message) assert((condition) && message)
-#endif
-
-#if FMT_GCC_VERSION >= 400 || FMT_HAS_BUILTIN(__builtin_clz)
-# define FMT_BUILTIN_CLZ(n) __builtin_clz(n)
-#endif
-
-#if FMT_GCC_VERSION >= 400 || FMT_HAS_BUILTIN(__builtin_clzll)
-# define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n)
-#endif
-
-// Some compilers masquerade as both MSVC and GCC-likes or
-// otherwise support __builtin_clz and __builtin_clzll, so
-// only define FMT_BUILTIN_CLZ using the MSVC intrinsics
-// if the clz and clzll builtins are not available.
-#if FMT_MSC_VER && !defined(FMT_BUILTIN_CLZLL)
-# include <intrin.h>  // _BitScanReverse, _BitScanReverse64
-
-namespace fmt
-{
-namespace internal
-{
-# pragma intrinsic(_BitScanReverse)
-inline uint32_t clz(uint32_t x)
-{
-    unsigned long r = 0;
-    _BitScanReverse(&r, x);
-
-    assert(x != 0);
-    // Static analysis complains about using uninitialized data
-    // "r", but the only way that can happen is if "x" is 0,
-    // which the callers guarantee to not happen.
-# pragma warning(suppress: 6102)
-    return 31 - r;
-}
-# define FMT_BUILTIN_CLZ(n) fmt::internal::clz(n)
-
-# ifdef _WIN64
-#  pragma intrinsic(_BitScanReverse64)
-# endif
-
-inline uint32_t clzll(uint64_t x)
-{
-    unsigned long r = 0;
-# ifdef _WIN64
-    _BitScanReverse64(&r, x);
-# else
-    // Scan the high 32 bits.
-    if (_BitScanReverse(&r, static_cast<uint32_t>(x >> 32)))
-        return 63 - (r + 32);
-
-    // Scan the low 32 bits.
-    _BitScanReverse(&r, static_cast<uint32_t>(x));
-# endif
-
-    assert(x != 0);
-    // Static analysis complains about using uninitialized data
-    // "r", but the only way that can happen is if "x" is 0,
-    // which the callers guarantee to not happen.
-# pragma warning(suppress: 6102)
-    return 63 - r;
-}
-# define FMT_BUILTIN_CLZLL(n) fmt::internal::clzll(n)
-}
-}
-#endif
-
-namespace fmt
-{
-namespace internal
-{
-struct DummyInt
-{
-    int data[2];
-    operator int() const
-    {
-        return 0;
-    }
-};
-typedef std::numeric_limits<fmt::internal::DummyInt> FPUtil;
-
-// Dummy implementations of system functions such as signbit and ecvt called
-// if the latter are not available.
-inline DummyInt signbit(...)
-{
-    return DummyInt();
-}
-inline DummyInt _ecvt_s(...)
-{
-    return DummyInt();
-}
-inline DummyInt isinf(...)
-{
-    return DummyInt();
-}
-inline DummyInt _finite(...)
-{
-    return DummyInt();
-}
-inline DummyInt isnan(...)
-{
-    return DummyInt();
-}
-inline DummyInt _isnan(...)
-{
-    return DummyInt();
-}
-
-// A helper function to suppress bogus "conditional expression is constant"
-// warnings.
-template <typename T>
-inline T const_check(T value)
-{
-    return value;
-}
-}
-}  // namespace fmt
-
-namespace std
-{
-// Standard permits specialization of std::numeric_limits. This specialization
-// is used to resolve ambiguity between isinf and std::isinf in glibc:
-// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=48891
-// and the same for isnan and signbit.
-template <>
-class numeric_limits<fmt::internal::DummyInt> :
-    public std::numeric_limits<int>
-{
-public:
-    // Portable version of isinf.
-    template <typename T>
-    static bool isinfinity(T x)
-    {
-        using namespace fmt::internal;
-        // The resolution "priority" is:
-        // isinf macro > std::isinf > ::isinf > fmt::internal::isinf
-        if (const_check(sizeof(isinf(x)) == sizeof(bool) ||
-                        sizeof(isinf(x)) == sizeof(int)))
-        {
-            return isinf(x) != 0;
-        }
-        return !_finite(static_cast<double>(x));
-    }
-
-    // Portable version of isnan.
-    template <typename T>
-    static bool isnotanumber(T x)
-    {
-        using namespace fmt::internal;
-        if (const_check(sizeof(isnan(x)) == sizeof(bool) ||
-                        sizeof(isnan(x)) == sizeof(int)))
-        {
-            return isnan(x) != 0;
-        }
-        return _isnan(static_cast<double>(x)) != 0;
-    }
-
-    // Portable version of signbit.
-    static bool isnegative(double x)
-    {
-        using namespace fmt::internal;
-        if (const_check(sizeof(signbit(x)) == sizeof(int)))
-            return signbit(x) != 0;
-        if (x < 0) return true;
-        if (!isnotanumber(x)) return false;
-        int dec = 0, sign = 0;
-        char buffer[2];  // The buffer size must be >= 2 or _ecvt_s will fail.
-        _ecvt_s(buffer, sizeof(buffer), x, 0, &dec, &sign);
-        return sign != 0;
-    }
-};
-}  // namespace std
-
-namespace fmt
-{
-
-// Fix the warning about long long on older versions of GCC
-// that don't support the diagnostic pragma.
-FMT_GCC_EXTENSION typedef long long LongLong;
-FMT_GCC_EXTENSION typedef unsigned long long ULongLong;
-
-#if FMT_USE_RVALUE_REFERENCES
-using std::move;
-#endif
-
-template <typename Char>
-class BasicWriter;
-
-typedef BasicWriter<char> Writer;
-typedef BasicWriter<wchar_t> WWriter;
-
-template <typename Char>
-class ArgFormatter;
-
-template <typename CharType,
-          typename ArgFormatter = fmt::ArgFormatter<CharType> >
-class BasicFormatter;
-
-/**
-  \rst
-  A string reference. It can be constructed from a C string or ``std::string``.
-
-  You can use one of the following typedefs for common character types:
-
-  +------------+-------------------------+
-  | Type       | Definition              |
-  +============+=========================+
-  | StringRef  | BasicStringRef<char>    |
-  +------------+-------------------------+
-  | WStringRef | BasicStringRef<wchar_t> |
-  +------------+-------------------------+
-
-  This class is most useful as a parameter type to allow passing
-  different types of strings to a function, for example::
-
-    template <typename... Args>
-    std::string format(StringRef format_str, const Args & ... args);
-
-    format("{}", 42);
-    format(std::string("{}"), 42);
-  \endrst
- */
-template <typename Char>
-class BasicStringRef
-{
-private:
-    const Char *data_;
-    std::size_t size_;
-
-public:
-    /** Constructs a string reference object from a C string and a size. */
-    BasicStringRef(const Char *s, std::size_t size) : data_(s), size_(size) {}
-
-    /**
-      \rst
-      Constructs a string reference object from a C string computing
-      the size with ``std::char_traits<Char>::length``.
-      \endrst
-     */
-    BasicStringRef(const Char *s)
-        : data_(s), size_(std::char_traits<Char>::length(s)) {}
-
-    /**
-      \rst
-      Constructs a string reference from an ``std::string`` object.
-      \endrst
-     */
-    BasicStringRef(const std::basic_string<Char> &s)
-        : data_(s.c_str()), size_(s.size()) {}
-
-    /**
-      \rst
-      Converts a string reference to an ``std::string`` object.
-      \endrst
-     */
-    std::basic_string<Char> to_string() const
-    {
-        return std::basic_string<Char>(data_, size_);
-    }
-
-    /** Returns a pointer to the string data. */
-    const Char *data() const
-    {
-        return data_;
-    }
-
-    /** Returns the string size. */
-    std::size_t size() const
-    {
-        return size_;
-    }
-
-    // Lexicographically compare this string reference to other.
-    int compare(BasicStringRef other) const
-    {
-        std::size_t size = size_ < other.size_ ? size_ : other.size_;
-        int result = std::char_traits<Char>::compare(data_, other.data_, size);
-        if (result == 0)
-            result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);
-        return result;
-    }
-
-    friend bool operator==(BasicStringRef lhs, BasicStringRef rhs)
-    {
-        return lhs.compare(rhs) == 0;
-    }
-    friend bool operator!=(BasicStringRef lhs, BasicStringRef rhs)
-    {
-        return lhs.compare(rhs) != 0;
-    }
-    friend bool operator<(BasicStringRef lhs, BasicStringRef rhs)
-    {
-        return lhs.compare(rhs) < 0;
-    }
-    friend bool operator<=(BasicStringRef lhs, BasicStringRef rhs)
-    {
-        return lhs.compare(rhs) <= 0;
-    }
-    friend bool operator>(BasicStringRef lhs, BasicStringRef rhs)
-    {
-        return lhs.compare(rhs) > 0;
-    }
-    friend bool operator>=(BasicStringRef lhs, BasicStringRef rhs)
-    {
-        return lhs.compare(rhs) >= 0;
-    }
-};
-
-typedef BasicStringRef<char> StringRef;
-typedef BasicStringRef<wchar_t> WStringRef;
-
-/**
-  \rst
-  A reference to a null terminated string. It can be constructed from a C
-  string or ``std::string``.
-
-  You can use one of the following typedefs for common character types:
-
-  +-------------+--------------------------+
-  | Type        | Definition               |
-  +=============+==========================+
-  | CStringRef  | BasicCStringRef<char>    |
-  +-------------+--------------------------+
-  | WCStringRef | BasicCStringRef<wchar_t> |
-  +-------------+--------------------------+
-
-  This class is most useful as a parameter type to allow passing
-  different types of strings to a function, for example::
-
-    template <typename... Args>
-    std::string format(CStringRef format_str, const Args & ... args);
-
-    format("{}", 42);
-    format(std::string("{}"), 42);
-  \endrst
- */
-template <typename Char>
-class BasicCStringRef
-{
-private:
-    const Char *data_;
-
-public:
-    /** Constructs a string reference object from a C string. */
-    BasicCStringRef(const Char *s) : data_(s) {}
-
-    /**
-      \rst
-      Constructs a string reference from an ``std::string`` object.
-      \endrst
-     */
-    BasicCStringRef(const std::basic_string<Char> &s) : data_(s.c_str()) {}
-
-    /** Returns the pointer to a C string. */
-    const Char *c_str() const
-    {
-        return data_;
-    }
-};
-
-typedef BasicCStringRef<char> CStringRef;
-typedef BasicCStringRef<wchar_t> WCStringRef;
-
-/** A formatting error such as invalid format string. */
-class FormatError : public std::runtime_error
-{
-public:
-    explicit FormatError(CStringRef message)
-        : std::runtime_error(message.c_str()) {}
-    ~FormatError() throw();
-};
-
-namespace internal
-{
-
-// MakeUnsigned<T>::Type gives an unsigned type corresponding to integer type T.
-template <typename T>
-struct MakeUnsigned
-{
-    typedef T Type;
-};
-
-#define FMT_SPECIALIZE_MAKE_UNSIGNED(T, U) \
-  template <> \
-  struct MakeUnsigned<T> { typedef U Type; }
-
-FMT_SPECIALIZE_MAKE_UNSIGNED(char, unsigned char);
-FMT_SPECIALIZE_MAKE_UNSIGNED(signed char, unsigned char);
-FMT_SPECIALIZE_MAKE_UNSIGNED(short, unsigned short);
-FMT_SPECIALIZE_MAKE_UNSIGNED(int, unsigned);
-FMT_SPECIALIZE_MAKE_UNSIGNED(long, unsigned long);
-FMT_SPECIALIZE_MAKE_UNSIGNED(LongLong, ULongLong);
-
-// Casts nonnegative integer to unsigned.
-template <typename Int>
-inline typename MakeUnsigned<Int>::Type to_unsigned(Int value)
-{
-    FMT_ASSERT(value >= 0, "negative value");
-    return static_cast<typename MakeUnsigned<Int>::Type>(value);
-}
-
-// The number of characters to store in the MemoryBuffer object itself
-// to avoid dynamic memory allocation.
-enum { INLINE_BUFFER_SIZE = 500 };
-
-#if FMT_SECURE_SCL
-// Use checked iterator to avoid warnings on MSVC.
-template <typename T>
-inline stdext::checked_array_iterator<T*> make_ptr(T *ptr, std::size_t size)
-{
-    return stdext::checked_array_iterator<T*>(ptr, size);
-}
-#else
-template <typename T>
-inline T *make_ptr(T *ptr, std::size_t)
-{
-    return ptr;
-}
-#endif
-}  // namespace internal
-
-/**
-  \rst
-  A buffer supporting a subset of ``std::vector``'s operations.
-  \endrst
- */
-template <typename T>
-class Buffer
-{
-private:
-    FMT_DISALLOW_COPY_AND_ASSIGN(Buffer);
-
-protected:
-    T *ptr_;
-    std::size_t size_;
-    std::size_t capacity_;
-
-    Buffer(T *ptr = 0, std::size_t capacity = 0)
-        : ptr_(ptr), size_(0), capacity_(capacity) {}
-
-    /**
-      \rst
-      Increases the buffer capacity to hold at least *size* elements updating
-      ``ptr_`` and ``capacity_``.
-      \endrst
-     */
-    virtual void grow(std::size_t size) = 0;
-
-public:
-    virtual ~Buffer() {}
-
-    /** Returns the size of this buffer. */
-    std::size_t size() const
-    {
-        return size_;
-    }
-
-    /** Returns the capacity of this buffer. */
-    std::size_t capacity() const
-    {
-        return capacity_;
-    }
-
-    /**
-      Resizes the buffer. If T is a POD type new elements may not be initialized.
-     */
-    void resize(std::size_t new_size)
-    {
-        if (new_size > capacity_)
-            grow(new_size);
-        size_ = new_size;
-    }
-
-    /**
-      \rst
-      Reserves space to store at least *capacity* elements.
-      \endrst
-     */
-    void reserve(std::size_t capacity)
-    {
-        if (capacity > capacity_)
-            grow(capacity);
-    }
-
-    void clear() FMT_NOEXCEPT { size_ = 0; }
-
-    void push_back(const T &value)
-    {
-        if (size_ == capacity_)
-            grow(size_ + 1);
-        ptr_[size_++] = value;
-    }
-
-    /** Appends data to the end of the buffer. */
-    template <typename U>
-    void append(const U *begin, const U *end);
-
-    T &operator[](std::size_t index)
-    {
-        return ptr_[index];
-    }
-    const T &operator[](std::size_t index) const
-    {
-        return ptr_[index];
-    }
-};
-
-template <typename T>
-template <typename U>
-void Buffer<T>::append(const U *begin, const U *end)
-{
-    std::size_t new_size = size_ + internal::to_unsigned(end - begin);
-    if (new_size > capacity_)
-        grow(new_size);
-    std::uninitialized_copy(begin, end,
-                            internal::make_ptr(ptr_, capacity_) + size_);
-    size_ = new_size;
-}
-
-namespace internal
-{
-
-// A memory buffer for trivially copyable/constructible types with the first
-// SIZE elements stored in the object itself.
-template <typename T, std::size_t SIZE, typename Allocator = std::allocator<T> >
-class MemoryBuffer : private Allocator, public Buffer<T>
-{
-private:
-    T data_[SIZE];
-
-    // Deallocate memory allocated by the buffer.
-    void deallocate()
-    {
-        if (this->ptr_ != data_) Allocator::deallocate(this->ptr_, this->capacity_);
-    }
-
-protected:
-    void grow(std::size_t size) FMT_OVERRIDE;
-
-public:
-    explicit MemoryBuffer(const Allocator &alloc = Allocator())
-        : Allocator(alloc), Buffer<T>(data_, SIZE) {}
-    ~MemoryBuffer()
-    {
-        deallocate();
-    }
-
-#if FMT_USE_RVALUE_REFERENCES
-private:
-    // Move data from other to this buffer.
-    void move(MemoryBuffer &other)
-    {
-        Allocator &this_alloc = *this, &other_alloc = other;
-        this_alloc = std::move(other_alloc);
-        this->size_ = other.size_;
-        this->capacity_ = other.capacity_;
-        if (other.ptr_ == other.data_)
-        {
-            this->ptr_ = data_;
-            std::uninitialized_copy(other.data_, other.data_ + this->size_,
-                                    make_ptr(data_, this->capacity_));
-        }
-        else
-        {
-            this->ptr_ = other.ptr_;
-            // Set pointer to the inline array so that delete is not called
-            // when deallocating.
-            other.ptr_ = other.data_;
-        }
-    }
-
-public:
-    MemoryBuffer(MemoryBuffer &&other)
-    {
-        move(other);
-    }
-
-    MemoryBuffer &operator=(MemoryBuffer &&other)
-    {
-        assert(this != &other);
-        deallocate();
-        move(other);
-        return *this;
-    }
-#endif
-
-    // Returns a copy of the allocator associated with this buffer.
-    Allocator get_allocator() const
-    {
-        return *this;
-    }
-};
-
-template <typename T, std::size_t SIZE, typename Allocator>
-void MemoryBuffer<T, SIZE, Allocator>::grow(std::size_t size)
-{
-    std::size_t new_capacity = this->capacity_ + this->capacity_ / 2;
-    if (size > new_capacity)
-        new_capacity = size;
-    T *new_ptr = this->allocate(new_capacity);
-    // The following code doesn't throw, so the raw pointer above doesn't leak.
-    std::uninitialized_copy(this->ptr_, this->ptr_ + this->size_,
-                            make_ptr(new_ptr, new_capacity));
-    std::size_t old_capacity = this->capacity_;
-    T *old_ptr = this->ptr_;
-    this->capacity_ = new_capacity;
-    this->ptr_ = new_ptr;
-    // deallocate may throw (at least in principle), but it doesn't matter since
-    // the buffer already uses the new storage and will deallocate it in case
-    // of exception.
-    if (old_ptr != data_)
-        Allocator::deallocate(old_ptr, old_capacity);
-}
-
-// A fixed-size buffer.
-template <typename Char>
-class FixedBuffer : public fmt::Buffer<Char>
-{
-public:
-    FixedBuffer(Char *array, std::size_t size) : fmt::Buffer<Char>(array, size) {}
-
-protected:
-    FMT_API void grow(std::size_t size);
-};
-
-template <typename Char>
-class BasicCharTraits
-{
-public:
-#if FMT_SECURE_SCL
-    typedef stdext::checked_array_iterator<Char*> CharPtr;
-#else
-    typedef Char *CharPtr;
-#endif
-    static Char cast(int value)
-    {
-        return static_cast<Char>(value);
-    }
-};
-
-template <typename Char>
-class CharTraits;
-
-template <>
-class CharTraits<char> : public BasicCharTraits<char>
-{
-private:
-    // Conversion from wchar_t to char is not allowed.
-    static char convert(wchar_t);
-
-public:
-    static char convert(char value)
-    {
-        return value;
-    }
-
-    // Formats a floating-point number.
-    template <typename T>
-    FMT_API static int format_float(char *buffer, std::size_t size,
-                                    const char *format, unsigned width, int precision, T value);
-};
-
-template <>
-class CharTraits<wchar_t> : public BasicCharTraits<wchar_t>
-{
-public:
-    static wchar_t convert(char value)
-    {
-        return value;
-    }
-    static wchar_t convert(wchar_t value)
-    {
-        return value;
-    }
-
-    template <typename T>
-    FMT_API static int format_float(wchar_t *buffer, std::size_t size,
-                                    const wchar_t *format, unsigned width, int precision, T value);
-};
-
-// Checks if a number is negative - used to avoid warnings.
-template <bool IsSigned>
-struct SignChecker
-{
-    template <typename T>
-    static bool is_negative(T value)
-    {
-        return value < 0;
-    }
-};
-
-template <>
-struct SignChecker<false>
-{
-    template <typename T>
-    static bool is_negative(T)
-    {
-        return false;
-    }
-};
-
-// Returns true if value is negative, false otherwise.
-// Same as (value < 0) but doesn't produce warnings if T is an unsigned type.
-template <typename T>
-inline bool is_negative(T value)
-{
-    return SignChecker<std::numeric_limits<T>::is_signed>::is_negative(value);
-}
-
-// Selects uint32_t if FitsIn32Bits is true, uint64_t otherwise.
-template <bool FitsIn32Bits>
-struct TypeSelector
-{
-    typedef uint32_t Type;
-};
-
-template <>
-struct TypeSelector<false>
-{
-    typedef uint64_t Type;
-};
-
-template <typename T>
-struct IntTraits
-{
-    // Smallest of uint32_t and uint64_t that is large enough to represent
-    // all values of T.
-    typedef typename
-    TypeSelector<std::numeric_limits<T>::digits <= 32>::Type MainType;
-};
-
-FMT_API void report_unknown_type(char code, const char *type);
-
-// Static data is placed in this class template to allow header-only
-// configuration.
-template <typename T = void>
-struct FMT_API BasicData
-{
-    static const uint32_t POWERS_OF_10_32[];
-    static const uint64_t POWERS_OF_10_64[];
-    static const char DIGITS[];
-};
-
-#ifndef FMT_USE_EXTERN_TEMPLATES
-// Clang doesn't have a feature check for extern templates so we check
-// for variadic templates which were introduced in the same version.
-# define FMT_USE_EXTERN_TEMPLATES (__clang__ && FMT_USE_VARIADIC_TEMPLATES)
-#endif
-
-#if FMT_USE_EXTERN_TEMPLATES && !defined(FMT_HEADER_ONLY)
-extern template struct BasicData<void>;
-#endif
-
-typedef BasicData<> Data;
-
-#ifdef FMT_BUILTIN_CLZLL
-// Returns the number of decimal digits in n. Leading zeros are not counted
-// except for n == 0 in which case count_digits returns 1.
-inline unsigned count_digits(uint64_t n)
-{
-    // Based on http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10
-    // and the benchmark https://github.com/localvoid/cxx-benchmark-count-digits.
-    int t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12;
-    return to_unsigned(t) - (n < Data::POWERS_OF_10_64[t]) + 1;
-}
-#else
-// Fallback version of count_digits used when __builtin_clz is not available.
-inline unsigned count_digits(uint64_t n)
-{
-    unsigned count = 1;
-    for (;;)
-    {
-        // Integer division is slow so do it for a group of four digits instead
-        // of for every digit. The idea comes from the talk by Alexandrescu
-        // "Three Optimization Tips for C++". See speed-test for a comparison.
-        if (n < 10) return count;
-        if (n < 100) return count + 1;
-        if (n < 1000) return count + 2;
-        if (n < 10000) return count + 3;
-        n /= 10000u;
-        count += 4;
-    }
-}
-#endif
-
-#ifdef FMT_BUILTIN_CLZ
-// Optional version of count_digits for better performance on 32-bit platforms.
-inline unsigned count_digits(uint32_t n)
-{
-    int t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12;
-    return to_unsigned(t) - (n < Data::POWERS_OF_10_32[t]) + 1;
-}
-#endif
-
-// A functor that doesn't add a thousands separator.
-struct NoThousandsSep
-{
-    template <typename Char>
-    void operator()(Char *) {}
-};
-
-// A functor that adds a thousands separator.
-class ThousandsSep
-{
-private:
-    fmt::StringRef sep_;
-
-    // Index of a decimal digit with the least significant digit having index 0.
-    unsigned digit_index_;
-
-public:
-    explicit ThousandsSep(fmt::StringRef sep) : sep_(sep), digit_index_(0) {}
-
-    template <typename Char>
-    void operator()(Char *&buffer)
-    {
-        if (++digit_index_ % 3 != 0)
-            return;
-        buffer -= sep_.size();
-        std::uninitialized_copy(sep_.data(), sep_.data() + sep_.size(),
-                                internal::make_ptr(buffer, sep_.size()));
-    }
-};
-
-// Formats a decimal unsigned integer value writing into buffer.
-// thousands_sep is a functor that is called after writing each char to
-// add a thousands separator if necessary.
-template <typename UInt, typename Char, typename ThousandsSep>
-inline void format_decimal(Char *buffer, UInt value, unsigned num_digits,
-                           ThousandsSep thousands_sep)
-{
-    buffer += num_digits;
-    while (value >= 100)
-    {
-        // Integer division is slow so do it for a group of two digits instead
-        // of for every digit. The idea comes from the talk by Alexandrescu
-        // "Three Optimization Tips for C++". See speed-test for a comparison.
-        unsigned index = static_cast<unsigned>((value % 100) * 2);
-        value /= 100;
-        *--buffer = Data::DIGITS[index + 1];
-        thousands_sep(buffer);
-        *--buffer = Data::DIGITS[index];
-        thousands_sep(buffer);
-    }
-    if (value < 10)
-    {
-        *--buffer = static_cast<char>('0' + value);
-        return;
-    }
-    unsigned index = static_cast<unsigned>(value * 2);
-    *--buffer = Data::DIGITS[index + 1];
-    thousands_sep(buffer);
-    *--buffer = Data::DIGITS[index];
-}
-
-template <typename UInt, typename Char>
-inline void format_decimal(Char *buffer, UInt value, unsigned num_digits)
-{
-    return format_decimal(buffer, value, num_digits, NoThousandsSep());
-}
-
-#ifndef _WIN32
-# define FMT_USE_WINDOWS_H 0
-#elif !defined(FMT_USE_WINDOWS_H)
-# define FMT_USE_WINDOWS_H 1
-#endif
-
-// Define FMT_USE_WINDOWS_H to 0 to disable use of windows.h.
-// All the functionality that relies on it will be disabled too.
-#if FMT_USE_WINDOWS_H
-// A converter from UTF-8 to UTF-16.
-// It is only provided for Windows since other systems support UTF-8 natively.
-class UTF8ToUTF16
-{
-private:
-    MemoryBuffer<wchar_t, INLINE_BUFFER_SIZE> buffer_;
-
-public:
-    FMT_API explicit UTF8ToUTF16(StringRef s);
-    operator WStringRef() const
-    {
-        return WStringRef(&buffer_[0], size());
-    }
-    size_t size() const
-    {
-        return buffer_.size() - 1;
-    }
-    const wchar_t *c_str() const
-    {
-        return &buffer_[0];
-    }
-    std::wstring str() const
-    {
-        return std::wstring(&buffer_[0], size());
-    }
-};
-
-// A converter from UTF-16 to UTF-8.
-// It is only provided for Windows since other systems support UTF-8 natively.
-class UTF16ToUTF8
-{
-private:
-    MemoryBuffer<char, INLINE_BUFFER_SIZE> buffer_;
-
-public:
-    UTF16ToUTF8() {}
-    FMT_API explicit UTF16ToUTF8(WStringRef s);
-    operator StringRef() const
-    {
-        return StringRef(&buffer_[0], size());
-    }
-    size_t size() const
-    {
-        return buffer_.size() - 1;
-    }
-    const char *c_str() const
-    {
-        return &buffer_[0];
-    }
-    std::string str() const
-    {
-        return std::string(&buffer_[0], size());
-    }
-
-    // Performs conversion returning a system error code instead of
-    // throwing exception on conversion error. This method may still throw
-    // in case of memory allocation error.
-    FMT_API int convert(WStringRef s);
-};
-
-FMT_API void format_windows_error(fmt::Writer &out, int error_code,
-                                  fmt::StringRef message) FMT_NOEXCEPT;
-#endif
-
-FMT_API void format_system_error(fmt::Writer &out, int error_code,
-                                 fmt::StringRef message) FMT_NOEXCEPT;
-
-// A formatting argument value.
-struct Value
-{
-    template <typename Char>
-    struct StringValue
-    {
-        const Char *value;
-        std::size_t size;
-    };
-
-    typedef void (*FormatFunc)(
-        void *formatter, const void *arg, void *format_str_ptr);
-
-    struct CustomValue
-    {
-        const void *value;
-        FormatFunc format;
-    };
-
-    union
-    {
-        int int_value;
-        unsigned uint_value;
-        LongLong long_long_value;
-        ULongLong ulong_long_value;
-        double double_value;
-        long double long_double_value;
-        const void *pointer;
-        StringValue<char> string;
-        StringValue<signed char> sstring;
-        StringValue<unsigned char> ustring;
-        StringValue<wchar_t> wstring;
-        CustomValue custom;
-    };
-
-    enum Type
-    {
-        NONE, NAMED_ARG,
-        // Integer types should go first,
-        INT, UINT, LONG_LONG, ULONG_LONG, BOOL, CHAR, LAST_INTEGER_TYPE = CHAR,
-        // followed by floating-point types.
-        DOUBLE, LONG_DOUBLE, LAST_NUMERIC_TYPE = LONG_DOUBLE,
-        CSTRING, STRING, WSTRING, POINTER, CUSTOM
-    };
-};
-
-// A formatting argument. It is a trivially copyable/constructible type to
-// allow storage in internal::MemoryBuffer.
-struct Arg : Value
-{
-    Type type;
-};
-
-template <typename Char>
-struct NamedArg;
-
-template <typename T = void>
-struct Null {};
-
-// A helper class template to enable or disable overloads taking wide
-// characters and strings in MakeValue.
-template <typename T, typename Char>
-struct WCharHelper
-{
-    typedef Null<T> Supported;
-    typedef T Unsupported;
-};
-
-template <typename T>
-struct WCharHelper<T, wchar_t>
-{
-    typedef T Supported;
-    typedef Null<T> Unsupported;
-};
-
-typedef char Yes[1];
-typedef char No[2];
-
-template <typename T>
-T &get();
-
-// These are non-members to workaround an overload resolution bug in bcc32.
-Yes &convert(fmt::ULongLong);
-No &convert(...);
-
-template<typename T, bool ENABLE_CONVERSION>
-struct ConvertToIntImpl
-{
-    enum { value = ENABLE_CONVERSION };
-};
-
-template<typename T, bool ENABLE_CONVERSION>
-struct ConvertToIntImpl2
-{
-    enum { value = false };
-};
-
-template<typename T>
-struct ConvertToIntImpl2<T, true>
-{
-    enum
-    {
-        // Don't convert numeric types.
-        value = ConvertToIntImpl<T, !std::numeric_limits<T>::is_specialized>::value
-    };
-};
-
-template<typename T>
-struct ConvertToInt
-{
-    enum { enable_conversion = sizeof(convert(get<T>())) == sizeof(Yes) };
-    enum { value = ConvertToIntImpl2<T, enable_conversion>::value };
-};
-
-#define FMT_DISABLE_CONVERSION_TO_INT(Type) \
-  template <> \
-  struct ConvertToInt<Type> {  enum { value = 0 }; }
-
-// Silence warnings about convering float to int.
-FMT_DISABLE_CONVERSION_TO_INT(float);
-FMT_DISABLE_CONVERSION_TO_INT(double);
-FMT_DISABLE_CONVERSION_TO_INT(long double);
-
-template<bool B, class T = void>
-struct EnableIf {};
-
-template<class T>
-struct EnableIf<true, T>
-{
-    typedef T type;
-};
-
-template<bool B, class T, class F>
-struct Conditional
-{
-    typedef T type;
-};
-
-template<class T, class F>
-struct Conditional<false, T, F>
-{
-    typedef F type;
-};
-
-// For bcc32 which doesn't understand ! in template arguments.
-template<bool>
-struct Not
-{
-    enum { value = 0 };
-};
-
-template<>
-struct Not<false>
-{
-    enum { value = 1 };
-};
-
-template<typename T, T> struct LConvCheck
-{
-    LConvCheck(int) {}
-};
-
-// Returns the thousands separator for the current locale.
-// We check if ``lconv`` contains ``thousands_sep`` because on Android
-// ``lconv`` is stubbed as an empty struct.
-template <typename LConv>
-inline StringRef thousands_sep(
-    LConv *lc, LConvCheck<char *LConv::*, &LConv::thousands_sep> = 0)
-{
-    return lc->thousands_sep;
-}
-
-inline fmt::StringRef thousands_sep(...)
-{
-    return "";
-}
-
-// Makes an Arg object from any type.
-template <typename Formatter>
-class MakeValue : public Arg
-{
-public:
-    typedef typename Formatter::Char Char;
-
-private:
-    // The following two methods are private to disallow formatting of
-    // arbitrary pointers. If you want to output a pointer cast it to
-    // "void *" or "const void *". In particular, this forbids formatting
-    // of "[const] volatile char *" which is printed as bool by iostreams.
-    // Do not implement!
-    template <typename T>
-    MakeValue(const T *value);
-    template <typename T>
-    MakeValue(T *value);
-
-    // The following methods are private to disallow formatting of wide
-    // characters and strings into narrow strings as in
-    //   fmt::format("{}", L"test");
-    // To fix this, use a wide format string: fmt::format(L"{}", L"test").
-#if !FMT_MSC_VER || defined(_NATIVE_WCHAR_T_DEFINED)
-    MakeValue(typename WCharHelper<wchar_t, Char>::Unsupported);
-#endif
-    MakeValue(typename WCharHelper<wchar_t *, Char>::Unsupported);
-    MakeValue(typename WCharHelper<const wchar_t *, Char>::Unsupported);
-    MakeValue(typename WCharHelper<const std::wstring &, Char>::Unsupported);
-    MakeValue(typename WCharHelper<WStringRef, Char>::Unsupported);
-
-    void set_string(StringRef str)
-    {
-        string.value = str.data();
-        string.size = str.size();
-    }
-
-    void set_string(WStringRef str)
-    {
-        wstring.value = str.data();
-        wstring.size = str.size();
-    }
-
-    // Formats an argument of a custom type, such as a user-defined class.
-    template <typename T>
-    static void format_custom_arg(
-        void *formatter, const void *arg, void *format_str_ptr)
-    {
-        format(*static_cast<Formatter*>(formatter),
-               *static_cast<const Char**>(format_str_ptr),
-               *static_cast<const T*>(arg));
-    }
-
-public:
-    MakeValue() {}
-
-#define FMT_MAKE_VALUE_(Type, field, TYPE, rhs) \
-  MakeValue(Type value) { field = rhs; } \
-  static uint64_t type(Type) { return Arg::TYPE; }
-
-#define FMT_MAKE_VALUE(Type, field, TYPE) \
-  FMT_MAKE_VALUE_(Type, field, TYPE, value)
-
-    FMT_MAKE_VALUE(bool, int_value, BOOL)
-    FMT_MAKE_VALUE(short, int_value, INT)
-    FMT_MAKE_VALUE(unsigned short, uint_value, UINT)
-    FMT_MAKE_VALUE(int, int_value, INT)
-    FMT_MAKE_VALUE(unsigned, uint_value, UINT)
-
-    MakeValue(long value)
-    {
-        // To minimize the number of types we need to deal with, long is
-        // translated either to int or to long long depending on its size.
-        if (const_check(sizeof(long) == sizeof(int)))
-            int_value = static_cast<int>(value);
-        else
-            long_long_value = value;
-    }
-    static uint64_t type(long)
-    {
-        return sizeof(long) == sizeof(int) ? Arg::INT : Arg::LONG_LONG;
-    }
-
-    MakeValue(unsigned long value)
-    {
-        if (const_check(sizeof(unsigned long) == sizeof(unsigned)))
-            uint_value = static_cast<unsigned>(value);
-        else
-            ulong_long_value = value;
-    }
-    static uint64_t type(unsigned long)
-    {
-        return sizeof(unsigned long) == sizeof(unsigned) ?
-               Arg::UINT : Arg::ULONG_LONG;
-    }
-
-    FMT_MAKE_VALUE(LongLong, long_long_value, LONG_LONG)
-    FMT_MAKE_VALUE(ULongLong, ulong_long_value, ULONG_LONG)
-    FMT_MAKE_VALUE(float, double_value, DOUBLE)
-    FMT_MAKE_VALUE(double, double_value, DOUBLE)
-    FMT_MAKE_VALUE(long double, long_double_value, LONG_DOUBLE)
-    FMT_MAKE_VALUE(signed char, int_value, INT)
-    FMT_MAKE_VALUE(unsigned char, uint_value, UINT)
-    FMT_MAKE_VALUE(char, int_value, CHAR)
-
-#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
-    MakeValue(typename WCharHelper<wchar_t, Char>::Supported value)
-    {
-        int_value = value;
-    }
-    static uint64_t type(wchar_t)
-    {
-        return Arg::CHAR;
-    }
-#endif
-
-#define FMT_MAKE_STR_VALUE(Type, TYPE) \
-  MakeValue(Type value) { set_string(value); } \
-  static uint64_t type(Type) { return Arg::TYPE; }
-
-    FMT_MAKE_VALUE(char *, string.value, CSTRING)
-    FMT_MAKE_VALUE(const char *, string.value, CSTRING)
-    FMT_MAKE_VALUE(signed char *, sstring.value, CSTRING)
-    FMT_MAKE_VALUE(const signed char *, sstring.value, CSTRING)
-    FMT_MAKE_VALUE(unsigned char *, ustring.value, CSTRING)
-    FMT_MAKE_VALUE(const unsigned char *, ustring.value, CSTRING)
-    FMT_MAKE_STR_VALUE(const std::string &, STRING)
-    FMT_MAKE_STR_VALUE(StringRef, STRING)
-    FMT_MAKE_VALUE_(CStringRef, string.value, CSTRING, value.c_str())
-
-#define FMT_MAKE_WSTR_VALUE(Type, TYPE) \
-  MakeValue(typename WCharHelper<Type, Char>::Supported value) { \
-    set_string(value); \
-  } \
-  static uint64_t type(Type) { return Arg::TYPE; }
-
-    FMT_MAKE_WSTR_VALUE(wchar_t *, WSTRING)
-    FMT_MAKE_WSTR_VALUE(const wchar_t *, WSTRING)
-    FMT_MAKE_WSTR_VALUE(const std::wstring &, WSTRING)
-    FMT_MAKE_WSTR_VALUE(WStringRef, WSTRING)
-
-    FMT_MAKE_VALUE(void *, pointer, POINTER)
-    FMT_MAKE_VALUE(const void *, pointer, POINTER)
-
-    template <typename T>
-    MakeValue(const T &value,
-              typename EnableIf<Not<
-              ConvertToInt<T>::value>::value, int>::type = 0)
-    {
-        custom.value = &value;
-        custom.format = &format_custom_arg<T>;
-    }
-
-    template <typename T>
-    MakeValue(const T &value,
-              typename EnableIf<ConvertToInt<T>::value, int>::type = 0)
-    {
-        int_value = value;
-    }
-
-    template <typename T>
-    static uint64_t type(const T &)
-    {
-        return ConvertToInt<T>::value ? Arg::INT : Arg::CUSTOM;
-    }
-
-    // Additional template param `Char_` is needed here because make_type always
-    // uses char.
-    template <typename Char_>
-    MakeValue(const NamedArg<Char_> &value)
-    {
-        pointer = &value;
-    }
-
-    template <typename Char_>
-    static uint64_t type(const NamedArg<Char_> &)
-    {
-        return Arg::NAMED_ARG;
-    }
-};
-
-template <typename Formatter>
-class MakeArg : public Arg
-{
-public:
-    MakeArg()
-    {
-        type = Arg::NONE;
-    }
-
-    template <typename T>
-    MakeArg(const T &value)
-        : Arg(MakeValue<Formatter>(value))
-    {
-        type = static_cast<Arg::Type>(MakeValue<Formatter>::type(value));
-    }
-};
-
-template <typename Char>
-struct NamedArg : Arg
-{
-    BasicStringRef<Char> name;
-
-    template <typename T>
-    NamedArg(BasicStringRef<Char> argname, const T &value)
-        : Arg(MakeArg< BasicFormatter<Char> >(value)), name(argname) {}
-};
-
-class RuntimeError : public std::runtime_error
-{
-protected:
-    RuntimeError() : std::runtime_error("") {}
-    ~RuntimeError() throw();
-};
-
-template <typename Char>
-class PrintfArgFormatter;
-
-template <typename Char>
-class ArgMap;
-}  // namespace internal
-
-/** An argument list. */
-class ArgList
-{
-private:
-    // To reduce compiled code size per formatting function call, types of first
-    // MAX_PACKED_ARGS arguments are passed in the types_ field.
-    uint64_t types_;
-    union
-    {
-        // If the number of arguments is less than MAX_PACKED_ARGS, the argument
-        // values are stored in values_, otherwise they are stored in args_.
-        // This is done to reduce compiled code size as storing larger objects
-        // may require more code (at least on x86-64) even if the same amount of
-        // data is actually copied to stack. It saves ~10% on the bloat test.
-        const internal::Value *values_;
-        const internal::Arg *args_;
-    };
-
-    internal::Arg::Type type(unsigned index) const
-    {
-        unsigned shift = index * 4;
-        uint64_t mask = 0xf;
-        return static_cast<internal::Arg::Type>(
-                   (types_ & (mask << shift)) >> shift);
-    }
-
-    template <typename Char>
-    friend class internal::ArgMap;
-
-public:
-    // Maximum number of arguments with packed types.
-    enum { MAX_PACKED_ARGS = 16 };
-
-    ArgList() : types_(0) {}
-
-    ArgList(ULongLong types, const internal::Value *values)
-        : types_(types), values_(values) {}
-    ArgList(ULongLong types, const internal::Arg *args)
-        : types_(types), args_(args) {}
-
-    /** Returns the argument at specified index. */
-    internal::Arg operator[](unsigned index) const
-    {
-        using internal::Arg;
-        Arg arg;
-        bool use_values = type(MAX_PACKED_ARGS - 1) == Arg::NONE;
-        if (index < MAX_PACKED_ARGS)
-        {
-            Arg::Type arg_type = type(index);
-            internal::Value &val = arg;
-            if (arg_type != Arg::NONE)
-                val = use_values ? values_[index] : args_[index];
-            arg.type = arg_type;
-            return arg;
-        }
-        if (use_values)
-        {
-            // The index is greater than the number of arguments that can be stored
-            // in values, so return a "none" argument.
-            arg.type = Arg::NONE;
-            return arg;
-        }
-        for (unsigned i = MAX_PACKED_ARGS; i <= index; ++i)
-        {
-            if (args_[i].type == Arg::NONE)
-                return args_[i];
-        }
-        return args_[index];
-    }
-};
-
-#define FMT_DISPATCH(call) static_cast<Impl*>(this)->call
-
-/**
-  \rst
-  An argument visitor based on the `curiously recurring template pattern
-  <http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern>`_.
-
-  To use `~fmt::ArgVisitor` define a subclass that implements some or all of the
-  visit methods with the same signatures as the methods in `~fmt::ArgVisitor`,
-  for example, `~fmt::ArgVisitor::visit_int()`.
-  Pass the subclass as the *Impl* template parameter. Then calling
-  `~fmt::ArgVisitor::visit` for some argument will dispatch to a visit method
-  specific to the argument type. For example, if the argument type is
-  ``double`` then the `~fmt::ArgVisitor::visit_double()` method of a subclass
-  will be called. If the subclass doesn't contain a method with this signature,
-  then a corresponding method of `~fmt::ArgVisitor` will be called.
-
-  **Example**::
-
-    class MyArgVisitor : public fmt::ArgVisitor<MyArgVisitor, void> {
-     public:
-      void visit_int(int value) { fmt::print("{}", value); }
-      void visit_double(double value) { fmt::print("{}", value ); }
-    };
-  \endrst
- */
-template <typename Impl, typename Result>
-class ArgVisitor
-{
-private:
-    typedef internal::Arg Arg;
-
-public:
-    void report_unhandled_arg() {}
-
-    Result visit_unhandled_arg()
-    {
-        FMT_DISPATCH(report_unhandled_arg());
-        return Result();
-    }
-
-    /** Visits an ``int`` argument. **/
-    Result visit_int(int value)
-    {
-        return FMT_DISPATCH(visit_any_int(value));
-    }
-
-    /** Visits a ``long long`` argument. **/
-    Result visit_long_long(LongLong value)
-    {
-        return FMT_DISPATCH(visit_any_int(value));
-    }
-
-    /** Visits an ``unsigned`` argument. **/
-    Result visit_uint(unsigned value)
-    {
-        return FMT_DISPATCH(visit_any_int(value));
-    }
-
-    /** Visits an ``unsigned long long`` argument. **/
-    Result visit_ulong_long(ULongLong value)
-    {
-        return FMT_DISPATCH(visit_any_int(value));
-    }
-
-    /** Visits a ``bool`` argument. **/
-    Result visit_bool(bool value)
-    {
-        return FMT_DISPATCH(visit_any_int(value));
-    }
-
-    /** Visits a ``char`` or ``wchar_t`` argument. **/
-    Result visit_char(int value)
-    {
-        return FMT_DISPATCH(visit_any_int(value));
-    }
-
-    /** Visits an argument of any integral type. **/
-    template <typename T>
-    Result visit_any_int(T)
-    {
-        return FMT_DISPATCH(visit_unhandled_arg());
-    }
-
-    /** Visits a ``double`` argument. **/
-    Result visit_double(double value)
-    {
-        return FMT_DISPATCH(visit_any_double(value));
-    }
-
-    /** Visits a ``long double`` argument. **/
-    Result visit_long_double(long double value)
-    {
-        return FMT_DISPATCH(visit_any_double(value));
-    }
-
-    /** Visits a ``double`` or ``long double`` argument. **/
-    template <typename T>
-    Result visit_any_double(T)
-    {
-        return FMT_DISPATCH(visit_unhandled_arg());
-    }
-
-    /** Visits a null-terminated C string (``const char *``) argument. **/
-    Result visit_cstring(const char *)
-    {
-        return FMT_DISPATCH(visit_unhandled_arg());
-    }
-
-    /** Visits a string argument. **/
-    Result visit_string(Arg::StringValue<char>)
-    {
-        return FMT_DISPATCH(visit_unhandled_arg());
-    }
-
-    /** Visits a wide string argument. **/
-    Result visit_wstring(Arg::StringValue<wchar_t>)
-    {
-        return FMT_DISPATCH(visit_unhandled_arg());
-    }
-
-    /** Visits a pointer argument. **/
-    Result visit_pointer(const void *)
-    {
-        return FMT_DISPATCH(visit_unhandled_arg());
-    }
-
-    /** Visits an argument of a custom (user-defined) type. **/
-    Result visit_custom(Arg::CustomValue)
-    {
-        return FMT_DISPATCH(visit_unhandled_arg());
-    }
-
-    /**
-      \rst
-      Visits an argument dispatching to the appropriate visit method based on
-      the argument type. For example, if the argument type is ``double`` then
-      the `~fmt::ArgVisitor::visit_double()` method of the *Impl* class will be
-      called.
-      \endrst
-     */
-    Result visit(const Arg &arg)
-    {
-        switch (arg.type)
-        {
-        case Arg::NONE:
-        case Arg::NAMED_ARG:
-            FMT_ASSERT(false, "invalid argument type");
-            break;
-        case Arg::INT:
-            return FMT_DISPATCH(visit_int(arg.int_value));
-        case Arg::UINT:
-            return FMT_DISPATCH(visit_uint(arg.uint_value));
-        case Arg::LONG_LONG:
-            return FMT_DISPATCH(visit_long_long(arg.long_long_value));
-        case Arg::ULONG_LONG:
-            return FMT_DISPATCH(visit_ulong_long(arg.ulong_long_value));
-        case Arg::BOOL:
-            return FMT_DISPATCH(visit_bool(arg.int_value != 0));
-        case Arg::CHAR:
-            return FMT_DISPATCH(visit_char(arg.int_value));
-        case Arg::DOUBLE:
-            return FMT_DISPATCH(visit_double(arg.double_value));
-        case Arg::LONG_DOUBLE:
-            return FMT_DISPATCH(visit_long_double(arg.long_double_value));
-        case Arg::CSTRING:
-            return FMT_DISPATCH(visit_cstring(arg.string.value));
-        case Arg::STRING:
-            return FMT_DISPATCH(visit_string(arg.string));
-        case Arg::WSTRING:
-            return FMT_DISPATCH(visit_wstring(arg.wstring));
-        case Arg::POINTER:
-            return FMT_DISPATCH(visit_pointer(arg.pointer));
-        case Arg::CUSTOM:
-            return FMT_DISPATCH(visit_custom(arg.custom));
-        }
-        return Result();
-    }
-};
-
-enum Alignment
-{
-    ALIGN_DEFAULT, ALIGN_LEFT, ALIGN_RIGHT, ALIGN_CENTER, ALIGN_NUMERIC
-};
-
-// Flags.
-enum
-{
-    SIGN_FLAG = 1, PLUS_FLAG = 2, MINUS_FLAG = 4, HASH_FLAG = 8,
-    CHAR_FLAG = 0x10  // Argument has char type - used in error reporting.
-};
-
-// An empty format specifier.
-struct EmptySpec {};
-
-// A type specifier.
-template <char TYPE>
-struct TypeSpec : EmptySpec
-{
-    Alignment align() const
-    {
-        return ALIGN_DEFAULT;
-    }
-    unsigned width() const
-    {
-        return 0;
-    }
-    int precision() const
-    {
-        return -1;
-    }
-    bool flag(unsigned) const
-    {
-        return false;
-    }
-    char type() const
-    {
-        return TYPE;
-    }
-    char fill() const
-    {
-        return ' ';
-    }
-};
-
-// A width specifier.
-struct WidthSpec
-{
-    unsigned width_;
-    // Fill is always wchar_t and cast to char if necessary to avoid having
-    // two specialization of WidthSpec and its subclasses.
-    wchar_t fill_;
-
-    WidthSpec(unsigned width, wchar_t fill) : width_(width), fill_(fill) {}
-
-    unsigned width() const
-    {
-        return width_;
-    }
-    wchar_t fill() const
-    {
-        return fill_;
-    }
-};
-
-// An alignment specifier.
-struct AlignSpec : WidthSpec
-{
-    Alignment align_;
-
-    AlignSpec(unsigned width, wchar_t fill, Alignment align = ALIGN_DEFAULT)
-        : WidthSpec(width, fill), align_(align) {}
-
-    Alignment align() const
-    {
-        return align_;
-    }
-
-    int precision() const
-    {
-        return -1;
-    }
-};
-
-// An alignment and type specifier.
-template <char TYPE>
-struct AlignTypeSpec : AlignSpec
-{
-    AlignTypeSpec(unsigned width, wchar_t fill) : AlignSpec(width, fill) {}
-
-    bool flag(unsigned) const
-    {
-        return false;
-    }
-    char type() const
-    {
-        return TYPE;
-    }
-};
-
-// A full format specifier.
-struct FormatSpec : AlignSpec
-{
-    unsigned flags_;
-    int precision_;
-    char type_;
-
-    FormatSpec(
-        unsigned width = 0, char type = 0, wchar_t fill = ' ')
-        : AlignSpec(width, fill), flags_(0), precision_(-1), type_(type) {}
-
-    bool flag(unsigned f) const
-    {
-        return (flags_ & f) != 0;
-    }
-    int precision() const
-    {
-        return precision_;
-    }
-    char type() const
-    {
-        return type_;
-    }
-};
-
-// An integer format specifier.
-template <typename T, typename SpecT = TypeSpec<0>, typename Char = char>
-class IntFormatSpec : public SpecT
-{
-private:
-    T value_;
-
-public:
-    IntFormatSpec(T val, const SpecT &spec = SpecT())
-        : SpecT(spec), value_(val) {}
-
-    T value() const
-    {
-        return value_;
-    }
-};
-
-// A string format specifier.
-template <typename Char>
-class StrFormatSpec : public AlignSpec
-{
-private:
-    const Char *str_;
-
-public:
-    template <typename FillChar>
-    StrFormatSpec(const Char *str, unsigned width, FillChar fill)
-        : AlignSpec(width, fill), str_(str)
-    {
-        internal::CharTraits<Char>::convert(FillChar());
-    }
-
-    const Char *str() const
-    {
-        return str_;
-    }
-};
-
-/**
-  Returns an integer format specifier to format the value in base 2.
- */
-IntFormatSpec<int, TypeSpec<'b'> > bin(int value);
-
-/**
-  Returns an integer format specifier to format the value in base 8.
- */
-IntFormatSpec<int, TypeSpec<'o'> > oct(int value);
-
-/**
-  Returns an integer format specifier to format the value in base 16 using
-  lower-case letters for the digits above 9.
- */
-IntFormatSpec<int, TypeSpec<'x'> > hex(int value);
-
-/**
-  Returns an integer formatter format specifier to format in base 16 using
-  upper-case letters for the digits above 9.
- */
-IntFormatSpec<int, TypeSpec<'X'> > hexu(int value);
-
-/**
-  \rst
-  Returns an integer format specifier to pad the formatted argument with the
-  fill character to the specified width using the default (right) numeric
-  alignment.
-
-  **Example**::
-
-    MemoryWriter out;
-    out << pad(hex(0xcafe), 8, '0');
-    // out.str() == "0000cafe"
-
-  \endrst
- */
-template <char TYPE_CODE, typename Char>
-IntFormatSpec<int, AlignTypeSpec<TYPE_CODE>, Char> pad(
-    int value, unsigned width, Char fill = ' ');
-
-#define FMT_DEFINE_INT_FORMATTERS(TYPE) \
-inline IntFormatSpec<TYPE, TypeSpec<'b'> > bin(TYPE value) { \
-  return IntFormatSpec<TYPE, TypeSpec<'b'> >(value, TypeSpec<'b'>()); \
-} \
- \
-inline IntFormatSpec<TYPE, TypeSpec<'o'> > oct(TYPE value) { \
-  return IntFormatSpec<TYPE, TypeSpec<'o'> >(value, TypeSpec<'o'>()); \
-} \
- \
-inline IntFormatSpec<TYPE, TypeSpec<'x'> > hex(TYPE value) { \
-  return IntFormatSpec<TYPE, TypeSpec<'x'> >(value, TypeSpec<'x'>()); \
-} \
- \
-inline IntFormatSpec<TYPE, TypeSpec<'X'> > hexu(TYPE value) { \
-  return IntFormatSpec<TYPE, TypeSpec<'X'> >(value, TypeSpec<'X'>()); \
-} \
- \
-template <char TYPE_CODE> \
-inline IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE> > pad( \
-    IntFormatSpec<TYPE, TypeSpec<TYPE_CODE> > f, unsigned width) { \
-  return IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE> >( \
-      f.value(), AlignTypeSpec<TYPE_CODE>(width, ' ')); \
-} \
- \
-/* For compatibility with older compilers we provide two overloads for pad, */ \
-/* one that takes a fill character and one that doesn't. In the future this */ \
-/* can be replaced with one overload making the template argument Char      */ \
-/* default to char (C++11). */ \
-template <char TYPE_CODE, typename Char> \
-inline IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE>, Char> pad( \
-    IntFormatSpec<TYPE, TypeSpec<TYPE_CODE>, Char> f, \
-    unsigned width, Char fill) { \
-  return IntFormatSpec<TYPE, AlignTypeSpec<TYPE_CODE>, Char>( \
-      f.value(), AlignTypeSpec<TYPE_CODE>(width, fill)); \
-} \
- \
-inline IntFormatSpec<TYPE, AlignTypeSpec<0> > pad( \
-    TYPE value, unsigned width) { \
-  return IntFormatSpec<TYPE, AlignTypeSpec<0> >( \
-      value, AlignTypeSpec<0>(width, ' ')); \
-} \
- \
-template <typename Char> \
-inline IntFormatSpec<TYPE, AlignTypeSpec<0>, Char> pad( \
-   TYPE value, unsigned width, Char fill) { \
- return IntFormatSpec<TYPE, AlignTypeSpec<0>, Char>( \
-     value, AlignTypeSpec<0>(width, fill)); \
-}
-
-FMT_DEFINE_INT_FORMATTERS(int)
-FMT_DEFINE_INT_FORMATTERS(long)
-FMT_DEFINE_INT_FORMATTERS(unsigned)
-FMT_DEFINE_INT_FORMATTERS(unsigned long)
-FMT_DEFINE_INT_FORMATTERS(LongLong)
-FMT_DEFINE_INT_FORMATTERS(ULongLong)
-
-/**
-  \rst
-  Returns a string formatter that pads the formatted argument with the fill
-  character to the specified width using the default (left) string alignment.
-
-  **Example**::
-
-    std::string s = str(MemoryWriter() << pad("abc", 8));
-    // s == "abc     "
-
-  \endrst
- */
-template <typename Char>
-inline StrFormatSpec<Char> pad(
-    const Char *str, unsigned width, Char fill = ' ')
-{
-    return StrFormatSpec<Char>(str, width, fill);
-}
-
-inline StrFormatSpec<wchar_t> pad(
-    const wchar_t *str, unsigned width, char fill = ' ')
-{
-    return StrFormatSpec<wchar_t>(str, width, fill);
-}
-
-namespace internal
-{
-
-template <typename Char>
-class ArgMap
-{
-private:
-    typedef std::vector<
-    std::pair<fmt::BasicStringRef<Char>, internal::Arg> > MapType;
-    typedef typename MapType::value_type Pair;
-
-    MapType map_;
-
-public:
-    FMT_API void init(const ArgList &args);
-
-    const internal::Arg* find(const fmt::BasicStringRef<Char> &name) const
-    {
-        // The list is unsorted, so just return the first matching name.
-        for (typename MapType::const_iterator it = map_.begin(), end = map_.end();
-                it != end; ++it)
-        {
-            if (it->first == name)
-                return &it->second;
-        }
-        return 0;
-    }
-};
-
-template <typename Impl, typename Char>
-class ArgFormatterBase : public ArgVisitor<Impl, void>
-{
-private:
-    BasicWriter<Char> &writer_;
-    FormatSpec &spec_;
-
-    FMT_DISALLOW_COPY_AND_ASSIGN(ArgFormatterBase);
-
-    void write_pointer(const void *p)
-    {
-        spec_.flags_ = HASH_FLAG;
-        spec_.type_ = 'x';
-        writer_.write_int(reinterpret_cast<uintptr_t>(p), spec_);
-    }
-
-protected:
-    BasicWriter<Char> &writer()
-    {
-        return writer_;
-    }
-    FormatSpec &spec()
-    {
-        return spec_;
-    }
-
-    void write(bool value)
-    {
-        const char *str_value = value ? "true" : "false";
-        Arg::StringValue<char> str = { str_value, std::strlen(str_value) };
-        writer_.write_str(str, spec_);
-    }
-
-    void write(const char *value)
-    {
-        Arg::StringValue<char> str = {value, value != 0 ? std::strlen(value) : 0};
-        writer_.write_str(str, spec_);
-    }
-
-public:
-    ArgFormatterBase(BasicWriter<Char> &w, FormatSpec &s)
-        : writer_(w), spec_(s) {}
-
-    template <typename T>
-    void visit_any_int(T value)
-    {
-        writer_.write_int(value, spec_);
-    }
-
-    template <typename T>
-    void visit_any_double(T value)
-    {
-        writer_.write_double(value, spec_);
-    }
-
-    void visit_bool(bool value)
-    {
-        if (spec_.type_)
-            return visit_any_int(value);
-        write(value);
-    }
-
-    void visit_char(int value)
-    {
-        if (spec_.type_ && spec_.type_ != 'c')
-        {
-            spec_.flags_ |= CHAR_FLAG;
-            writer_.write_int(value, spec_);
-            return;
-        }
-        if (spec_.align_ == ALIGN_NUMERIC || spec_.flags_ != 0)
-            FMT_THROW(FormatError("invalid format specifier for char"));
-        typedef typename BasicWriter<Char>::CharPtr CharPtr;
-        Char fill = internal::CharTraits<Char>::cast(spec_.fill());
-        CharPtr out = CharPtr();
-        const unsigned CHAR_SIZE = 1;
-        if (spec_.width_ > CHAR_SIZE)
-        {
-            out = writer_.grow_buffer(spec_.width_);
-            if (spec_.align_ == ALIGN_RIGHT)
-            {
-                std::uninitialized_fill_n(out, spec_.width_ - CHAR_SIZE, fill);
-                out += spec_.width_ - CHAR_SIZE;
-            }
-            else if (spec_.align_ == ALIGN_CENTER)
-            {
-                out = writer_.fill_padding(out, spec_.width_,
-                                           internal::const_check(CHAR_SIZE), fill);
-            }
-            else
-            {
-                std::uninitialized_fill_n(out + CHAR_SIZE,
-                                          spec_.width_ - CHAR_SIZE, fill);
-            }
-        }
-        else
-        {
-            out = writer_.grow_buffer(CHAR_SIZE);
-        }
-        *out = internal::CharTraits<Char>::cast(value);
-    }
-
-    void visit_cstring(const char *value)
-    {
-        if (spec_.type_ == 'p')
-            return write_pointer(value);
-        write(value);
-    }
-
-    void visit_string(Arg::StringValue<char> value)
-    {
-        writer_.write_str(value, spec_);
-    }
-
-    using ArgVisitor<Impl, void>::visit_wstring;
-
-    void visit_wstring(Arg::StringValue<Char> value)
-    {
-        writer_.write_str(value, spec_);
-    }
-
-    void visit_pointer(const void *value)
-    {
-        if (spec_.type_ && spec_.type_ != 'p')
-            report_unknown_type(spec_.type_, "pointer");
-        write_pointer(value);
-    }
-};
-
-class FormatterBase
-{
-private:
-    ArgList args_;
-    int next_arg_index_;
-
-    // Returns the argument with specified index.
-    FMT_API Arg do_get_arg(unsigned arg_index, const char *&error);
-
-protected:
-    const ArgList &args() const
-    {
-        return args_;
-    }
-
-    explicit FormatterBase(const ArgList &args)
-    {
-        args_ = args;
-        next_arg_index_ = 0;
-    }
-
-    // Returns the next argument.
-    Arg next_arg(const char *&error)
-    {
-        if (next_arg_index_ >= 0)
-            return do_get_arg(internal::to_unsigned(next_arg_index_++), error);
-        error = "cannot switch from manual to automatic argument indexing";
-        return Arg();
-    }
-
-    // Checks if manual indexing is used and returns the argument with
-    // specified index.
-    Arg get_arg(unsigned arg_index, const char *&error)
-    {
-        return check_no_auto_index(error) ? do_get_arg(arg_index, error) : Arg();
-    }
-
-    bool check_no_auto_index(const char *&error)
-    {
-        if (next_arg_index_ > 0)
-        {
-            error = "cannot switch from automatic to manual argument indexing";
-            return false;
-        }
-        next_arg_index_ = -1;
-        return true;
-    }
-
-    template <typename Char>
-    void write(BasicWriter<Char> &w, const Char *start, const Char *end)
-    {
-        if (start != end)
-            w << BasicStringRef<Char>(start, internal::to_unsigned(end - start));
-    }
-};
-
-// A printf formatter.
-template <typename Char>
-class PrintfFormatter : private FormatterBase
-{
-private:
-    void parse_flags(FormatSpec &spec, const Char *&s);
-
-    // Returns the argument with specified index or, if arg_index is equal
-    // to the maximum unsigned value, the next argument.
-    Arg get_arg(const Char *s,
-                unsigned arg_index = (std::numeric_limits<unsigned>::max)());
-
-    // Parses argument index, flags and width and returns the argument index.
-    unsigned parse_header(const Char *&s, FormatSpec &spec);
-
-public:
-    explicit PrintfFormatter(const ArgList &args) : FormatterBase(args) {}
-    FMT_API void format(BasicWriter<Char> &writer,
-                        BasicCStringRef<Char> format_str);
-};
-}  // namespace internal
-
-/**
-  \rst
-  An argument formatter based on the `curiously recurring template pattern
-  <http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern>`_.
-
-  To use `~fmt::BasicArgFormatter` define a subclass that implements some or
-  all of the visit methods with the same signatures as the methods in
-  `~fmt::ArgVisitor`, for example, `~fmt::ArgVisitor::visit_int()`.
-  Pass the subclass as the *Impl* template parameter. When a formatting
-  function processes an argument, it will dispatch to a visit method
-  specific to the argument type. For example, if the argument type is
-  ``double`` then the `~fmt::ArgVisitor::visit_double()` method of a subclass
-  will be called. If the subclass doesn't contain a method with this signature,
-  then a corresponding method of `~fmt::BasicArgFormatter` or its superclass
-  will be called.
-  \endrst
- */
-template <typename Impl, typename Char>
-class BasicArgFormatter : public internal::ArgFormatterBase<Impl, Char>
-{
-private:
-    BasicFormatter<Char, Impl> &formatter_;
-    const Char *format_;
-
-public:
-    /**
-      \rst
-      Constructs an argument formatter object.
-      *formatter* is a reference to the main formatter object, *spec* contains
-      format specifier information for standard argument types, and *fmt* points
-      to the part of the format string being parsed for custom argument types.
-      \endrst
-     */
-    BasicArgFormatter(BasicFormatter<Char, Impl> &formatter,
-                      FormatSpec &spec, const Char *fmt)
-        : internal::ArgFormatterBase<Impl, Char>(formatter.writer(), spec),
-          formatter_(formatter), format_(fmt) {}
-
-    /** Formats argument of a custom (user-defined) type. */
-    void visit_custom(internal::Arg::CustomValue c)
-    {
-        c.format(&formatter_, c.value, &format_);
-    }
-};
-
-/** The default argument formatter. */
-template <typename Char>
-class ArgFormatter : public BasicArgFormatter<ArgFormatter<Char>, Char>
-{
-public:
-    /** Constructs an argument formatter object. */
-    ArgFormatter(BasicFormatter<Char> &formatter,
-                 FormatSpec &spec, const Char *fmt)
-        : BasicArgFormatter<ArgFormatter<Char>, Char>(formatter, spec, fmt) {}
-};
-
-/** This template formats data and writes the output to a writer. */
-template <typename CharType, typename ArgFormatter>
-class BasicFormatter : private internal::FormatterBase
-{
-public:
-    /** The character type for the output. */
-    typedef CharType Char;
-
-private:
-    BasicWriter<Char> &writer_;
-    internal::ArgMap<Char> map_;
-
-    FMT_DISALLOW_COPY_AND_ASSIGN(BasicFormatter);
-
-    using internal::FormatterBase::get_arg;
-
-    // Checks if manual indexing is used and returns the argument with
-    // specified name.
-    internal::Arg get_arg(BasicStringRef<Char> arg_name, const char *&error);
-
-    // Parses argument index and returns corresponding argument.
-    internal::Arg parse_arg_index(const Char *&s);
-
-    // Parses argument name and returns corresponding argument.
-    internal::Arg parse_arg_name(const Char *&s);
-
-public:
-    /**
-     \rst
-     Constructs a ``BasicFormatter`` object. References to the arguments and
-     the writer are stored in the formatter object so make sure they have
-     appropriate lifetimes.
-     \endrst
-     */
-    BasicFormatter(const ArgList &args, BasicWriter<Char> &w)
-        : internal::FormatterBase(args), writer_(w) {}
-
-    /** Returns a reference to the writer associated with this formatter. */
-    BasicWriter<Char> &writer()
-    {
-        return writer_;
-    }
-
-    /** Formats stored arguments and writes the output to the writer. */
-    void format(BasicCStringRef<Char> format_str);
-
-    // Formats a single argument and advances format_str, a format string pointer.
-    const Char *format(const Char *&format_str, const internal::Arg &arg);
-};
-
-// Generates a comma-separated list with results of applying f to
-// numbers 0..n-1.
-# define FMT_GEN(n, f) FMT_GEN##n(f)
-# define FMT_GEN1(f)  f(0)
-# define FMT_GEN2(f)  FMT_GEN1(f),  f(1)
-# define FMT_GEN3(f)  FMT_GEN2(f),  f(2)
-# define FMT_GEN4(f)  FMT_GEN3(f),  f(3)
-# define FMT_GEN5(f)  FMT_GEN4(f),  f(4)
-# define FMT_GEN6(f)  FMT_GEN5(f),  f(5)
-# define FMT_GEN7(f)  FMT_GEN6(f),  f(6)
-# define FMT_GEN8(f)  FMT_GEN7(f),  f(7)
-# define FMT_GEN9(f)  FMT_GEN8(f),  f(8)
-# define FMT_GEN10(f) FMT_GEN9(f),  f(9)
-# define FMT_GEN11(f) FMT_GEN10(f), f(10)
-# define FMT_GEN12(f) FMT_GEN11(f), f(11)
-# define FMT_GEN13(f) FMT_GEN12(f), f(12)
-# define FMT_GEN14(f) FMT_GEN13(f), f(13)
-# define FMT_GEN15(f) FMT_GEN14(f), f(14)
-
-namespace internal
-{
-inline uint64_t make_type()
-{
-    return 0;
-}
-
-template <typename T>
-inline uint64_t make_type(const T &arg)
-{
-    return MakeValue< BasicFormatter<char> >::type(arg);
-}
-
-template <unsigned N, bool/*IsPacked*/= (N < ArgList::MAX_PACKED_ARGS)>
-          struct ArgArray;
-
-template <unsigned N>
-struct ArgArray<N, true/*IsPacked*/>
-{
-    typedef Value Type[N > 0 ? N : 1];
-
-template <typename Formatter, typename T>
-static Value make(const T &value)
-{
-#ifdef __clang__
-    Value result = MakeValue<Formatter>(value);
-    // Workaround a bug in Apple LLVM version 4.2 (clang-425.0.28) of clang:
-    // https://github.com/fmtlib/fmt/issues/276
-    (void)result.custom.format;
-    return result;
-#else
-    return MakeValue<Formatter>(value);
-#endif
-}
-         };
-
-template <unsigned N>
-struct ArgArray<N, false/*IsPacked*/>
-{
-    typedef Arg Type[N + 1]; // +1 for the list end Arg::NONE
-
-    template <typename Formatter, typename T>
-    static Arg make(const T &value)
-    {
-        return MakeArg<Formatter>(value);
-    }
-};
-
-#if FMT_USE_VARIADIC_TEMPLATES
-template <typename Arg, typename... Args>
-inline uint64_t make_type(const Arg &first, const Args & ... tail)
-{
-    return make_type(first) | (make_type(tail...) << 4);
-}
-
-#else
-
-struct ArgType
-{
-    uint64_t type;
-
-    ArgType() : type(0) {}
-
-    template <typename T>
-    ArgType(const T &arg) : type(make_type(arg)) {}
-};
-
-# define FMT_ARG_TYPE_DEFAULT(n) ArgType t##n = ArgType()
-
-inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT))
-{
-    return t0.type | (t1.type << 4) | (t2.type << 8) | (t3.type << 12) |
-           (t4.type << 16) | (t5.type << 20) | (t6.type << 24) | (t7.type << 28) |
-           (t8.type << 32) | (t9.type << 36) | (t10.type << 40) | (t11.type << 44) |
-           (t12.type << 48) | (t13.type << 52) | (t14.type << 56);
-}
-#endif
-}  // namespace internal
-
-# define FMT_MAKE_TEMPLATE_ARG(n) typename T##n
-# define FMT_MAKE_ARG_TYPE(n) T##n
-# define FMT_MAKE_ARG(n) const T##n &v##n
-# define FMT_ASSIGN_char(n) \
-  arr[n] = fmt::internal::MakeValue< fmt::BasicFormatter<char> >(v##n)
-# define FMT_ASSIGN_wchar_t(n) \
-  arr[n] = fmt::internal::MakeValue< fmt::BasicFormatter<wchar_t> >(v##n)
-
-#if FMT_USE_VARIADIC_TEMPLATES
-// Defines a variadic function returning void.
-# define FMT_VARIADIC_VOID(func, arg_type) \
-  template <typename... Args> \
-  void func(arg_type arg0, const Args & ... args) { \
-    typedef fmt::internal::ArgArray<sizeof...(Args)> ArgArray; \
-    typename ArgArray::Type array{ \
-      ArgArray::template make<fmt::BasicFormatter<Char> >(args)...}; \
-    func(arg0, fmt::ArgList(fmt::internal::make_type(args...), array)); \
-  }
-
-// Defines a variadic constructor.
-# define FMT_VARIADIC_CTOR(ctor, func, arg0_type, arg1_type) \
-  template <typename... Args> \
-  ctor(arg0_type arg0, arg1_type arg1, const Args & ... args) { \
-    typedef fmt::internal::ArgArray<sizeof...(Args)> ArgArray; \
-    typename ArgArray::Type array{ \
-      ArgArray::template make<fmt::BasicFormatter<Char> >(args)...}; \
-    func(arg0, arg1, fmt::ArgList(fmt::internal::make_type(args...), array)); \
-  }
-
-#else
-
-# define FMT_MAKE_REF(n) \
-  fmt::internal::MakeValue< fmt::BasicFormatter<Char> >(v##n)
-# define FMT_MAKE_REF2(n) v##n
-
-// Defines a wrapper for a function taking one argument of type arg_type
-// and n additional arguments of arbitrary types.
-# define FMT_WRAP1(func, arg_type, n) \
-  template <FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \
-  inline void func(arg_type arg1, FMT_GEN(n, FMT_MAKE_ARG)) { \
-    const fmt::internal::ArgArray<n>::Type array = {FMT_GEN(n, FMT_MAKE_REF)}; \
-    func(arg1, fmt::ArgList( \
-      fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), array)); \
-  }
-
-// Emulates a variadic function returning void on a pre-C++11 compiler.
-# define FMT_VARIADIC_VOID(func, arg_type) \
-  inline void func(arg_type arg) { func(arg, fmt::ArgList()); } \
-  FMT_WRAP1(func, arg_type, 1) FMT_WRAP1(func, arg_type, 2) \
-  FMT_WRAP1(func, arg_type, 3) FMT_WRAP1(func, arg_type, 4) \
-  FMT_WRAP1(func, arg_type, 5) FMT_WRAP1(func, arg_type, 6) \
-  FMT_WRAP1(func, arg_type, 7) FMT_WRAP1(func, arg_type, 8) \
-  FMT_WRAP1(func, arg_type, 9) FMT_WRAP1(func, arg_type, 10)
-
-# define FMT_CTOR(ctor, func, arg0_type, arg1_type, n) \
-  template <FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \
-  ctor(arg0_type arg0, arg1_type arg1, FMT_GEN(n, FMT_MAKE_ARG)) { \
-    const fmt::internal::ArgArray<n>::Type array = {FMT_GEN(n, FMT_MAKE_REF)}; \
-    func(arg0, arg1, fmt::ArgList( \
-      fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), array)); \
-  }
-
-// Emulates a variadic constructor on a pre-C++11 compiler.
-# define FMT_VARIADIC_CTOR(ctor, func, arg0_type, arg1_type) \
-  FMT_CTOR(ctor, func, arg0_type, arg1_type, 1) \
-  FMT_CTOR(ctor, func, arg0_type, arg1_type, 2) \
-  FMT_CTOR(ctor, func, arg0_type, arg1_type, 3) \
-  FMT_CTOR(ctor, func, arg0_type, arg1_type, 4) \
-  FMT_CTOR(ctor, func, arg0_type, arg1_type, 5) \
-  FMT_CTOR(ctor, func, arg0_type, arg1_type, 6) \
-  FMT_CTOR(ctor, func, arg0_type, arg1_type, 7) \
-  FMT_CTOR(ctor, func, arg0_type, arg1_type, 8) \
-  FMT_CTOR(ctor, func, arg0_type, arg1_type, 9) \
-  FMT_CTOR(ctor, func, arg0_type, arg1_type, 10)
-#endif
-
-// Generates a comma-separated list with results of applying f to pairs
-// (argument, index).
-#define FMT_FOR_EACH1(f, x0) f(x0, 0)
-#define FMT_FOR_EACH2(f, x0, x1) \
-  FMT_FOR_EACH1(f, x0), f(x1, 1)
-#define FMT_FOR_EACH3(f, x0, x1, x2) \
-  FMT_FOR_EACH2(f, x0 ,x1), f(x2, 2)
-#define FMT_FOR_EACH4(f, x0, x1, x2, x3) \
-  FMT_FOR_EACH3(f, x0, x1, x2), f(x3, 3)
-#define FMT_FOR_EACH5(f, x0, x1, x2, x3, x4) \
-  FMT_FOR_EACH4(f, x0, x1, x2, x3), f(x4, 4)
-#define FMT_FOR_EACH6(f, x0, x1, x2, x3, x4, x5) \
-  FMT_FOR_EACH5(f, x0, x1, x2, x3, x4), f(x5, 5)
-#define FMT_FOR_EACH7(f, x0, x1, x2, x3, x4, x5, x6) \
-  FMT_FOR_EACH6(f, x0, x1, x2, x3, x4, x5), f(x6, 6)
-#define FMT_FOR_EACH8(f, x0, x1, x2, x3, x4, x5, x6, x7) \
-  FMT_FOR_EACH7(f, x0, x1, x2, x3, x4, x5, x6), f(x7, 7)
-#define FMT_FOR_EACH9(f, x0, x1, x2, x3, x4, x5, x6, x7, x8) \
-  FMT_FOR_EACH8(f, x0, x1, x2, x3, x4, x5, x6, x7), f(x8, 8)
-#define FMT_FOR_EACH10(f, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) \
-  FMT_FOR_EACH9(f, x0, x1, x2, x3, x4, x5, x6, x7, x8), f(x9, 9)
-
-/**
- An error returned by an operating system or a language runtime,
- for example a file opening error.
-*/
-class SystemError : public internal::RuntimeError
-{
-private:
-    void init(int err_code, CStringRef format_str, ArgList args);
-
-protected:
-    int error_code_;
-
-    typedef char Char;  // For FMT_VARIADIC_CTOR.
-
-    SystemError() {}
-
-public:
-    /**
-     \rst
-     Constructs a :class:`fmt::SystemError` object with the description
-     of the form
-
-     .. parsed-literal::
-       *<message>*: *<system-message>*
-
-     where *<message>* is the formatted message and *<system-message>* is
-     the system message corresponding to the error code.
-     *error_code* is a system error code as given by ``errno``.
-     If *error_code* is not a valid error code such as -1, the system message
-     may look like "Unknown error -1" and is platform-dependent.
-
-     **Example**::
-
-       // This throws a SystemError with the description
-       //   cannot open file 'madeup': No such file or directory
-       // or similar (system message may vary).
-       const char *filename = "madeup";
-       std::FILE *file = std::fopen(filename, "r");
-       if (!file)
-         throw fmt::SystemError(errno, "cannot open file '{}'", filename);
-     \endrst
-    */
-    SystemError(int error_code, CStringRef message)
-    {
-        init(error_code, message, ArgList());
-    }
-    FMT_VARIADIC_CTOR(SystemError, init, int, CStringRef)
-
-    ~SystemError() throw();
-
-    int error_code() const
-    {
-        return error_code_;
-    }
-};
-
-/**
-  \rst
-  This template provides operations for formatting and writing data into
-  a character stream. The output is stored in a buffer provided by a subclass
-  such as :class:`fmt::BasicMemoryWriter`.
-
-  You can use one of the following typedefs for common character types:
-
-  +---------+----------------------+
-  | Type    | Definition           |
-  +=========+======================+
-  | Writer  | BasicWriter<char>    |
-  +---------+----------------------+
-  | WWriter | BasicWriter<wchar_t> |
-  +---------+----------------------+
-
-  \endrst
- */
-template <typename Char>
-class BasicWriter
-{
-private:
-    // Output buffer.
-    Buffer<Char> &buffer_;
-
-    FMT_DISALLOW_COPY_AND_ASSIGN(BasicWriter);
-
-    typedef typename internal::CharTraits<Char>::CharPtr CharPtr;
-
-#if FMT_SECURE_SCL
-    // Returns pointer value.
-    static Char *get(CharPtr p)
-    {
-        return p.base();
-    }
-#else
-    static Char *get(Char *p)
-    {
-        return p;
-    }
-#endif
-
-    // Fills the padding around the content and returns the pointer to the
-    // content area.
-    static CharPtr fill_padding(CharPtr buffer,
-                                unsigned total_size, std::size_t content_size, wchar_t fill);
-
-    // Grows the buffer by n characters and returns a pointer to the newly
-    // allocated area.
-    CharPtr grow_buffer(std::size_t n)
-    {
-        std::size_t size = buffer_.size();
-        buffer_.resize(size + n);
-        return internal::make_ptr(&buffer_[size], n);
-    }
-
-    // Writes an unsigned decimal integer.
-    template <typename UInt>
-    Char *write_unsigned_decimal(UInt value, unsigned prefix_size = 0)
-    {
-        unsigned num_digits = internal::count_digits(value);
-        Char *ptr = get(grow_buffer(prefix_size + num_digits));
-        internal::format_decimal(ptr + prefix_size, value, num_digits);
-        return ptr;
-    }
-
-    // Writes a decimal integer.
-    template <typename Int>
-    void write_decimal(Int value)
-    {
-        typedef typename internal::IntTraits<Int>::MainType MainType;
-        MainType abs_value = static_cast<MainType>(value);
-        if (internal::is_negative(value))
-        {
-            abs_value = 0 - abs_value;
-            *write_unsigned_decimal(abs_value, 1) = '-';
-        }
-        else
-        {
-            write_unsigned_decimal(abs_value, 0);
-        }
-    }
-
-    // Prepare a buffer for integer formatting.
-    CharPtr prepare_int_buffer(unsigned num_digits,
-                               const EmptySpec &, const char *prefix, unsigned prefix_size)
-    {
-        unsigned size = prefix_size + num_digits;
-        CharPtr p = grow_buffer(size);
-        std::uninitialized_copy(prefix, prefix + prefix_size, p);
-        return p + size - 1;
-    }
-
-    template <typename Spec>
-    CharPtr prepare_int_buffer(unsigned num_digits,
-                               const Spec &spec, const char *prefix, unsigned prefix_size);
-
-    // Formats an integer.
-    template <typename T, typename Spec>
-    void write_int(T value, Spec spec);
-
-    // Formats a floating-point number (double or long double).
-    template <typename T>
-    void write_double(T value, const FormatSpec &spec);
-
-    // Writes a formatted string.
-    template <typename StrChar>
-    CharPtr write_str(const StrChar *s, std::size_t size, const AlignSpec &spec);
-
-    template <typename StrChar>
-    void write_str(const internal::Arg::StringValue<StrChar> &str,
-                   const FormatSpec &spec);
-
-    // This following methods are private to disallow writing wide characters
-    // and strings to a char stream. If you want to print a wide string as a
-    // pointer as std::ostream does, cast it to const void*.
-    // Do not implement!
-    void operator<<(typename internal::WCharHelper<wchar_t, Char>::Unsupported);
-    void operator<<(
-        typename internal::WCharHelper<const wchar_t *, Char>::Unsupported);
-
-    // Appends floating-point length specifier to the format string.
-    // The second argument is only used for overload resolution.
-    void append_float_length(Char *&format_ptr, long double)
-    {
-        *format_ptr++ = 'L';
-    }
-
-    template<typename T>
-    void append_float_length(Char *&, T) {}
-
-    template <typename Impl, typename Char_>
-    friend class internal::ArgFormatterBase;
-
-    friend class internal::PrintfArgFormatter<Char>;
-
-protected:
-    /**
-      Constructs a ``BasicWriter`` object.
-     */
-    explicit BasicWriter(Buffer<Char> &b) : buffer_(b) {}
-
-public:
-    /**
-      \rst
-      Destroys a ``BasicWriter`` object.
-      \endrst
-     */
-    virtual ~BasicWriter() {}
-
-    /**
-      Returns the total number of characters written.
-     */
-    std::size_t size() const
-    {
-        return buffer_.size();
-    }
-
-    /**
-      Returns a pointer to the output buffer content. No terminating null
-      character is appended.
-     */
-    const Char *data() const FMT_NOEXCEPT
-    {
-        return &buffer_[0];
-    }
-
-    /**
-      Returns a pointer to the output buffer content with terminating null
-      character appended.
-     */
-    const Char *c_str() const
-    {
-        std::size_t size = buffer_.size();
-        buffer_.reserve(size + 1);
-        buffer_[size] = '\0';
-        return &buffer_[0];
-    }
-
-    /**
-      \rst
-      Returns the content of the output buffer as an `std::string`.
-      \endrst
-     */
-    std::basic_string<Char> str() const
-    {
-        return std::basic_string<Char>(&buffer_[0], buffer_.size());
-    }
-
-    /**
-      \rst
-      Writes formatted data.
-
-      *args* is an argument list representing arbitrary arguments.
-
-      **Example**::
-
-         MemoryWriter out;
-         out.write("Current point:\n");
-         out.write("({:+f}, {:+f})", -3.14, 3.14);
-
-      This will write the following output to the ``out`` object:
-
-      .. code-block:: none
-
-         Current point:
-         (-3.140000, +3.140000)
-
-      The output can be accessed using :func:`data()`, :func:`c_str` or
-      :func:`str` methods.
-
-      See also :ref:`syntax`.
-      \endrst
-     */
-    void write(BasicCStringRef<Char> format, ArgList args)
-    {
-        BasicFormatter<Char>(args, *this).format(format);
-    }
-    FMT_VARIADIC_VOID(write, BasicCStringRef<Char>)
-
-    BasicWriter &operator<<(int value)
-    {
-        write_decimal(value);
-        return *this;
-    }
-    BasicWriter &operator<<(unsigned value)
-    {
-        return *this << IntFormatSpec<unsigned>(value);
-    }
-    BasicWriter &operator<<(long value)
-    {
-        write_decimal(value);
-        return *this;
-    }
-    BasicWriter &operator<<(unsigned long value)
-    {
-        return *this << IntFormatSpec<unsigned long>(value);
-    }
-    BasicWriter &operator<<(LongLong value)
-    {
-        write_decimal(value);
-        return *this;
-    }
-
-    /**
-      \rst
-      Formats *value* and writes it to the stream.
-      \endrst
-     */
-    BasicWriter &operator<<(ULongLong value)
-    {
-        return *this << IntFormatSpec<ULongLong>(value);
-    }
-
-    BasicWriter &operator<<(double value)
-    {
-        write_double(value, FormatSpec());
-        return *this;
-    }
-
-    /**
-      \rst
-      Formats *value* using the general format for floating-point numbers
-      (``'g'``) and writes it to the stream.
-      \endrst
-     */
-    BasicWriter &operator<<(long double value)
-    {
-        write_double(value, FormatSpec());
-        return *this;
-    }
-
-    /**
-      Writes a character to the stream.
-     */
-    BasicWriter &operator<<(char value)
-    {
-        buffer_.push_back(value);
-        return *this;
-    }
-
-    BasicWriter &operator<<(
-        typename internal::WCharHelper<wchar_t, Char>::Supported value)
-    {
-        buffer_.push_back(value);
-        return *this;
-    }
-
-    /**
-      \rst
-      Writes *value* to the stream.
-      \endrst
-     */
-    BasicWriter &operator<<(fmt::BasicStringRef<Char> value)
-    {
-        const Char *str = value.data();
-        buffer_.append(str, str + value.size());
-        return *this;
-    }
-
-    BasicWriter &operator<<(
-        typename internal::WCharHelper<StringRef, Char>::Supported value)
-    {
-        const char *str = value.data();
-        buffer_.append(str, str + value.size());
-        return *this;
-    }
-
-    template <typename T, typename Spec, typename FillChar>
-    BasicWriter &operator<<(IntFormatSpec<T, Spec, FillChar> spec)
-    {
-        internal::CharTraits<Char>::convert(FillChar());
-        write_int(spec.value(), spec);
-        return *this;
-    }
-
-    template <typename StrChar>
-    BasicWriter &operator<<(const StrFormatSpec<StrChar> &spec)
-    {
-        const StrChar *s = spec.str();
-        write_str(s, std::char_traits<Char>::length(s), spec);
-        return *this;
-    }
-
-    void clear() FMT_NOEXCEPT { buffer_.clear(); }
-
-    Buffer<Char> &buffer() FMT_NOEXCEPT { return buffer_; }
-};
-
-template <typename Char>
-template <typename StrChar>
-typename BasicWriter<Char>::CharPtr BasicWriter<Char>::write_str(
-    const StrChar *s, std::size_t size, const AlignSpec &spec)
-{
-    CharPtr out = CharPtr();
-    if (spec.width() > size)
-    {
-        out = grow_buffer(spec.width());
-        Char fill = internal::CharTraits<Char>::cast(spec.fill());
-        if (spec.align() == ALIGN_RIGHT)
-        {
-            std::uninitialized_fill_n(out, spec.width() - size, fill);
-            out += spec.width() - size;
-        }
-        else if (spec.align() == ALIGN_CENTER)
-        {
-            out = fill_padding(out, spec.width(), size, fill);
-        }
-        else
-        {
-            std::uninitialized_fill_n(out + size, spec.width() - size, fill);
-        }
-    }
-    else
-    {
-        out = grow_buffer(size);
-    }
-    std::uninitialized_copy(s, s + size, out);
-    return out;
-}
-
-template <typename Char>
-template <typename StrChar>
-void BasicWriter<Char>::write_str(
-    const internal::Arg::StringValue<StrChar> &s, const FormatSpec &spec)
-{
-    // Check if StrChar is convertible to Char.
-    internal::CharTraits<Char>::convert(StrChar());
-    if (spec.type_ && spec.type_ != 's')
-        internal::report_unknown_type(spec.type_, "string");
-    const StrChar *str_value = s.value;
-    std::size_t str_size = s.size;
-    if (str_size == 0)
-    {
-        if (!str_value)
-        {
-            FMT_THROW(FormatError("string pointer is null"));
-        }
-    }
-    std::size_t precision = static_cast<std::size_t>(spec.precision_);
-    if (spec.precision_ >= 0 && precision < str_size)
-        str_size = precision;
-    write_str(str_value, str_size, spec);
-}
-
-template <typename Char>
-typename BasicWriter<Char>::CharPtr
-BasicWriter<Char>::fill_padding(
-    CharPtr buffer, unsigned total_size,
-    std::size_t content_size, wchar_t fill)
-{
-    std::size_t padding = total_size - content_size;
-    std::size_t left_padding = padding / 2;
-    Char fill_char = internal::CharTraits<Char>::cast(fill);
-    std::uninitialized_fill_n(buffer, left_padding, fill_char);
-    buffer += left_padding;
-    CharPtr content = buffer;
-    std::uninitialized_fill_n(buffer + content_size,
-                              padding - left_padding, fill_char);
-    return content;
-}
-
-template <typename Char>
-template <typename Spec>
-typename BasicWriter<Char>::CharPtr
-BasicWriter<Char>::prepare_int_buffer(
-    unsigned num_digits, const Spec &spec,
-    const char *prefix, unsigned prefix_size)
-{
-    unsigned width = spec.width();
-    Alignment align = spec.align();
-    Char fill = internal::CharTraits<Char>::cast(spec.fill());
-    if (spec.precision() > static_cast<int>(num_digits))
-    {
-        // Octal prefix '0' is counted as a digit, so ignore it if precision
-        // is specified.
-        if (prefix_size > 0 && prefix[prefix_size - 1] == '0')
-            --prefix_size;
-        unsigned number_size =
-            prefix_size + internal::to_unsigned(spec.precision());
-        AlignSpec subspec(number_size, '0', ALIGN_NUMERIC);
-        if (number_size >= width)
-            return prepare_int_buffer(num_digits, subspec, prefix, prefix_size);
-        buffer_.reserve(width);
-        unsigned fill_size = width - number_size;
-        if (align != ALIGN_LEFT)
-        {
-            CharPtr p = grow_buffer(fill_size);
-            std::uninitialized_fill(p, p + fill_size, fill);
-        }
-        CharPtr result = prepare_int_buffer(
-                             num_digits, subspec, prefix, prefix_size);
-        if (align == ALIGN_LEFT)
-        {
-            CharPtr p = grow_buffer(fill_size);
-            std::uninitialized_fill(p, p + fill_size, fill);
-        }
-        return result;
-    }
-    unsigned size = prefix_size + num_digits;
-    if (width <= size)
-    {
-        CharPtr p = grow_buffer(size);
-        std::uninitialized_copy(prefix, prefix + prefix_size, p);
-        return p + size - 1;
-    }
-    CharPtr p = grow_buffer(width);
-    CharPtr end = p + width;
-    if (align == ALIGN_LEFT)
-    {
-        std::uninitialized_copy(prefix, prefix + prefix_size, p);
-        p += size;
-        std::uninitialized_fill(p, end, fill);
-    }
-    else if (align == ALIGN_CENTER)
-    {
-        p = fill_padding(p, width, size, fill);
-        std::uninitialized_copy(prefix, prefix + prefix_size, p);
-        p += size;
-    }
-    else
-    {
-        if (align == ALIGN_NUMERIC)
-        {
-            if (prefix_size != 0)
-            {
-                p = std::uninitialized_copy(prefix, prefix + prefix_size, p);
-                size -= prefix_size;
-            }
-        }
-        else
-        {
-            std::uninitialized_copy(prefix, prefix + prefix_size, end - size);
-        }
-        std::uninitialized_fill(p, end - size, fill);
-        p = end;
-    }
-    return p - 1;
-}
-
-template <typename Char>
-template <typename T, typename Spec>
-void BasicWriter<Char>::write_int(T value, Spec spec)
-{
-    unsigned prefix_size = 0;
-    typedef typename internal::IntTraits<T>::MainType UnsignedType;
-    UnsignedType abs_value = static_cast<UnsignedType>(value);
-    char prefix[4] = "";
-    if (internal::is_negative(value))
-    {
-        prefix[0] = '-';
-        ++prefix_size;
-        abs_value = 0 - abs_value;
-    }
-    else if (spec.flag(SIGN_FLAG))
-    {
-        prefix[0] = spec.flag(PLUS_FLAG) ? '+' : ' ';
-        ++prefix_size;
-    }
-    switch (spec.type())
-    {
-    case 0:
-    case 'd':
-    {
-        unsigned num_digits = internal::count_digits(abs_value);
-        CharPtr p = prepare_int_buffer(num_digits, spec, prefix, prefix_size) + 1;
-        internal::format_decimal(get(p), abs_value, 0);
-        break;
-    }
-    case 'x':
-    case 'X':
-    {
-        UnsignedType n = abs_value;
-        if (spec.flag(HASH_FLAG))
-        {
-            prefix[prefix_size++] = '0';
-            prefix[prefix_size++] = spec.type();
-        }
-        unsigned num_digits = 0;
-        do
-        {
-            ++num_digits;
-        }
-        while ((n >>= 4) != 0);
-        Char *p = get(prepare_int_buffer(
-                          num_digits, spec, prefix, prefix_size));
-        n = abs_value;
-        const char *digits = spec.type() == 'x' ?
-                             "0123456789abcdef" : "0123456789ABCDEF";
-        do
-        {
-            *p-- = digits[n & 0xf];
-        }
-        while ((n >>= 4) != 0);
-        break;
-    }
-    case 'b':
-    case 'B':
-    {
-        UnsignedType n = abs_value;
-        if (spec.flag(HASH_FLAG))
-        {
-            prefix[prefix_size++] = '0';
-            prefix[prefix_size++] = spec.type();
-        }
-        unsigned num_digits = 0;
-        do
-        {
-            ++num_digits;
-        }
-        while ((n >>= 1) != 0);
-        Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size));
-        n = abs_value;
-        do
-        {
-            *p-- = static_cast<Char>('0' + (n & 1));
-        }
-        while ((n >>= 1) != 0);
-        break;
-    }
-    case 'o':
-    {
-        UnsignedType n = abs_value;
-        if (spec.flag(HASH_FLAG))
-            prefix[prefix_size++] = '0';
-        unsigned num_digits = 0;
-        do
-        {
-            ++num_digits;
-        }
-        while ((n >>= 3) != 0);
-        Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size));
-        n = abs_value;
-        do
-        {
-            *p-- = static_cast<Char>('0' + (n & 7));
-        }
-        while ((n >>= 3) != 0);
-        break;
-    }
-    case 'n':
-    {
-        unsigned num_digits = internal::count_digits(abs_value);
-        fmt::StringRef sep = "";
-#ifndef ANDROID
-        sep = internal::thousands_sep(std::localeconv());
-#endif
-        unsigned size = static_cast<unsigned>(
-                            num_digits + sep.size() * ((num_digits - 1) / 3));
-        CharPtr p = prepare_int_buffer(size, spec, prefix, prefix_size) + 1;
-        internal::format_decimal(get(p), abs_value, 0, internal::ThousandsSep(sep));
-        break;
-    }
-    default:
-        internal::report_unknown_type(
-            spec.type(), spec.flag(CHAR_FLAG) ? "char" : "integer");
-        break;
-    }
-}
-
-template <typename Char>
-template <typename T>
-void BasicWriter<Char>::write_double(T value, const FormatSpec &spec)
-{
-    // Check type.
-    char type = spec.type();
-    bool upper = false;
-    switch (type)
-    {
-    case 0:
-        type = 'g';
-        break;
-    case 'e':
-    case 'f':
-    case 'g':
-    case 'a':
-        break;
-    case 'F':
-#if FMT_MSC_VER
-        // MSVC's printf doesn't support 'F'.
-        type = 'f';
-#endif
-    // Fall through.
-    case 'E':
-    case 'G':
-    case 'A':
-        upper = true;
-        break;
-    default:
-        internal::report_unknown_type(type, "double");
-        break;
-    }
-
-    char sign = 0;
-    // Use isnegative instead of value < 0 because the latter is always
-    // false for NaN.
-    if (internal::FPUtil::isnegative(static_cast<double>(value)))
-    {
-        sign = '-';
-        value = -value;
-    }
-    else if (spec.flag(SIGN_FLAG))
-    {
-        sign = spec.flag(PLUS_FLAG) ? '+' : ' ';
-    }
-
-    if (internal::FPUtil::isnotanumber(value))
-    {
-        // Format NaN ourselves because sprintf's output is not consistent
-        // across platforms.
-        std::size_t nan_size = 4;
-        const char *nan = upper ? " NAN" : " nan";
-        if (!sign)
-        {
-            --nan_size;
-            ++nan;
-        }
-        CharPtr out = write_str(nan, nan_size, spec);
-        if (sign)
-            *out = sign;
-        return;
-    }
-
-    if (internal::FPUtil::isinfinity(value))
-    {
-        // Format infinity ourselves because sprintf's output is not consistent
-        // across platforms.
-        std::size_t inf_size = 4;
-        const char *inf = upper ? " INF" : " inf";
-        if (!sign)
-        {
-            --inf_size;
-            ++inf;
-        }
-        CharPtr out = write_str(inf, inf_size, spec);
-        if (sign)
-            *out = sign;
-        return;
-    }
-
-    std::size_t offset = buffer_.size();
-    unsigned width = spec.width();
-    if (sign)
-    {
-        buffer_.reserve(buffer_.size() + (width > 1u ? width : 1u));
-        if (width > 0)
-            --width;
-        ++offset;
-    }
-
-    // Build format string.
-    enum { MAX_FORMAT_SIZE = 10}; // longest format: %#-*.*Lg
-    Char format[MAX_FORMAT_SIZE];
-    Char *format_ptr = format;
-    *format_ptr++ = '%';
-    unsigned width_for_sprintf = width;
-    if (spec.flag(HASH_FLAG))
-        *format_ptr++ = '#';
-    if (spec.align() == ALIGN_CENTER)
-    {
-        width_for_sprintf = 0;
-    }
-    else
-    {
-        if (spec.align() == ALIGN_LEFT)
-            *format_ptr++ = '-';
-        if (width != 0)
-            *format_ptr++ = '*';
-    }
-    if (spec.precision() >= 0)
-    {
-        *format_ptr++ = '.';
-        *format_ptr++ = '*';
-    }
-
-    append_float_length(format_ptr, value);
-    *format_ptr++ = type;
-    *format_ptr = '\0';
-
-    // Format using snprintf.
-    Char fill = internal::CharTraits<Char>::cast(spec.fill());
-    unsigned n = 0;
-    Char *start = 0;
-    for (;;)
-    {
-        std::size_t buffer_size = buffer_.capacity() - offset;
-#if FMT_MSC_VER
-        // MSVC's vsnprintf_s doesn't work with zero size, so reserve
-        // space for at least one extra character to make the size non-zero.
-        // Note that the buffer's capacity will increase by more than 1.
-        if (buffer_size == 0)
-        {
-            buffer_.reserve(offset + 1);
-            buffer_size = buffer_.capacity() - offset;
-        }
-#endif
-        start = &buffer_[offset];
-        int result = internal::CharTraits<Char>::format_float(
-                         start, buffer_size, format, width_for_sprintf, spec.precision(), value);
-        if (result >= 0)
-        {
-            n = internal::to_unsigned(result);
-            if (offset + n < buffer_.capacity())
-                break;  // The buffer is large enough - continue with formatting.
-            buffer_.reserve(offset + n + 1);
-        }
-        else
-        {
-            // If result is negative we ask to increase the capacity by at least 1,
-            // but as std::vector, the buffer grows exponentially.
-            buffer_.reserve(buffer_.capacity() + 1);
-        }
-    }
-    if (sign)
-    {
-        if ((spec.align() != ALIGN_RIGHT && spec.align() != ALIGN_DEFAULT) ||
-                *start != ' ')
-        {
-            *(start - 1) = sign;
-            sign = 0;
-        }
-        else
-        {
-            *(start - 1) = fill;
-        }
-        ++n;
-    }
-    if (spec.align() == ALIGN_CENTER && spec.width() > n)
-    {
-        width = spec.width();
-        CharPtr p = grow_buffer(width);
-        std::memmove(get(p) + (width - n) / 2, get(p), n * sizeof(Char));
-        fill_padding(p, spec.width(), n, fill);
-        return;
-    }
-    if (spec.fill() != ' ' || sign)
-    {
-        while (*start == ' ')
-            *start++ = fill;
-        if (sign)
-            *(start - 1) = sign;
-    }
-    grow_buffer(n);
-}
-
-/**
-  \rst
-  This class template provides operations for formatting and writing data
-  into a character stream. The output is stored in a memory buffer that grows
-  dynamically.
-
-  You can use one of the following typedefs for common character types
-  and the standard allocator:
-
-  +---------------+-----------------------------------------------------+
-  | Type          | Definition                                          |
-  +===============+=====================================================+
-  | MemoryWriter  | BasicMemoryWriter<char, std::allocator<char>>       |
-  +---------------+-----------------------------------------------------+
-  | WMemoryWriter | BasicMemoryWriter<wchar_t, std::allocator<wchar_t>> |
-  +---------------+-----------------------------------------------------+
-
-  **Example**::
-
-     MemoryWriter out;
-     out << "The answer is " << 42 << "\n";
-     out.write("({:+f}, {:+f})", -3.14, 3.14);
-
-  This will write the following output to the ``out`` object:
-
-  .. code-block:: none
-
-     The answer is 42
-     (-3.140000, +3.140000)
-
-  The output can be converted to an ``std::string`` with ``out.str()`` or
-  accessed as a C string with ``out.c_str()``.
-  \endrst
- */
-template <typename Char, typename Allocator = std::allocator<Char> >
-class BasicMemoryWriter : public BasicWriter<Char>
-{
-private:
-    internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE, Allocator> buffer_;
-
-public:
-    explicit BasicMemoryWriter(const Allocator& alloc = Allocator())
-        : BasicWriter<Char>(buffer_), buffer_(alloc) {}
-
-#if FMT_USE_RVALUE_REFERENCES
-    /**
-      \rst
-      Constructs a :class:`fmt::BasicMemoryWriter` object moving the content
-      of the other object to it.
-      \endrst
-     */
-    BasicMemoryWriter(BasicMemoryWriter &&other)
-        : BasicWriter<Char>(buffer_), buffer_(std::move(other.buffer_))
-    {
-    }
-
-    /**
-      \rst
-      Moves the content of the other ``BasicMemoryWriter`` object to this one.
-      \endrst
-     */
-    BasicMemoryWriter &operator=(BasicMemoryWriter &&other)
-    {
-        buffer_ = std::move(other.buffer_);
-        return *this;
-    }
-#endif
-};
-
-typedef BasicMemoryWriter<char> MemoryWriter;
-typedef BasicMemoryWriter<wchar_t> WMemoryWriter;
-
-/**
-  \rst
-  This class template provides operations for formatting and writing data
-  into a fixed-size array. For writing into a dynamically growing buffer
-  use :class:`fmt::BasicMemoryWriter`.
-
-  Any write method will throw ``std::runtime_error`` if the output doesn't fit
-  into the array.
-
-  You can use one of the following typedefs for common character types:
-
-  +--------------+---------------------------+
-  | Type         | Definition                |
-  +==============+===========================+
-  | ArrayWriter  | BasicArrayWriter<char>    |
-  +--------------+---------------------------+
-  | WArrayWriter | BasicArrayWriter<wchar_t> |
-  +--------------+---------------------------+
-  \endrst
- */
-template <typename Char>
-class BasicArrayWriter : public BasicWriter<Char>
-{
-private:
-    internal::FixedBuffer<Char> buffer_;
-
-public:
-    /**
-     \rst
-     Constructs a :class:`fmt::BasicArrayWriter` object for *array* of the
-     given size.
-     \endrst
-     */
-    BasicArrayWriter(Char *array, std::size_t size)
-        : BasicWriter<Char>(buffer_), buffer_(array, size) {}
-
-    /**
-     \rst
-     Constructs a :class:`fmt::BasicArrayWriter` object for *array* of the
-     size known at compile time.
-     \endrst
-     */
-    template <std::size_t SIZE>
-    explicit BasicArrayWriter(Char (&array)[SIZE])
-        : BasicWriter<Char>(buffer_), buffer_(array, SIZE) {}
-};
-
-typedef BasicArrayWriter<char> ArrayWriter;
-typedef BasicArrayWriter<wchar_t> WArrayWriter;
-
-// Reports a system error without throwing an exception.
-// Can be used to report errors from destructors.
-FMT_API void report_system_error(int error_code,
-                                 StringRef message) FMT_NOEXCEPT;
-
-#if FMT_USE_WINDOWS_H
-
-/** A Windows error. */
-class WindowsError : public SystemError
-{
-private:
-    FMT_API void init(int error_code, CStringRef format_str, ArgList args);
-
-public:
-    /**
-     \rst
-     Constructs a :class:`fmt::WindowsError` object with the description
-     of the form
-
-     .. parsed-literal::
-       *<message>*: *<system-message>*
-
-     where *<message>* is the formatted message and *<system-message>* is the
-     system message corresponding to the error code.
-     *error_code* is a Windows error code as given by ``GetLastError``.
-     If *error_code* is not a valid error code such as -1, the system message
-     will look like "error -1".
-
-     **Example**::
-
-       // This throws a WindowsError with the description
-       //   cannot open file 'madeup': The system cannot find the file specified.
-       // or similar (system message may vary).
-       const char *filename = "madeup";
-       LPOFSTRUCT of = LPOFSTRUCT();
-       HFILE file = OpenFile(filename, &of, OF_READ);
-       if (file == HFILE_ERROR) {
-         throw fmt::WindowsError(GetLastError(),
-                                 "cannot open file '{}'", filename);
-       }
-     \endrst
-    */
-    WindowsError(int error_code, CStringRef message)
-    {
-        init(error_code, message, ArgList());
-    }
-    FMT_VARIADIC_CTOR(WindowsError, init, int, CStringRef)
-};
-
-// Reports a Windows error without throwing an exception.
-// Can be used to report errors from destructors.
-FMT_API void report_windows_error(int error_code,
-                                  StringRef message) FMT_NOEXCEPT;
-
-#endif
-
-enum Color { BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE };
-
-/**
-  Formats a string and prints it to stdout using ANSI escape sequences
-  to specify color (experimental).
-  Example:
-    print_colored(fmt::RED, "Elapsed time: {0:.2f} seconds", 1.23);
- */
-FMT_API void print_colored(Color c, CStringRef format, ArgList args);
-
-/**
-  \rst
-  Formats arguments and returns the result as a string.
-
-  **Example**::
-
-    std::string message = format("The answer is {}", 42);
-  \endrst
-*/
-inline std::string format(CStringRef format_str, ArgList args)
-{
-    MemoryWriter w;
-    w.write(format_str, args);
-    return w.str();
-}
-
-inline std::wstring format(WCStringRef format_str, ArgList args)
-{
-    WMemoryWriter w;
-    w.write(format_str, args);
-    return w.str();
-}
-
-/**
-  \rst
-  Prints formatted data to the file *f*.
-
-  **Example**::
-
-    print(stderr, "Don't {}!", "panic");
-  \endrst
- */
-FMT_API void print(std::FILE *f, CStringRef format_str, ArgList args);
-
-/**
-  \rst
-  Prints formatted data to ``stdout``.
-
-  **Example**::
-
-    print("Elapsed time: {0:.2f} seconds", 1.23);
-  \endrst
- */
-FMT_API void print(CStringRef format_str, ArgList args);
-
-template <typename Char>
-void printf(BasicWriter<Char> &w, BasicCStringRef<Char> format, ArgList args)
-{
-    internal::PrintfFormatter<Char>(args).format(w, format);
-}
-
-/**
-  \rst
-  Formats arguments and returns the result as a string.
-
-  **Example**::
-
-    std::string message = fmt::sprintf("The answer is %d", 42);
-  \endrst
-*/
-inline std::string sprintf(CStringRef format, ArgList args)
-{
-    MemoryWriter w;
-    printf(w, format, args);
-    return w.str();
-}
-
-inline std::wstring sprintf(WCStringRef format, ArgList args)
-{
-    WMemoryWriter w;
-    printf(w, format, args);
-    return w.str();
-}
-
-/**
-  \rst
-  Prints formatted data to the file *f*.
-
-  **Example**::
-
-    fmt::fprintf(stderr, "Don't %s!", "panic");
-  \endrst
- */
-FMT_API int fprintf(std::FILE *f, CStringRef format, ArgList args);
-
-/**
-  \rst
-  Prints formatted data to ``stdout``.
-
-  **Example**::
-
-    fmt::printf("Elapsed time: %.2f seconds", 1.23);
-  \endrst
- */
-inline int printf(CStringRef format, ArgList args)
-{
-    return fprintf(stdout, format, args);
-}
-
-/**
-  Fast integer formatter.
- */
-class FormatInt
-{
-private:
-    // Buffer should be large enough to hold all digits (digits10 + 1),
-    // a sign and a null character.
-    enum {BUFFER_SIZE = std::numeric_limits<ULongLong>::digits10 + 3};
-    mutable char buffer_[BUFFER_SIZE];
-    char *str_;
-
-    // Formats value in reverse and returns the number of digits.
-    char *format_decimal(ULongLong value)
-    {
-        char *buffer_end = buffer_ + BUFFER_SIZE - 1;
-        while (value >= 100)
-        {
-            // Integer division is slow so do it for a group of two digits instead
-            // of for every digit. The idea comes from the talk by Alexandrescu
-            // "Three Optimization Tips for C++". See speed-test for a comparison.
-            unsigned index = static_cast<unsigned>((value % 100) * 2);
-            value /= 100;
-            *--buffer_end = internal::Data::DIGITS[index + 1];
-            *--buffer_end = internal::Data::DIGITS[index];
-        }
-        if (value < 10)
-        {
-            *--buffer_end = static_cast<char>('0' + value);
-            return buffer_end;
-        }
-        unsigned index = static_cast<unsigned>(value * 2);
-        *--buffer_end = internal::Data::DIGITS[index + 1];
-        *--buffer_end = internal::Data::DIGITS[index];
-        return buffer_end;
-    }
-
-    void FormatSigned(LongLong value)
-    {
-        ULongLong abs_value = static_cast<ULongLong>(value);
-        bool negative = value < 0;
-        if (negative)
-            abs_value = 0 - abs_value;
-        str_ = format_decimal(abs_value);
-        if (negative)
-            *--str_ = '-';
-    }
-
-public:
-    explicit FormatInt(int value)
-    {
-        FormatSigned(value);
-    }
-    explicit FormatInt(long value)
-    {
-        FormatSigned(value);
-    }
-    explicit FormatInt(LongLong value)
-    {
-        FormatSigned(value);
-    }
-    explicit FormatInt(unsigned value) : str_(format_decimal(value)) {}
-    explicit FormatInt(unsigned long value) : str_(format_decimal(value)) {}
-    explicit FormatInt(ULongLong value) : str_(format_decimal(value)) {}
-
-    /** Returns the number of characters written to the output buffer. */
-    std::size_t size() const
-    {
-        return internal::to_unsigned(buffer_ - str_ + BUFFER_SIZE - 1);
-    }
-
-    /**
-      Returns a pointer to the output buffer content. No terminating null
-      character is appended.
-     */
-    const char *data() const
-    {
-        return str_;
-    }
-
-    /**
-      Returns a pointer to the output buffer content with terminating null
-      character appended.
-     */
-    const char *c_str() const
-    {
-        buffer_[BUFFER_SIZE - 1] = '\0';
-        return str_;
-    }
-
-    /**
-      \rst
-      Returns the content of the output buffer as an ``std::string``.
-      \endrst
-     */
-    std::string str() const
-    {
-        return std::string(str_, size());
-    }
-};
-
-// Formats a decimal integer value writing into buffer and returns
-// a pointer to the end of the formatted string. This function doesn't
-// write a terminating null character.
-template <typename T>
-inline void format_decimal(char *&buffer, T value)
-{
-    typedef typename internal::IntTraits<T>::MainType MainType;
-    MainType abs_value = static_cast<MainType>(value);
-    if (internal::is_negative(value))
-    {
-        *buffer++ = '-';
-        abs_value = 0 - abs_value;
-    }
-    if (abs_value < 100)
-    {
-        if (abs_value < 10)
-        {
-            *buffer++ = static_cast<char>('0' + abs_value);
-            return;
-        }
-        unsigned index = static_cast<unsigned>(abs_value * 2);
-        *buffer++ = internal::Data::DIGITS[index];
-        *buffer++ = internal::Data::DIGITS[index + 1];
-        return;
-    }
-    unsigned num_digits = internal::count_digits(abs_value);
-    internal::format_decimal(buffer, abs_value, num_digits);
-    buffer += num_digits;
-}
-
-/**
-  \rst
-  Returns a named argument for formatting functions.
-
-  **Example**::
-
-    print("Elapsed time: {s:.2f} seconds", arg("s", 1.23));
-
-  \endrst
- */
-template <typename T>
-inline internal::NamedArg<char> arg(StringRef name, const T &arg)
-{
-    return internal::NamedArg<char>(name, arg);
-}
-
-template <typename T>
-inline internal::NamedArg<wchar_t> arg(WStringRef name, const T &arg)
-{
-    return internal::NamedArg<wchar_t>(name, arg);
-}
-
-// The following two functions are deleted intentionally to disable
-// nested named arguments as in ``format("{}", arg("a", arg("b", 42)))``.
-template <typename Char>
-void arg(StringRef, const internal::NamedArg<Char>&) FMT_DELETED_OR_UNDEFINED;
-template <typename Char>
-void arg(WStringRef, const internal::NamedArg<Char>&) FMT_DELETED_OR_UNDEFINED;
-}
-
-#if FMT_GCC_VERSION
-// Use the system_header pragma to suppress warnings about variadic macros
-// because suppressing -Wvariadic-macros with the diagnostic pragma doesn't
-// work. It is used at the end because we want to suppress as little warnings
-// as possible.
-# pragma GCC system_header
-#endif
-
-// This is used to work around VC++ bugs in handling variadic macros.
-#define FMT_EXPAND(args) args
-
-// Returns the number of arguments.
-// Based on https://groups.google.com/forum/#!topic/comp.std.c/d-6Mj5Lko_s.
-#define FMT_NARG(...) FMT_NARG_(__VA_ARGS__, FMT_RSEQ_N())
-#define FMT_NARG_(...) FMT_EXPAND(FMT_ARG_N(__VA_ARGS__))
-#define FMT_ARG_N(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N
-#define FMT_RSEQ_N() 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0
-
-#define FMT_CONCAT(a, b) a##b
-#define FMT_FOR_EACH_(N, f, ...) \
-  FMT_EXPAND(FMT_CONCAT(FMT_FOR_EACH, N)(f, __VA_ARGS__))
-#define FMT_FOR_EACH(f, ...) \
-  FMT_EXPAND(FMT_FOR_EACH_(FMT_NARG(__VA_ARGS__), f, __VA_ARGS__))
-
-#define FMT_ADD_ARG_NAME(type, index) type arg##index
-#define FMT_GET_ARG_NAME(type, index) arg##index
-
-#if FMT_USE_VARIADIC_TEMPLATES
-# define FMT_VARIADIC_(Char, ReturnType, func, call, ...) \
-  template <typename... Args> \
-  ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__), \
-      const Args & ... args) { \
-    typedef fmt::internal::ArgArray<sizeof...(Args)> ArgArray; \
-    typename ArgArray::Type array{ \
-      ArgArray::template make<fmt::BasicFormatter<Char> >(args)...}; \
-    call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), \
-      fmt::ArgList(fmt::internal::make_type(args...), array)); \
-  }
-#else
-// Defines a wrapper for a function taking __VA_ARGS__ arguments
-// and n additional arguments of arbitrary types.
-# define FMT_WRAP(Char, ReturnType, func, call, n, ...) \
-  template <FMT_GEN(n, FMT_MAKE_TEMPLATE_ARG)> \
-  inline ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__), \
-      FMT_GEN(n, FMT_MAKE_ARG)) { \
-    fmt::internal::ArgArray<n>::Type arr; \
-    FMT_GEN(n, FMT_ASSIGN_##Char); \
-    call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), fmt::ArgList( \
-      fmt::internal::make_type(FMT_GEN(n, FMT_MAKE_REF2)), arr)); \
-  }
-
-# define FMT_VARIADIC_(Char, ReturnType, func, call, ...) \
-  inline ReturnType func(FMT_FOR_EACH(FMT_ADD_ARG_NAME, __VA_ARGS__)) { \
-    call(FMT_FOR_EACH(FMT_GET_ARG_NAME, __VA_ARGS__), fmt::ArgList()); \
-  } \
-  FMT_WRAP(Char, ReturnType, func, call, 1, __VA_ARGS__) \
-  FMT_WRAP(Char, ReturnType, func, call, 2, __VA_ARGS__) \
-  FMT_WRAP(Char, ReturnType, func, call, 3, __VA_ARGS__) \
-  FMT_WRAP(Char, ReturnType, func, call, 4, __VA_ARGS__) \
-  FMT_WRAP(Char, ReturnType, func, call, 5, __VA_ARGS__) \
-  FMT_WRAP(Char, ReturnType, func, call, 6, __VA_ARGS__) \
-  FMT_WRAP(Char, ReturnType, func, call, 7, __VA_ARGS__) \
-  FMT_WRAP(Char, ReturnType, func, call, 8, __VA_ARGS__) \
-  FMT_WRAP(Char, ReturnType, func, call, 9, __VA_ARGS__) \
-  FMT_WRAP(Char, ReturnType, func, call, 10, __VA_ARGS__) \
-  FMT_WRAP(Char, ReturnType, func, call, 11, __VA_ARGS__) \
-  FMT_WRAP(Char, ReturnType, func, call, 12, __VA_ARGS__) \
-  FMT_WRAP(Char, ReturnType, func, call, 13, __VA_ARGS__) \
-  FMT_WRAP(Char, ReturnType, func, call, 14, __VA_ARGS__) \
-  FMT_WRAP(Char, ReturnType, func, call, 15, __VA_ARGS__)
-#endif  // FMT_USE_VARIADIC_TEMPLATES
-
-/**
-  \rst
-  Defines a variadic function with the specified return type, function name
-  and argument types passed as variable arguments to this macro.
-
-  **Example**::
-
-    void print_error(const char *file, int line, const char *format,
-                     fmt::ArgList args) {
-      fmt::print("{}: {}: ", file, line);
-      fmt::print(format, args);
-    }
-    FMT_VARIADIC(void, print_error, const char *, int, const char *)
-
-  ``FMT_VARIADIC`` is used for compatibility with legacy C++ compilers that
-  don't implement variadic templates. You don't have to use this macro if
-  you don't need legacy compiler support and can use variadic templates
-  directly::
-
-    template <typename... Args>
-    void print_error(const char *file, int line, const char *format,
-                     const Args & ... args) {
-      fmt::print("{}: {}: ", file, line);
-      fmt::print(format, args...);
-    }
-  \endrst
- */
-#define FMT_VARIADIC(ReturnType, func, ...) \
-  FMT_VARIADIC_(char, ReturnType, func, return func, __VA_ARGS__)
-
-#define FMT_VARIADIC_W(ReturnType, func, ...) \
-  FMT_VARIADIC_(wchar_t, ReturnType, func, return func, __VA_ARGS__)
-
-#define FMT_CAPTURE_ARG_(id, index) ::fmt::arg(#id, id)
-
-#define FMT_CAPTURE_ARG_W_(id, index) ::fmt::arg(L###id, id)
-
-/**
-  \rst
-  Convenient macro to capture the arguments' names and values into several
-  ``fmt::arg(name, value)``.
-
-  **Example**::
-
-    int x = 1, y = 2;
-    print("point: ({x}, {y})", FMT_CAPTURE(x, y));
-    // same as:
-    // print("point: ({x}, {y})", arg("x", x), arg("y", y));
-
-  \endrst
- */
-#define FMT_CAPTURE(...) FMT_FOR_EACH(FMT_CAPTURE_ARG_, __VA_ARGS__)
-
-#define FMT_CAPTURE_W(...) FMT_FOR_EACH(FMT_CAPTURE_ARG_W_, __VA_ARGS__)
-
-namespace fmt
-{
-FMT_VARIADIC(std::string, format, CStringRef)
-FMT_VARIADIC_W(std::wstring, format, WCStringRef)
-FMT_VARIADIC(void, print, CStringRef)
-FMT_VARIADIC(void, print, std::FILE *, CStringRef)
-
-FMT_VARIADIC(void, print_colored, Color, CStringRef)
-FMT_VARIADIC(std::string, sprintf, CStringRef)
-FMT_VARIADIC_W(std::wstring, sprintf, WCStringRef)
-FMT_VARIADIC(int, printf, CStringRef)
-FMT_VARIADIC(int, fprintf, std::FILE *, CStringRef)
-
-namespace internal
-{
-template <typename Char>
-inline bool is_name_start(Char c)
-{
-    return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c;
-}
-
-// Parses an unsigned integer advancing s to the end of the parsed input.
-// This function assumes that the first character of s is a digit.
-template <typename Char>
-unsigned parse_nonnegative_int(const Char *&s)
-{
-    assert('0' <= *s && *s <= '9');
-    unsigned value = 0;
-    do
-    {
-        unsigned new_value = value * 10 + (*s++ - '0');
-        // Check if value wrapped around.
-        if (new_value < value)
-        {
-            value = (std::numeric_limits<unsigned>::max)();
-            break;
-        }
-        value = new_value;
-    }
-    while ('0' <= *s && *s <= '9');
-    // Convert to unsigned to prevent a warning.
-    unsigned max_int = (std::numeric_limits<int>::max)();
-    if (value > max_int)
-        FMT_THROW(FormatError("number is too big"));
-    return value;
-}
-
-inline void require_numeric_argument(const Arg &arg, char spec)
-{
-    if (arg.type > Arg::LAST_NUMERIC_TYPE)
-    {
-        std::string message =
-            fmt::format("format specifier '{}' requires numeric argument", spec);
-        FMT_THROW(fmt::FormatError(message));
-    }
-}
-
-template <typename Char>
-void check_sign(const Char *&s, const Arg &arg)
-{
-    char sign = static_cast<char>(*s);
-    require_numeric_argument(arg, sign);
-    if (arg.type == Arg::UINT || arg.type == Arg::ULONG_LONG)
-    {
-        FMT_THROW(FormatError(fmt::format(
-                                  "format specifier '{}' requires signed argument", sign)));
-    }
-    ++s;
-}
-}  // namespace internal
-
-template <typename Char, typename AF>
-inline internal::Arg BasicFormatter<Char, AF>::get_arg(
-    BasicStringRef<Char> arg_name, const char *&error)
-{
-    if (check_no_auto_index(error))
-    {
-        map_.init(args());
-        const internal::Arg *arg = map_.find(arg_name);
-        if (arg)
-            return *arg;
-        error = "argument not found";
-    }
-    return internal::Arg();
-}
-
-template <typename Char, typename AF>
-inline internal::Arg BasicFormatter<Char, AF>::parse_arg_index(const Char *&s)
-{
-    const char *error = 0;
-    internal::Arg arg = *s < '0' || *s > '9' ?
-                        next_arg(error) : get_arg(internal::parse_nonnegative_int(s), error);
-    if (error)
-    {
-        FMT_THROW(FormatError(
-                      *s != '}' && *s != ':' ? "invalid format string" : error));
-    }
-    return arg;
-}
-
-template <typename Char, typename AF>
-inline internal::Arg BasicFormatter<Char, AF>::parse_arg_name(const Char *&s)
-{
-    assert(internal::is_name_start(*s));
-    const Char *start = s;
-    Char c;
-    do
-    {
-        c = *++s;
-    }
-    while (internal::is_name_start(c) || ('0' <= c && c <= '9'));
-    const char *error = 0;
-    internal::Arg arg = get_arg(BasicStringRef<Char>(start, s - start), error);
-    if (error)
-        FMT_THROW(FormatError(error));
-    return arg;
-}
-
-template <typename Char, typename ArgFormatter>
-const Char *BasicFormatter<Char, ArgFormatter>::format(
-    const Char *&format_str, const internal::Arg &arg)
-{
-    using internal::Arg;
-    const Char *s = format_str;
-    FormatSpec spec;
-    if (*s == ':')
-    {
-        if (arg.type == Arg::CUSTOM)
-        {
-            arg.custom.format(this, arg.custom.value, &s);
-            return s;
-        }
-        ++s;
-        // Parse fill and alignment.
-        if (Char c = *s)
-        {
-            const Char *p = s + 1;
-            spec.align_ = ALIGN_DEFAULT;
-            do
-            {
-                switch (*p)
-                {
-                case '<':
-                    spec.align_ = ALIGN_LEFT;
-                    break;
-                case '>':
-                    spec.align_ = ALIGN_RIGHT;
-                    break;
-                case '=':
-                    spec.align_ = ALIGN_NUMERIC;
-                    break;
-                case '^':
-                    spec.align_ = ALIGN_CENTER;
-                    break;
-                }
-                if (spec.align_ != ALIGN_DEFAULT)
-                {
-                    if (p != s)
-                    {
-                        if (c == '}') break;
-                        if (c == '{')
-                            FMT_THROW(FormatError("invalid fill character '{'"));
-                        s += 2;
-                        spec.fill_ = c;
-                    }
-                    else ++s;
-                    if (spec.align_ == ALIGN_NUMERIC)
-                        require_numeric_argument(arg, '=');
-                    break;
-                }
-            }
-            while (--p >= s);
-        }
-
-        // Parse sign.
-        switch (*s)
-        {
-        case '+':
-            check_sign(s, arg);
-            spec.flags_ |= SIGN_FLAG | PLUS_FLAG;
-            break;
-        case '-':
-            check_sign(s, arg);
-            spec.flags_ |= MINUS_FLAG;
-            break;
-        case ' ':
-            check_sign(s, arg);
-            spec.flags_ |= SIGN_FLAG;
-            break;
-        }
-
-        if (*s == '#')
-        {
-            require_numeric_argument(arg, '#');
-            spec.flags_ |= HASH_FLAG;
-            ++s;
-        }
-
-        // Parse zero flag.
-        if (*s == '0')
-        {
-            require_numeric_argument(arg, '0');
-            spec.align_ = ALIGN_NUMERIC;
-            spec.fill_ = '0';
-            ++s;
-        }
-
-        // Parse width.
-        if ('0' <= *s && *s <= '9')
-        {
-            spec.width_ = internal::parse_nonnegative_int(s);
-        }
-        else if (*s == '{')
-        {
-            ++s;
-            Arg width_arg = internal::is_name_start(*s) ?
-                            parse_arg_name(s) : parse_arg_index(s);
-            if (*s++ != '}')
-                FMT_THROW(FormatError("invalid format string"));
-            ULongLong value = 0;
-            switch (width_arg.type)
-            {
-            case Arg::INT:
-                if (width_arg.int_value < 0)
-                    FMT_THROW(FormatError("negative width"));
-                value = width_arg.int_value;
-                break;
-            case Arg::UINT:
-                value = width_arg.uint_value;
-                break;
-            case Arg::LONG_LONG:
-                if (width_arg.long_long_value < 0)
-                    FMT_THROW(FormatError("negative width"));
-                value = width_arg.long_long_value;
-                break;
-            case Arg::ULONG_LONG:
-                value = width_arg.ulong_long_value;
-                break;
-            default:
-                FMT_THROW(FormatError("width is not integer"));
-            }
-            if (value > (std::numeric_limits<int>::max)())
-                FMT_THROW(FormatError("number is too big"));
-            spec.width_ = static_cast<int>(value);
-        }
-
-        // Parse precision.
-        if (*s == '.')
-        {
-            ++s;
-            spec.precision_ = 0;
-            if ('0' <= *s && *s <= '9')
-            {
-                spec.precision_ = internal::parse_nonnegative_int(s);
-            }
-            else if (*s == '{')
-            {
-                ++s;
-                Arg precision_arg = internal::is_name_start(*s) ?
-                                    parse_arg_name(s) : parse_arg_index(s);
-                if (*s++ != '}')
-                    FMT_THROW(FormatError("invalid format string"));
-                ULongLong value = 0;
-                switch (precision_arg.type)
-                {
-                case Arg::INT:
-                    if (precision_arg.int_value < 0)
-                        FMT_THROW(FormatError("negative precision"));
-                    value = precision_arg.int_value;
-                    break;
-                case Arg::UINT:
-                    value = precision_arg.uint_value;
-                    break;
-                case Arg::LONG_LONG:
-                    if (precision_arg.long_long_value < 0)
-                        FMT_THROW(FormatError("negative precision"));
-                    value = precision_arg.long_long_value;
-                    break;
-                case Arg::ULONG_LONG:
-                    value = precision_arg.ulong_long_value;
-                    break;
-                default:
-                    FMT_THROW(FormatError("precision is not integer"));
-                }
-                if (value > (std::numeric_limits<int>::max)())
-                    FMT_THROW(FormatError("number is too big"));
-                spec.precision_ = static_cast<int>(value);
-            }
-            else
-            {
-                FMT_THROW(FormatError("missing precision specifier"));
-            }
-            if (arg.type <= Arg::LAST_INTEGER_TYPE || arg.type == Arg::POINTER)
-            {
-                FMT_THROW(FormatError(
-                              fmt::format("precision not allowed in {} format specifier",
-                                          arg.type == Arg::POINTER ? "pointer" : "integer")));
-            }
-        }
-
-        // Parse type.
-        if (*s != '}' && *s)
-            spec.type_ = static_cast<char>(*s++);
-    }
-
-    if (*s++ != '}')
-        FMT_THROW(FormatError("missing '}' in format string"));
-
-    // Format argument.
-    ArgFormatter(*this, spec, s - 1).visit(arg);
-    return s;
-}
-
-template <typename Char, typename AF>
-void BasicFormatter<Char, AF>::format(BasicCStringRef<Char> format_str)
-{
-    const Char *s = format_str.c_str();
-    const Char *start = s;
-    while (*s)
-    {
-        Char c = *s++;
-        if (c != '{' && c != '}') continue;
-        if (*s == c)
-        {
-            write(writer_, start, s);
-            start = ++s;
-            continue;
-        }
-        if (c == '}')
-            FMT_THROW(FormatError("unmatched '}' in format string"));
-        write(writer_, start, s - 1);
-        internal::Arg arg = internal::is_name_start(*s) ?
-                            parse_arg_name(s) : parse_arg_index(s);
-        start = s = format(s, arg);
-    }
-    write(writer_, start, s);
-}
-}  // namespace fmt
-
-#if FMT_USE_USER_DEFINED_LITERALS
-namespace fmt
-{
-namespace internal
-{
-
-template <typename Char>
-struct UdlFormat
-{
-    const Char *str;
-
-    template <typename... Args>
-    auto operator()(Args && ... args) const
-    -> decltype(format(str, std::forward<Args>(args)...))
-    {
-        return format(str, std::forward<Args>(args)...);
-    }
-};
-
-template <typename Char>
-struct UdlArg
-{
-    const Char *str;
-
-    template <typename T>
-    NamedArg<Char> operator=(T &&value) const
-    {
-        return {str, std::forward<T>(value)};
-    }
-};
-
-} // namespace internal
-
-inline namespace literals
-{
-
-/**
-  \rst
-  C++11 literal equivalent of :func:`fmt::format`.
-
-  **Example**::
-
-    using namespace fmt::literals;
-    std::string message = "The answer is {}"_format(42);
-  \endrst
- */
-inline internal::UdlFormat<char>
-operator"" _format(const char *s, std::size_t)
-{
-    return {s};
-}
-inline internal::UdlFormat<wchar_t>
-operator"" _format(const wchar_t *s, std::size_t)
-{
-    return {s};
-}
-
-/**
-  \rst
-  C++11 literal equivalent of :func:`fmt::arg`.
-
-  **Example**::
-
-    using namespace fmt::literals;
-    print("Elapsed time: {s:.2f} seconds", "s"_a=1.23);
-  \endrst
- */
-inline internal::UdlArg<char>
-operator"" _a(const char *s, std::size_t)
-{
-    return {s};
-}
-inline internal::UdlArg<wchar_t>
-operator"" _a(const wchar_t *s, std::size_t)
-{
-    return {s};
-}
-
-} // inline namespace literals
-} // namespace fmt
-#endif // FMT_USE_USER_DEFINED_LITERALS
-
-// Restore warnings.
-#if FMT_GCC_VERSION >= 406
-# pragma GCC diagnostic pop
-#endif
-
-#if defined(__clang__) && !defined(FMT_ICC_VERSION)
-# pragma clang diagnostic pop
-#endif
-
-#ifdef FMT_HEADER_ONLY
-# define FMT_FUNC inline
-# include "format.cc"
-#else
-# define FMT_FUNC
-#endif
-
-#endif  // FMT_FORMAT_H_
diff --git a/wasserstein/include/spdlog/fmt/bundled/ostream.cc b/wasserstein/include/spdlog/fmt/bundled/ostream.cc
deleted file mode 100644
index bcb67fe..0000000
--- a/wasserstein/include/spdlog/fmt/bundled/ostream.cc
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- Formatting library for C++ - std::ostream support
-
- Copyright (c) 2012 - 2016, Victor Zverovich
- All rights reserved.
-
- For the license information refer to format.h.
- */
-
-#include "ostream.h"
-
-namespace fmt {
-
-namespace {
-// Write the content of w to os.
-void write(std::ostream &os, Writer &w) {
-  const char *data = w.data();
-  typedef internal::MakeUnsigned<std::streamsize>::Type UnsignedStreamSize;
-  UnsignedStreamSize size = w.size();
-  UnsignedStreamSize max_size =
-      internal::to_unsigned((std::numeric_limits<std::streamsize>::max)());
-  do {
-    UnsignedStreamSize n = size <= max_size ? size : max_size;
-    os.write(data, static_cast<std::streamsize>(n));
-    data += n;
-    size -= n;
-  } while (size != 0);
-}
-}
-
-FMT_FUNC void print(std::ostream &os, CStringRef format_str, ArgList args) {
-  MemoryWriter w;
-  w.write(format_str, args);
-  write(os, w);
-}
-
-FMT_FUNC int fprintf(std::ostream &os, CStringRef format, ArgList args) {
-  MemoryWriter w;
-  printf(w, format, args);
-  write(os, w);
-  return static_cast<int>(w.size());
-}
-}  // namespace fmt
diff --git a/wasserstein/include/spdlog/fmt/bundled/ostream.h b/wasserstein/include/spdlog/fmt/bundled/ostream.h
deleted file mode 100644
index c52646d..0000000
--- a/wasserstein/include/spdlog/fmt/bundled/ostream.h
+++ /dev/null
@@ -1,126 +0,0 @@
-/*
- Formatting library for C++ - std::ostream support
-
- Copyright (c) 2012 - 2016, Victor Zverovich
- All rights reserved.
-
- For the license information refer to format.h.
- */
-
-#ifndef FMT_OSTREAM_H_
-#define FMT_OSTREAM_H_
-
-#include "format.h"
-#include <ostream>
-
-namespace fmt
-{
-
-namespace internal
-{
-
-template <class Char>
-class FormatBuf : public std::basic_streambuf<Char>
-{
-private:
-    typedef typename std::basic_streambuf<Char>::int_type int_type;
-    typedef typename std::basic_streambuf<Char>::traits_type traits_type;
-
-    Buffer<Char> &buffer_;
-    Char *start_;
-
-public:
-    FormatBuf(Buffer<Char> &buffer) : buffer_(buffer), start_(&buffer[0])
-    {
-        this->setp(start_, start_ + buffer_.capacity());
-    }
-
-    int_type overflow(int_type ch = traits_type::eof())
-    {
-        if (!traits_type::eq_int_type(ch, traits_type::eof()))
-        {
-            size_t buf_size = size();
-            buffer_.resize(buf_size);
-            buffer_.reserve(buf_size * 2);
-
-            start_ = &buffer_[0];
-            start_[buf_size] = traits_type::to_char_type(ch);
-            this->setp(start_+ buf_size + 1, start_ + buf_size * 2);
-        }
-        return ch;
-    }
-
-    size_t size() const
-    {
-        return to_unsigned(this->pptr() - start_);
-    }
-};
-
-Yes &convert(std::ostream &);
-
-struct DummyStream : std::ostream
-{
-    DummyStream();  // Suppress a bogus warning in MSVC.
-    // Hide all operator<< overloads from std::ostream.
-    void operator<<(Null<>);
-};
-
-No &operator<<(std::ostream &, int);
-
-template<typename T>
-struct ConvertToIntImpl<T, true>
-{
-    // Convert to int only if T doesn't have an overloaded operator<<.
-    enum
-    {
-        value = sizeof(convert(get<DummyStream>() << get<T>())) == sizeof(No)
-    };
-};
-}  // namespace internal
-
-// Formats a value.
-template <typename Char, typename ArgFormatter, typename T>
-void format(BasicFormatter<Char, ArgFormatter> &f,
-            const Char *&format_str, const T &value)
-{
-    internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE> buffer;
-
-    internal::FormatBuf<Char> format_buf(buffer);
-    std::basic_ostream<Char> output(&format_buf);
-    output << value;
-
-    BasicStringRef<Char> str(&buffer[0], format_buf.size());
-    typedef internal::MakeArg< BasicFormatter<Char> > MakeArg;
-    format_str = f.format(format_str, MakeArg(str));
-}
-
-/**
-  \rst
-  Prints formatted data to the stream *os*.
-
-  **Example**::
-
-    print(cerr, "Don't {}!", "panic");
-  \endrst
- */
-FMT_API void print(std::ostream &os, CStringRef format_str, ArgList args);
-FMT_VARIADIC(void, print, std::ostream &, CStringRef)
-
-/**
-  \rst
-  Prints formatted data to the stream *os*.
-
-  **Example**::
-
-    fprintf(cerr, "Don't %s!", "panic");
-  \endrst
- */
-FMT_API int fprintf(std::ostream &os, CStringRef format_str, ArgList args);
-FMT_VARIADIC(int, fprintf, std::ostream &, CStringRef)
-}  // namespace fmt
-
-#ifdef FMT_HEADER_ONLY
-# include "ostream.cc"
-#endif
-
-#endif  // FMT_OSTREAM_H_
diff --git a/wasserstein/include/spdlog/fmt/bundled/posix.cc b/wasserstein/include/spdlog/fmt/bundled/posix.cc
deleted file mode 100644
index 76eb7f0..0000000
--- a/wasserstein/include/spdlog/fmt/bundled/posix.cc
+++ /dev/null
@@ -1,238 +0,0 @@
-/*
- A C++ interface to POSIX functions.
-
- Copyright (c) 2012 - 2016, Victor Zverovich
- All rights reserved.
-
- For the license information refer to format.h.
- */
-
-// Disable bogus MSVC warnings.
-#ifndef _CRT_SECURE_NO_WARNINGS
-# define _CRT_SECURE_NO_WARNINGS
-#endif
-
-#include "posix.h"
-
-#include <limits.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-
-#ifndef _WIN32
-# include <unistd.h>
-#else
-# include <windows.h>
-# include <io.h>
-
-# define O_CREAT _O_CREAT
-# define O_TRUNC _O_TRUNC
-
-# ifndef S_IRUSR
-#  define S_IRUSR _S_IREAD
-# endif
-
-# ifndef S_IWUSR
-#  define S_IWUSR _S_IWRITE
-# endif
-
-# ifdef __MINGW32__
-#  define _SH_DENYNO 0x40
-# endif
-
-#endif  // _WIN32
-
-#ifdef fileno
-# undef fileno
-#endif
-
-namespace {
-#ifdef _WIN32
-// Return type of read and write functions.
-typedef int RWResult;
-
-// On Windows the count argument to read and write is unsigned, so convert
-// it from size_t preventing integer overflow.
-inline unsigned convert_rwcount(std::size_t count) {
-  return count <= UINT_MAX ? static_cast<unsigned>(count) : UINT_MAX;
-}
-#else
-// Return type of read and write functions.
-typedef ssize_t RWResult;
-
-inline std::size_t convert_rwcount(std::size_t count) { return count; }
-#endif
-}
-
-fmt::BufferedFile::~BufferedFile() FMT_NOEXCEPT {
-  if (file_ && FMT_SYSTEM(fclose(file_)) != 0)
-    fmt::report_system_error(errno, "cannot close file");
-}
-
-fmt::BufferedFile::BufferedFile(
-    fmt::CStringRef filename, fmt::CStringRef mode) {
-  FMT_RETRY_VAL(file_, FMT_SYSTEM(fopen(filename.c_str(), mode.c_str())), 0);
-  if (!file_)
-    FMT_THROW(SystemError(errno, "cannot open file {}", filename));
-}
-
-void fmt::BufferedFile::close() {
-  if (!file_)
-    return;
-  int result = FMT_SYSTEM(fclose(file_));
-  file_ = 0;
-  if (result != 0)
-    FMT_THROW(SystemError(errno, "cannot close file"));
-}
-
-// A macro used to prevent expansion of fileno on broken versions of MinGW.
-#define FMT_ARGS
-
-int fmt::BufferedFile::fileno() const {
-  int fd = FMT_POSIX_CALL(fileno FMT_ARGS(file_));
-  if (fd == -1)
-    FMT_THROW(SystemError(errno, "cannot get file descriptor"));
-  return fd;
-}
-
-fmt::File::File(fmt::CStringRef path, int oflag) {
-  int mode = S_IRUSR | S_IWUSR;
-#if defined(_WIN32) && !defined(__MINGW32__)
-  fd_ = -1;
-  FMT_POSIX_CALL(sopen_s(&fd_, path.c_str(), oflag, _SH_DENYNO, mode));
-#else
-  FMT_RETRY(fd_, FMT_POSIX_CALL(open(path.c_str(), oflag, mode)));
-#endif
-  if (fd_ == -1)
-    FMT_THROW(SystemError(errno, "cannot open file {}", path));
-}
-
-fmt::File::~File() FMT_NOEXCEPT {
-  // Don't retry close in case of EINTR!
-  // See http://linux.derkeiler.com/Mailing-Lists/Kernel/2005-09/3000.html
-  if (fd_ != -1 && FMT_POSIX_CALL(close(fd_)) != 0)
-    fmt::report_system_error(errno, "cannot close file");
-}
-
-void fmt::File::close() {
-  if (fd_ == -1)
-    return;
-  // Don't retry close in case of EINTR!
-  // See http://linux.derkeiler.com/Mailing-Lists/Kernel/2005-09/3000.html
-  int result = FMT_POSIX_CALL(close(fd_));
-  fd_ = -1;
-  if (result != 0)
-    FMT_THROW(SystemError(errno, "cannot close file"));
-}
-
-fmt::LongLong fmt::File::size() const {
-#ifdef _WIN32
-  // Use GetFileSize instead of GetFileSizeEx for the case when _WIN32_WINNT
-  // is less than 0x0500 as is the case with some default MinGW builds.
-  // Both functions support large file sizes.
-  DWORD size_upper = 0;
-  HANDLE handle = reinterpret_cast<HANDLE>(_get_osfhandle(fd_));
-  DWORD size_lower = FMT_SYSTEM(GetFileSize(handle, &size_upper));
-  if (size_lower == INVALID_FILE_SIZE) {
-    DWORD error = GetLastError();
-    if (error != NO_ERROR)
-      FMT_THROW(WindowsError(GetLastError(), "cannot get file size"));
-  }
-  fmt::ULongLong long_size = size_upper;
-  return (long_size << sizeof(DWORD) * CHAR_BIT) | size_lower;
-#else
-  typedef struct stat Stat;
-  Stat file_stat = Stat();
-  if (FMT_POSIX_CALL(fstat(fd_, &file_stat)) == -1)
-    FMT_THROW(SystemError(errno, "cannot get file attributes"));
-  FMT_STATIC_ASSERT(sizeof(fmt::LongLong) >= sizeof(file_stat.st_size),
-      "return type of File::size is not large enough");
-  return file_stat.st_size;
-#endif
-}
-
-std::size_t fmt::File::read(void *buffer, std::size_t count) {
-  RWResult result = 0;
-  FMT_RETRY(result, FMT_POSIX_CALL(read(fd_, buffer, convert_rwcount(count))));
-  if (result < 0)
-    FMT_THROW(SystemError(errno, "cannot read from file"));
-  return internal::to_unsigned(result);
-}
-
-std::size_t fmt::File::write(const void *buffer, std::size_t count) {
-  RWResult result = 0;
-  FMT_RETRY(result, FMT_POSIX_CALL(write(fd_, buffer, convert_rwcount(count))));
-  if (result < 0)
-    FMT_THROW(SystemError(errno, "cannot write to file"));
-  return internal::to_unsigned(result);
-}
-
-fmt::File fmt::File::dup(int fd) {
-  // Don't retry as dup doesn't return EINTR.
-  // http://pubs.opengroup.org/onlinepubs/009695399/functions/dup.html
-  int new_fd = FMT_POSIX_CALL(dup(fd));
-  if (new_fd == -1)
-    FMT_THROW(SystemError(errno, "cannot duplicate file descriptor {}", fd));
-  return File(new_fd);
-}
-
-void fmt::File::dup2(int fd) {
-  int result = 0;
-  FMT_RETRY(result, FMT_POSIX_CALL(dup2(fd_, fd)));
-  if (result == -1) {
-    FMT_THROW(SystemError(errno,
-      "cannot duplicate file descriptor {} to {}", fd_, fd));
-  }
-}
-
-void fmt::File::dup2(int fd, ErrorCode &ec) FMT_NOEXCEPT {
-  int result = 0;
-  FMT_RETRY(result, FMT_POSIX_CALL(dup2(fd_, fd)));
-  if (result == -1)
-    ec = ErrorCode(errno);
-}
-
-void fmt::File::pipe(File &read_end, File &write_end) {
-  // Close the descriptors first to make sure that assignments don't throw
-  // and there are no leaks.
-  read_end.close();
-  write_end.close();
-  int fds[2] = {};
-#ifdef _WIN32
-  // Make the default pipe capacity same as on Linux 2.6.11+.
-  enum { DEFAULT_CAPACITY = 65536 };
-  int result = FMT_POSIX_CALL(pipe(fds, DEFAULT_CAPACITY, _O_BINARY));
-#else
-  // Don't retry as the pipe function doesn't return EINTR.
-  // http://pubs.opengroup.org/onlinepubs/009696799/functions/pipe.html
-  int result = FMT_POSIX_CALL(pipe(fds));
-#endif
-  if (result != 0)
-    FMT_THROW(SystemError(errno, "cannot create pipe"));
-  // The following assignments don't throw because read_fd and write_fd
-  // are closed.
-  read_end = File(fds[0]);
-  write_end = File(fds[1]);
-}
-
-fmt::BufferedFile fmt::File::fdopen(const char *mode) {
-  // Don't retry as fdopen doesn't return EINTR.
-  FILE *f = FMT_POSIX_CALL(fdopen(fd_, mode));
-  if (!f)
-    FMT_THROW(SystemError(errno, "cannot associate stream with file descriptor"));
-  BufferedFile file(f);
-  fd_ = -1;
-  return file;
-}
-
-long fmt::getpagesize() {
-#ifdef _WIN32
-  SYSTEM_INFO si;
-  GetSystemInfo(&si);
-  return si.dwPageSize;
-#else
-  long size = FMT_POSIX_CALL(sysconf(_SC_PAGESIZE));
-  if (size < 0)
-    FMT_THROW(SystemError(errno, "cannot get memory page size"));
-  return size;
-#endif
-}
diff --git a/wasserstein/include/spdlog/fmt/bundled/posix.h b/wasserstein/include/spdlog/fmt/bundled/posix.h
deleted file mode 100644
index 859fcaa..0000000
--- a/wasserstein/include/spdlog/fmt/bundled/posix.h
+++ /dev/null
@@ -1,443 +0,0 @@
-/*
- A C++ interface to POSIX functions.
-
- Copyright (c) 2012 - 2016, Victor Zverovich
- All rights reserved.
-
- For the license information refer to format.h.
- */
-
-#ifndef FMT_POSIX_H_
-#define FMT_POSIX_H_
-
-#if defined(__MINGW32__) || defined(__CYGWIN__)
-// Workaround MinGW bug https://sourceforge.net/p/mingw/bugs/2024/.
-# undef __STRICT_ANSI__
-#endif
-
-#include <errno.h>
-#include <fcntl.h>   // for O_RDONLY
-#include <locale.h>  // for locale_t
-#include <stdio.h>
-#include <stdlib.h>  // for strtod_l
-
-#include <cstddef>
-
-#if defined __APPLE__ || defined(__FreeBSD__)
-# include <xlocale.h>  // for LC_NUMERIC_MASK on OS X
-#endif
-
-#include "format.h"
-
-#ifndef FMT_POSIX
-# if defined(_WIN32) && !defined(__MINGW32__)
-// Fix warnings about deprecated symbols.
-#  define FMT_POSIX(call) _##call
-# else
-#  define FMT_POSIX(call) call
-# endif
-#endif
-
-// Calls to system functions are wrapped in FMT_SYSTEM for testability.
-#ifdef FMT_SYSTEM
-# define FMT_POSIX_CALL(call) FMT_SYSTEM(call)
-#else
-# define FMT_SYSTEM(call) call
-# ifdef _WIN32
-// Fix warnings about deprecated symbols.
-#  define FMT_POSIX_CALL(call) ::_##call
-# else
-#  define FMT_POSIX_CALL(call) ::call
-# endif
-#endif
-
-#if FMT_GCC_VERSION >= 407
-# define FMT_UNUSED __attribute__((unused))
-#else
-# define FMT_UNUSED
-#endif
-
-#ifndef FMT_USE_STATIC_ASSERT
-# define FMT_USE_STATIC_ASSERT 0
-#endif
-
-#if FMT_USE_STATIC_ASSERT || FMT_HAS_FEATURE(cxx_static_assert) || \
-  (FMT_GCC_VERSION >= 403 && FMT_HAS_GXX_CXX11) || _MSC_VER >= 1600
-# define FMT_STATIC_ASSERT(cond, message) static_assert(cond, message)
-#else
-# define FMT_CONCAT_(a, b) FMT_CONCAT(a, b)
-# define FMT_STATIC_ASSERT(cond, message) \
-  typedef int FMT_CONCAT_(Assert, __LINE__)[(cond) ? 1 : -1] FMT_UNUSED
-#endif
-
-// Retries the expression while it evaluates to error_result and errno
-// equals to EINTR.
-#ifndef _WIN32
-# define FMT_RETRY_VAL(result, expression, error_result) \
-  do { \
-    result = (expression); \
-  } while (result == error_result && errno == EINTR)
-#else
-# define FMT_RETRY_VAL(result, expression, error_result) result = (expression)
-#endif
-
-#define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1)
-
-namespace fmt
-{
-
-// An error code.
-class ErrorCode
-{
-private:
-    int value_;
-
-public:
-explicit ErrorCode(int value = 0) FMT_NOEXCEPT :
-    value_(value) {}
-
-    int get() const FMT_NOEXCEPT
-    {
-        return value_;
-    }
-};
-
-// A buffered file.
-class BufferedFile
-{
-private:
-    FILE *file_;
-
-    friend class File;
-
-    explicit BufferedFile(FILE *f) : file_(f) {}
-
-public:
-    // Constructs a BufferedFile object which doesn't represent any file.
-BufferedFile() FMT_NOEXCEPT :
-    file_(0) {}
-
-    // Destroys the object closing the file it represents if any.
-    ~BufferedFile() FMT_NOEXCEPT;
-
-#if !FMT_USE_RVALUE_REFERENCES
-    // Emulate a move constructor and a move assignment operator if rvalue
-    // references are not supported.
-
-private:
-    // A proxy object to emulate a move constructor.
-    // It is private to make it impossible call operator Proxy directly.
-    struct Proxy
-    {
-        FILE *file;
-    };
-
-public:
-    // A "move constructor" for moving from a temporary.
-BufferedFile(Proxy p) FMT_NOEXCEPT :
-    file_(p.file) {}
-
-    // A "move constructor" for moving from an lvalue.
-BufferedFile(BufferedFile &f) FMT_NOEXCEPT :
-    file_(f.file_)
-    {
-        f.file_ = 0;
-    }
-
-    // A "move assignment operator" for moving from a temporary.
-    BufferedFile &operator=(Proxy p)
-    {
-        close();
-        file_ = p.file;
-        return *this;
-    }
-
-    // A "move assignment operator" for moving from an lvalue.
-    BufferedFile &operator=(BufferedFile &other)
-    {
-        close();
-        file_ = other.file_;
-        other.file_ = 0;
-        return *this;
-    }
-
-    // Returns a proxy object for moving from a temporary:
-    //   BufferedFile file = BufferedFile(...);
-    operator Proxy() FMT_NOEXCEPT
-    {
-        Proxy p = {file_};
-        file_ = 0;
-        return p;
-    }
-
-#else
-private:
-    FMT_DISALLOW_COPY_AND_ASSIGN(BufferedFile);
-
-public:
-BufferedFile(BufferedFile &&other) FMT_NOEXCEPT :
-    file_(other.file_)
-    {
-        other.file_ = 0;
-    }
-
-    BufferedFile& operator=(BufferedFile &&other)
-    {
-        close();
-        file_ = other.file_;
-        other.file_ = 0;
-        return *this;
-    }
-#endif
-
-    // Opens a file.
-    BufferedFile(CStringRef filename, CStringRef mode);
-
-    // Closes the file.
-    void close();
-
-    // Returns the pointer to a FILE object representing this file.
-    FILE *get() const FMT_NOEXCEPT
-    {
-        return file_;
-    }
-
-    // We place parentheses around fileno to workaround a bug in some versions
-    // of MinGW that define fileno as a macro.
-    int (fileno)() const;
-
-    void print(CStringRef format_str, const ArgList &args)
-    {
-        fmt::print(file_, format_str, args);
-    }
-    FMT_VARIADIC(void, print, CStringRef)
-};
-
-// A file. Closed file is represented by a File object with descriptor -1.
-// Methods that are not declared with FMT_NOEXCEPT may throw
-// fmt::SystemError in case of failure. Note that some errors such as
-// closing the file multiple times will cause a crash on Windows rather
-// than an exception. You can get standard behavior by overriding the
-// invalid parameter handler with _set_invalid_parameter_handler.
-class File
-{
-private:
-    int fd_;  // File descriptor.
-
-    // Constructs a File object with a given descriptor.
-    explicit File(int fd) : fd_(fd) {}
-
-public:
-    // Possible values for the oflag argument to the constructor.
-    enum
-    {
-        RDONLY = FMT_POSIX(O_RDONLY), // Open for reading only.
-        WRONLY = FMT_POSIX(O_WRONLY), // Open for writing only.
-        RDWR   = FMT_POSIX(O_RDWR)    // Open for reading and writing.
-    };
-
-    // Constructs a File object which doesn't represent any file.
-File() FMT_NOEXCEPT :
-    fd_(-1) {}
-
-    // Opens a file and constructs a File object representing this file.
-    File(CStringRef path, int oflag);
-
-#if !FMT_USE_RVALUE_REFERENCES
-    // Emulate a move constructor and a move assignment operator if rvalue
-    // references are not supported.
-
-private:
-    // A proxy object to emulate a move constructor.
-    // It is private to make it impossible call operator Proxy directly.
-    struct Proxy
-    {
-        int fd;
-    };
-
-public:
-    // A "move constructor" for moving from a temporary.
-File(Proxy p) FMT_NOEXCEPT :
-    fd_(p.fd) {}
-
-    // A "move constructor" for moving from an lvalue.
-File(File &other) FMT_NOEXCEPT :
-    fd_(other.fd_)
-    {
-        other.fd_ = -1;
-    }
-
-    // A "move assignment operator" for moving from a temporary.
-    File &operator=(Proxy p)
-    {
-        close();
-        fd_ = p.fd;
-        return *this;
-    }
-
-    // A "move assignment operator" for moving from an lvalue.
-    File &operator=(File &other)
-    {
-        close();
-        fd_ = other.fd_;
-        other.fd_ = -1;
-        return *this;
-    }
-
-    // Returns a proxy object for moving from a temporary:
-    //   File file = File(...);
-    operator Proxy() FMT_NOEXCEPT
-    {
-        Proxy p = {fd_};
-        fd_ = -1;
-        return p;
-    }
-
-#else
-private:
-    FMT_DISALLOW_COPY_AND_ASSIGN(File);
-
-public:
-File(File &&other) FMT_NOEXCEPT :
-    fd_(other.fd_)
-    {
-        other.fd_ = -1;
-    }
-
-    File& operator=(File &&other)
-    {
-        close();
-        fd_ = other.fd_;
-        other.fd_ = -1;
-        return *this;
-    }
-#endif
-
-    // Destroys the object closing the file it represents if any.
-    ~File() FMT_NOEXCEPT;
-
-    // Returns the file descriptor.
-    int descriptor() const FMT_NOEXCEPT
-    {
-        return fd_;
-    }
-
-    // Closes the file.
-    void close();
-
-    // Returns the file size. The size has signed type for consistency with
-    // stat::st_size.
-    LongLong size() const;
-
-    // Attempts to read count bytes from the file into the specified buffer.
-    std::size_t read(void *buffer, std::size_t count);
-
-    // Attempts to write count bytes from the specified buffer to the file.
-    std::size_t write(const void *buffer, std::size_t count);
-
-    // Duplicates a file descriptor with the dup function and returns
-    // the duplicate as a file object.
-    static File dup(int fd);
-
-    // Makes fd be the copy of this file descriptor, closing fd first if
-    // necessary.
-    void dup2(int fd);
-
-    // Makes fd be the copy of this file descriptor, closing fd first if
-    // necessary.
-    void dup2(int fd, ErrorCode &ec) FMT_NOEXCEPT;
-
-    // Creates a pipe setting up read_end and write_end file objects for reading
-    // and writing respectively.
-    static void pipe(File &read_end, File &write_end);
-
-    // Creates a BufferedFile object associated with this file and detaches
-    // this File object from the file.
-    BufferedFile fdopen(const char *mode);
-};
-
-// Returns the memory page size.
-long getpagesize();
-
-#if (defined(LC_NUMERIC_MASK) || defined(_MSC_VER)) && \
-    !defined(__ANDROID__) && !defined(__CYGWIN__)
-# define FMT_LOCALE
-#endif
-
-#ifdef FMT_LOCALE
-// A "C" numeric locale.
-class Locale
-{
-private:
-# ifdef _MSC_VER
-    typedef _locale_t locale_t;
-
-    enum { LC_NUMERIC_MASK = LC_NUMERIC };
-
-    static locale_t newlocale(int category_mask, const char *locale, locale_t)
-    {
-        return _create_locale(category_mask, locale);
-    }
-
-    static void freelocale(locale_t locale)
-    {
-        _free_locale(locale);
-    }
-
-    static double strtod_l(const char *nptr, char **endptr, _locale_t locale)
-    {
-        return _strtod_l(nptr, endptr, locale);
-    }
-# endif
-
-    locale_t locale_;
-
-    FMT_DISALLOW_COPY_AND_ASSIGN(Locale);
-
-public:
-    typedef locale_t Type;
-
-    Locale() : locale_(newlocale(LC_NUMERIC_MASK, "C", NULL))
-    {
-        if (!locale_)
-            FMT_THROW(fmt::SystemError(errno, "cannot create locale"));
-    }
-    ~Locale()
-    {
-        freelocale(locale_);
-    }
-
-    Type get() const
-    {
-        return locale_;
-    }
-
-    // Converts string to floating-point number and advances str past the end
-    // of the parsed input.
-    double strtod(const char *&str) const
-    {
-        char *end = 0;
-        double result = strtod_l(str, &end, locale_);
-        str = end;
-        return result;
-    }
-};
-#endif  // FMT_LOCALE
-}  // namespace fmt
-
-#if !FMT_USE_RVALUE_REFERENCES
-namespace std
-{
-// For compatibility with C++98.
-inline fmt::BufferedFile &move(fmt::BufferedFile &f)
-{
-    return f;
-}
-inline fmt::File &move(fmt::File &f)
-{
-    return f;
-}
-}
-#endif
-
-#endif  // FMT_POSIX_H_
diff --git a/wasserstein/include/spdlog/fmt/bundled/time.h b/wasserstein/include/spdlog/fmt/bundled/time.h
deleted file mode 100644
index 10c6cfc..0000000
--- a/wasserstein/include/spdlog/fmt/bundled/time.h
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- Formatting library for C++ - time formatting
-
- Copyright (c) 2012 - 2016, Victor Zverovich
- All rights reserved.
-
- For the license information refer to format.h.
- */
-
-#ifndef FMT_TIME_H_
-#define FMT_TIME_H_
-
-#include "format.h"
-#include <ctime>
-
-namespace fmt
-{
-template <typename ArgFormatter>
-void format(BasicFormatter<char, ArgFormatter> &f,
-            const char *&format_str, const std::tm &tm)
-{
-    if (*format_str == ':')
-        ++format_str;
-    const char *end = format_str;
-    while (*end && *end != '}')
-        ++end;
-    if (*end != '}')
-        FMT_THROW(FormatError("missing '}' in format string"));
-    internal::MemoryBuffer<char, internal::INLINE_BUFFER_SIZE> format;
-    format.append(format_str, end + 1);
-    format[format.size() - 1] = '\0';
-    Buffer<char> &buffer = f.writer().buffer();
-    std::size_t start = buffer.size();
-    for (;;)
-    {
-        std::size_t size = buffer.capacity() - start;
-        std::size_t count = std::strftime(&buffer[start], size, &format[0], &tm);
-        if (count != 0)
-        {
-            buffer.resize(start + count);
-            break;
-        }
-        if (size >= format.size() * 256)
-        {
-            // If the buffer is 256 times larger than the format string, assume
-            // that `strftime` gives an empty result. There doesn't seem to be a
-            // better way to distinguish the two cases:
-            // https://github.com/fmtlib/fmt/issues/367
-            break;
-        }
-        const std::size_t MIN_GROWTH = 10;
-        buffer.reserve(buffer.capacity() + (size > MIN_GROWTH ? size : MIN_GROWTH));
-    }
-    format_str = end + 1;
-}
-}
-
-#endif  // FMT_TIME_H_
diff --git a/wasserstein/include/spdlog/fmt/fmt.h b/wasserstein/include/spdlog/fmt/fmt.h
deleted file mode 100644
index a4ee467..0000000
--- a/wasserstein/include/spdlog/fmt/fmt.h
+++ /dev/null
@@ -1,28 +0,0 @@
-//
-// Copyright(c) 2016 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-//
-// Include a bundled header-only copy of fmtlib or an external one.
-// By default spdlog include its own copy.
-//
-
-#if !defined(SPDLOG_FMT_EXTERNAL)
-
-#ifndef FMT_HEADER_ONLY
-#define FMT_HEADER_ONLY
-#endif
-#ifndef FMT_USE_WINDOWS_H
-#define FMT_USE_WINDOWS_H 0
-#endif
-#include "spdlog/fmt/bundled/format.h"
-
-#else //external fmtlib
-
-#include <fmt/format.h>
-
-#endif
-
diff --git a/wasserstein/include/spdlog/fmt/ostr.h b/wasserstein/include/spdlog/fmt/ostr.h
deleted file mode 100644
index 49b5e98..0000000
--- a/wasserstein/include/spdlog/fmt/ostr.h
+++ /dev/null
@@ -1,17 +0,0 @@
-//
-// Copyright(c) 2016 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-// include external or bundled copy of fmtlib's ostream support
-//
-#if !defined(SPDLOG_FMT_EXTERNAL)
-#include "spdlog/fmt/fmt.h"
-#include "spdlog/fmt/bundled/ostream.h"
-#else
-#include <fmt/ostream.h>
-#endif
-
-
diff --git a/wasserstein/include/spdlog/formatter.h b/wasserstein/include/spdlog/formatter.h
deleted file mode 100644
index 6bba902..0000000
--- a/wasserstein/include/spdlog/formatter.h
+++ /dev/null
@@ -1,47 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include "spdlog/details/log_msg.h"
-
-#include <vector>
-#include <string>
-#include <memory>
-
-namespace spdlog
-{
-namespace details
-{
-class flag_formatter;
-}
-
-class formatter
-{
-public:
-    virtual ~formatter() {}
-    virtual void format(details::log_msg& msg) = 0;
-};
-
-class pattern_formatter SPDLOG_FINAL : public formatter
-{
-
-public:
-    explicit pattern_formatter(const std::string& pattern, pattern_time_type pattern_time = pattern_time_type::local);
-    pattern_formatter(const pattern_formatter&) = delete;
-    pattern_formatter& operator=(const pattern_formatter&) = delete;
-    void format(details::log_msg& msg) override;
-private:
-    const std::string _pattern;
-    const pattern_time_type _pattern_time;
-    std::vector<std::unique_ptr<details::flag_formatter>> _formatters;
-    std::tm get_time(details::log_msg& msg);
-    void handle_flag(char flag);
-    void compile_pattern(const std::string& pattern);
-};
-}
-
-#include "spdlog/details/pattern_formatter_impl.h"
-
diff --git a/wasserstein/include/spdlog/logger.h b/wasserstein/include/spdlog/logger.h
deleted file mode 100644
index 642208e..0000000
--- a/wasserstein/include/spdlog/logger.h
+++ /dev/null
@@ -1,132 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-// Thread safe logger (except for set_pattern(..), set_formatter(..) and set_error_handler())
-// Has name, log level, vector of std::shared sink pointers and formatter
-// Upon each log write the logger:
-// 1. Checks if its log level is enough to log the message
-// 2. Format the message using the formatter function
-// 3. Pass the formatted message to its sinks to performa the actual logging
-
-#include "spdlog/sinks/base_sink.h"
-#include "spdlog/common.h"
-
-#include <vector>
-#include <memory>
-#include <string>
-
-namespace spdlog
-{
-
-class logger
-{
-public:
-    logger(const std::string& logger_name, sink_ptr single_sink);
-    logger(const std::string& name, sinks_init_list);
-    template<class It>
-    logger(const std::string& name, const It& begin, const It& end);
-
-    virtual ~logger();
-    logger(const logger&) = delete;
-    logger& operator=(const logger&) = delete;
-
-
-    template <typename... Args> void log(level::level_enum lvl, const char* fmt, const Args&... args);
-    template <typename... Args> void log(level::level_enum lvl, const char* msg);
-    template <typename Arg1, typename... Args> void trace(const char* fmt, const Arg1&, const Args&... args);
-    template <typename Arg1, typename... Args> void debug(const char* fmt, const Arg1&, const Args&... args);
-    template <typename Arg1, typename... Args> void info(const char* fmt, const Arg1&, const Args&... args);
-    template <typename Arg1, typename... Args> void warn(const char* fmt, const Arg1&, const Args&... args);
-    template <typename Arg1, typename... Args> void error(const char* fmt, const Arg1&, const Args&... args);
-    template <typename Arg1, typename... Args> void critical(const char* fmt, const Arg1&, const Args&... args);
-
-    template <typename... Args> void log_if(const bool flag, level::level_enum lvl, const char* fmt, const Args&... args);
-    template <typename... Args> void log_if(const bool flag, level::level_enum lvl, const char* msg);
-    template <typename Arg1, typename... Args> void trace_if(const bool flag, const char* fmt, const Arg1&, const Args&... args);
-    template <typename Arg1, typename... Args> void debug_if(const bool flag, const char* fmt, const Arg1&, const Args&... args);
-    template <typename Arg1, typename... Args> void info_if(const bool flag, const char* fmt, const Arg1&, const Args&... args);
-    template <typename Arg1, typename... Args> void warn_if(const bool flag, const char* fmt, const Arg1&, const Args&... args);
-    template <typename Arg1, typename... Args> void error_if(const bool flag, const char* fmt, const Arg1&, const Args&... args);
-    template <typename Arg1, typename... Args> void critical_if(const bool flag, const char* fmt, const Arg1&, const Args&... args);
-
-#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
-    template <typename... Args> void log(level::level_enum lvl, const wchar_t* msg);
-    template <typename... Args> void log(level::level_enum lvl, const wchar_t* fmt, const Args&... args);
-    template <typename... Args> void trace(const wchar_t* fmt, const Args&... args);
-    template <typename... Args> void debug(const wchar_t* fmt, const Args&... args);
-    template <typename... Args> void info(const wchar_t* fmt, const Args&... args);
-    template <typename... Args> void warn(const wchar_t* fmt, const Args&... args);
-    template <typename... Args> void error(const wchar_t* fmt, const Args&... args);
-    template <typename... Args> void critical(const wchar_t* fmt, const Args&... args);
-
-    template <typename... Args> void log_if(const bool flag, level::level_enum lvl, const wchar_t* msg);
-    template <typename... Args> void log_if(const bool flag, level::level_enum lvl, const wchar_t* fmt, const Args&... args);
-    template <typename... Args> void trace_if(const bool flag, const wchar_t* fmt, const Args&... args);
-    template <typename... Args> void debug_if(const bool flag, const wchar_t* fmt, const Args&... args);
-    template <typename... Args> void info_if(const bool flag, const wchar_t* fmt, const Args&... args);
-    template <typename... Args> void warn_if(const bool flag, const wchar_t* fmt, const Args&... args);
-    template <typename... Args> void error_if(const bool flag, const wchar_t* fmt, const Args&... args);
-    template <typename... Args> void critical_if(const bool flag, const wchar_t* fmt, const Args&... args);
-#endif // SPDLOG_WCHAR_TO_UTF8_SUPPORT
-
-    template <typename T> void log(level::level_enum lvl, const T&);
-    template <typename T> void trace(const T&);
-    template <typename T> void debug(const T&);
-    template <typename T> void info(const T&);
-    template <typename T> void warn(const T&);
-    template <typename T> void error(const T&);
-    template <typename T> void critical(const T&);
-
-    template <typename T> void log_if(const bool flag, level::level_enum lvl, const T&);
-    template <typename T> void trace_if(const bool flag, const T&);
-    template <typename T> void debug_if(const bool flag, const T&);
-    template <typename T> void info_if(const bool flag, const T&);
-    template <typename T> void warn_if(const bool flag, const T&);
-    template <typename T> void error_if(const bool flag, const T&);
-    template <typename T> void critical_if(const bool flag, const T&);
-
-    bool should_log(level::level_enum) const;
-    void set_level(level::level_enum);
-    level::level_enum level() const;
-    const std::string& name() const;
-    void set_pattern(const std::string&, pattern_time_type = pattern_time_type::local);
-    void set_formatter(formatter_ptr);
-
-    // automatically call flush() if message level >= log_level
-    void flush_on(level::level_enum log_level);
-
-    virtual void flush();
-
-    const std::vector<sink_ptr>& sinks() const;
-
-    // error handler
-    virtual void set_error_handler(log_err_handler);
-    virtual log_err_handler error_handler();
-
-protected:
-    virtual void _sink_it(details::log_msg&);
-    virtual void _set_pattern(const std::string&, pattern_time_type);
-    virtual void _set_formatter(formatter_ptr);
-
-    // default error handler: print the error to stderr with the max rate of 1 message/minute
-    virtual void _default_err_handler(const std::string &msg);
-
-    // return true if the given message level should trigger a flush
-    bool _should_flush_on(const details::log_msg&);
-
-    const std::string _name;
-    std::vector<sink_ptr> _sinks;
-    formatter_ptr _formatter;
-    spdlog::level_t _level;
-    spdlog::level_t _flush_level;
-    log_err_handler _err_handler;
-    std::atomic<time_t> _last_err_time;
-    std::atomic<size_t> _msg_counter;
-};
-}
-
-#include "spdlog/details/logger_impl.h"
diff --git a/wasserstein/include/spdlog/sinks/android_sink.h b/wasserstein/include/spdlog/sinks/android_sink.h
deleted file mode 100644
index 239f2d2..0000000
--- a/wasserstein/include/spdlog/sinks/android_sink.h
+++ /dev/null
@@ -1,90 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#if defined(__ANDROID__)
-
-#include "spdlog/sinks/sink.h"
-
-#include <mutex>
-#include <string>
-#include <android/log.h>
-#include <thread>
-#include <chrono>
-
-#if !defined(SPDLOG_ANDROID_RETRIES)
-#define SPDLOG_ANDROID_RETRIES 2
-#endif
-
-namespace spdlog
-{
-namespace sinks
-{
-
-/*
-* Android sink (logging using __android_log_write)
-* __android_log_write is thread-safe. No lock is needed.
-*/
-class android_sink : public sink
-{
-public:
-    explicit android_sink(const std::string& tag = "spdlog", bool use_raw_msg = false): _tag(tag), _use_raw_msg(use_raw_msg) {}
-
-    void log(const details::log_msg& msg) override
-    {
-        const android_LogPriority priority = convert_to_android(msg.level);
-        const char *msg_output = (_use_raw_msg ? msg.raw.c_str() : msg.formatted.c_str());
-
-        // See system/core/liblog/logger_write.c for explanation of return value
-        int ret = __android_log_write(priority, _tag.c_str(), msg_output);
-        int retry_count = 0;
-        while ((ret == -11/*EAGAIN*/) && (retry_count < SPDLOG_ANDROID_RETRIES))
-        {
-            std::this_thread::sleep_for(std::chrono::milliseconds(5));
-            ret = __android_log_write(priority, _tag.c_str(), msg_output);
-            retry_count++;
-        }
-
-        if (ret < 0)
-        {
-            throw spdlog_ex("__android_log_write() failed", ret);
-        }
-    }
-
-    void flush() override
-    {
-    }
-
-private:
-    static android_LogPriority convert_to_android(spdlog::level::level_enum level)
-    {
-        switch(level)
-        {
-        case spdlog::level::trace:
-            return ANDROID_LOG_VERBOSE;
-        case spdlog::level::debug:
-            return ANDROID_LOG_DEBUG;
-        case spdlog::level::info:
-            return ANDROID_LOG_INFO;
-        case spdlog::level::warn:
-            return ANDROID_LOG_WARN;
-        case spdlog::level::err:
-            return ANDROID_LOG_ERROR;
-        case spdlog::level::critical:
-            return ANDROID_LOG_FATAL;
-        default:
-            return ANDROID_LOG_DEFAULT;
-        }
-    }
-
-    std::string _tag;
-    bool _use_raw_msg;
-};
-
-}
-}
-
-#endif
diff --git a/wasserstein/include/spdlog/sinks/ansicolor_sink.h b/wasserstein/include/spdlog/sinks/ansicolor_sink.h
deleted file mode 100644
index 56fd3fd..0000000
--- a/wasserstein/include/spdlog/sinks/ansicolor_sink.h
+++ /dev/null
@@ -1,133 +0,0 @@
-//
-// Copyright(c) 2017 spdlog authors.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include "spdlog/sinks/base_sink.h"
-#include "spdlog/common.h"
-#include "spdlog/details/os.h"
-
-#include <string>
-#include <map>
-
-namespace spdlog
-{
-namespace sinks
-{
-
-/**
- * This sink prefixes the output with an ANSI escape sequence color code depending on the severity
- * of the message.
- * If no color terminal detected, omit the escape codes.
- */
-template <class Mutex>
-class ansicolor_sink: public base_sink<Mutex>
-{
-public:
-    ansicolor_sink(FILE* file): target_file_(file)
-    {
-        should_do_colors_ = details::os::in_terminal(file) && details::os::is_color_terminal();
-        colors_[level::trace] = cyan;
-        colors_[level::debug] = cyan;
-        colors_[level::info] = reset;
-        colors_[level::warn] = yellow + bold;
-        colors_[level::err] = red + bold;
-        colors_[level::critical] = bold + on_red;
-        colors_[level::off] = reset;
-    }
-    virtual ~ansicolor_sink()
-    {
-        _flush();
-    }
-
-    void set_color(level::level_enum color_level, const std::string& color)
-    {
-        std::lock_guard<Mutex> lock(base_sink<Mutex>::_mutex);
-        colors_[color_level] = color;
-    }
-
-    /// Formatting codes
-    const std::string reset = "\033[00m";
-    const std::string bold = "\033[1m";
-    const std::string dark = "\033[2m";
-    const std::string underline = "\033[4m";
-    const std::string blink = "\033[5m";
-    const std::string reverse = "\033[7m";
-    const std::string concealed = "\033[8m";
-
-    // Foreground colors
-    const std::string grey = "\033[30m";
-    const std::string red = "\033[31m";
-    const std::string green = "\033[32m";
-    const std::string yellow = "\033[33m";
-    const std::string blue = "\033[34m";
-    const std::string magenta = "\033[35m";
-    const std::string cyan = "\033[36m";
-    const std::string white = "\033[37m";
-
-    /// Background colors
-    const std::string on_grey = "\033[40m";
-    const std::string on_red = "\033[41m";
-    const std::string on_green = "\033[42m";
-    const std::string on_yellow = "\033[43m";
-    const std::string on_blue = "\033[44m";
-    const std::string on_magenta = "\033[45m";
-    const std::string on_cyan = "\033[46m";
-    const std::string on_white = "\033[47m";
-
-protected:
-    virtual void _sink_it(const details::log_msg& msg) override
-    {
-        // Wrap the originally formatted message in color codes.
-        // If color is not supported in the terminal, log as is instead.
-        if (should_do_colors_)
-        {
-            const std::string& prefix = colors_[msg.level];
-            fwrite(prefix.data(), sizeof(char), prefix.size(), target_file_);
-            fwrite(msg.formatted.data(), sizeof(char), msg.formatted.size(), target_file_);
-            fwrite(reset.data(), sizeof(char), reset.size(), target_file_);
-        }
-        else
-        {
-            fwrite(msg.formatted.data(), sizeof(char), msg.formatted.size(), target_file_);
-        }
-        _flush();
-    }
-
-    void _flush() override
-    {
-        fflush(target_file_);
-    }
-    FILE* target_file_;
-    bool should_do_colors_;
-    std::map<level::level_enum, std::string> colors_;
-};
-
-
-template<class Mutex>
-class ansicolor_stdout_sink: public ansicolor_sink<Mutex>
-{
-public:
-    ansicolor_stdout_sink(): ansicolor_sink<Mutex>(stdout)
-    {}
-};
-
-template<class Mutex>
-class ansicolor_stderr_sink: public ansicolor_sink<Mutex>
-{
-public:
-    ansicolor_stderr_sink(): ansicolor_sink<Mutex>(stderr)
-    {}
-};
-
-typedef ansicolor_stdout_sink<std::mutex> ansicolor_stdout_sink_mt;
-typedef ansicolor_stdout_sink<details::null_mutex> ansicolor_stdout_sink_st;
-
-typedef ansicolor_stderr_sink<std::mutex> ansicolor_stderr_sink_mt;
-typedef ansicolor_stderr_sink<details::null_mutex> ansicolor_stderr_sink_st;
-
-} // namespace sinks
-} // namespace spdlog
-
diff --git a/wasserstein/include/spdlog/sinks/base_sink.h b/wasserstein/include/spdlog/sinks/base_sink.h
deleted file mode 100644
index 926f493..0000000
--- a/wasserstein/include/spdlog/sinks/base_sink.h
+++ /dev/null
@@ -1,50 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-//
-// base sink templated over a mutex (either dummy or real)
-// concrete implementation should only override the _sink_it method.
-// all locking is taken care of here so no locking needed by the implementers..
-//
-
-#include "spdlog/sinks/sink.h"
-#include "spdlog/formatter.h"
-#include "spdlog/common.h"
-#include "spdlog/details/log_msg.h"
-
-#include <mutex>
-
-namespace spdlog
-{
-namespace sinks
-{
-template<class Mutex>
-class base_sink:public sink
-{
-public:
-    base_sink():_mutex() {}
-    virtual ~base_sink() = default;
-
-    base_sink(const base_sink&) = delete;
-    base_sink& operator=(const base_sink&) = delete;
-
-    void log(const details::log_msg& msg) SPDLOG_FINAL override
-    {
-        std::lock_guard<Mutex> lock(_mutex);
-        _sink_it(msg);
-    }
-    void flush() SPDLOG_FINAL override
-    {
-        _flush();
-    }
-
-protected:
-    virtual void _sink_it(const details::log_msg& msg) = 0;
-    virtual void _flush() = 0;
-    Mutex _mutex;
-};
-}
-}
diff --git a/wasserstein/include/spdlog/sinks/dist_sink.h b/wasserstein/include/spdlog/sinks/dist_sink.h
deleted file mode 100644
index 4d4b6b6..0000000
--- a/wasserstein/include/spdlog/sinks/dist_sink.h
+++ /dev/null
@@ -1,73 +0,0 @@
-//
-// Copyright (c) 2015 David Schury, Gabi Melman
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include "spdlog/details/log_msg.h"
-#include "spdlog/details/null_mutex.h"
-#include "spdlog/sinks/base_sink.h"
-#include "spdlog/sinks/sink.h"
-
-#include <algorithm>
-#include <mutex>
-#include <memory>
-#include <vector>
-
-// Distribution sink (mux). Stores a vector of sinks which get called when log is called
-
-namespace spdlog
-{
-namespace sinks
-{
-template<class Mutex>
-class dist_sink: public base_sink<Mutex>
-{
-public:
-    explicit dist_sink() :_sinks() {}
-    dist_sink(const dist_sink&) = delete;
-    dist_sink& operator=(const dist_sink&) = delete;
-    virtual ~dist_sink() = default;
-
-protected:
-    std::vector<std::shared_ptr<sink>> _sinks;
-
-    void _sink_it(const details::log_msg& msg) override
-    {
-        for (auto &sink : _sinks)
-        {
-            if( sink->should_log( msg.level))
-            {
-                sink->log(msg);
-            }
-        }
-    }
-
-    void _flush() override
-    {
-        std::lock_guard<Mutex> lock(base_sink<Mutex>::_mutex);
-        for (auto &sink : _sinks)
-            sink->flush();
-    }
-
-public:
-
-
-    void add_sink(std::shared_ptr<sink> sink)
-    {
-        std::lock_guard<Mutex> lock(base_sink<Mutex>::_mutex);
-        _sinks.push_back(sink);
-    }
-
-    void remove_sink(std::shared_ptr<sink> sink)
-    {
-        std::lock_guard<Mutex> lock(base_sink<Mutex>::_mutex);
-        _sinks.erase(std::remove(_sinks.begin(), _sinks.end(), sink), _sinks.end());
-    }
-};
-
-typedef dist_sink<std::mutex> dist_sink_mt;
-typedef dist_sink<details::null_mutex> dist_sink_st;
-}
-}
diff --git a/wasserstein/include/spdlog/sinks/file_sinks.h b/wasserstein/include/spdlog/sinks/file_sinks.h
deleted file mode 100644
index 421acc8..0000000
--- a/wasserstein/include/spdlog/sinks/file_sinks.h
+++ /dev/null
@@ -1,242 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include "spdlog/sinks/base_sink.h"
-#include "spdlog/details/null_mutex.h"
-#include "spdlog/details/file_helper.h"
-#include "spdlog/fmt/fmt.h"
-
-#include <algorithm>
-#include <chrono>
-#include <cstdio>
-#include <ctime>
-#include <mutex>
-#include <string>
-#include <cerrno>
-
-namespace spdlog
-{
-namespace sinks
-{
-/*
- * Trivial file sink with single file as target
- */
-template<class Mutex>
-class simple_file_sink SPDLOG_FINAL : public base_sink < Mutex >
-{
-public:
-    explicit simple_file_sink(const filename_t &filename, bool truncate = false):_force_flush(false)
-    {
-        _file_helper.open(filename, truncate);
-    }
-
-    void set_force_flush(bool force_flush)
-    {
-        _force_flush = force_flush;
-    }
-
-protected:
-    void _sink_it(const details::log_msg& msg) override
-    {
-        _file_helper.write(msg);
-        if(_force_flush)
-            _file_helper.flush();
-    }
-    void _flush() override
-    {
-        _file_helper.flush();
-    }
-private:
-    details::file_helper _file_helper;
-    bool _force_flush;
-};
-
-typedef simple_file_sink<std::mutex> simple_file_sink_mt;
-typedef simple_file_sink<details::null_mutex> simple_file_sink_st;
-
-/*
- * Rotating file sink based on size
- */
-template<class Mutex>
-class rotating_file_sink SPDLOG_FINAL : public base_sink < Mutex >
-{
-public:
-    rotating_file_sink(const filename_t &base_filename,
-                       std::size_t max_size, std::size_t max_files) :
-        _base_filename(base_filename),
-        _max_size(max_size),
-        _max_files(max_files),
-        _current_size(0),
-        _file_helper()
-    {
-        _file_helper.open(calc_filename(_base_filename, 0));
-        _current_size = _file_helper.size(); //expensive. called only once
-    }
-
-
-protected:
-    void _sink_it(const details::log_msg& msg) override
-    {
-        _current_size += msg.formatted.size();
-        if (_current_size > _max_size)
-        {
-            _rotate();
-            _current_size = msg.formatted.size();
-        }
-        _file_helper.write(msg);
-    }
-
-    void _flush() override
-    {
-        _file_helper.flush();
-    }
-
-private:
-    static filename_t calc_filename(const filename_t& filename, std::size_t index)
-    {
-        std::conditional<std::is_same<filename_t::value_type, char>::value, fmt::MemoryWriter, fmt::WMemoryWriter>::type w;
-        if (index)
-            w.write(SPDLOG_FILENAME_T("{}.{}"), filename, index);
-        else
-            w.write(SPDLOG_FILENAME_T("{}"), filename);
-        return w.str();
-    }
-
-    // Rotate files:
-    // log.txt -> log.txt.1
-    // log.txt.1 -> log.txt.2
-    // log.txt.2 -> log.txt.3
-    // lo3.txt.3 -> delete
-
-    void _rotate()
-    {
-        using details::os::filename_to_str;
-        _file_helper.close();
-        for (auto i = _max_files; i > 0; --i)
-        {
-            filename_t src = calc_filename(_base_filename, i - 1);
-            filename_t target = calc_filename(_base_filename, i);
-
-            if (details::file_helper::file_exists(target))
-            {
-                if (details::os::remove(target) != 0)
-                {
-                    throw spdlog_ex("rotating_file_sink: failed removing " + filename_to_str(target), errno);
-                }
-            }
-            if (details::file_helper::file_exists(src) && details::os::rename(src, target))
-            {
-                throw spdlog_ex("rotating_file_sink: failed renaming " + filename_to_str(src) + " to " + filename_to_str(target), errno);
-            }
-        }
-        _file_helper.reopen(true);
-    }
-    filename_t _base_filename;
-    std::size_t _max_size;
-    std::size_t _max_files;
-    std::size_t _current_size;
-    details::file_helper _file_helper;
-};
-
-typedef rotating_file_sink<std::mutex> rotating_file_sink_mt;
-typedef rotating_file_sink<details::null_mutex>rotating_file_sink_st;
-
-/*
- * Default generator of daily log file names.
- */
-struct default_daily_file_name_calculator
-{
-    // Create filename for the form basename.YYYY-MM-DD_hh-mm
-    static filename_t calc_filename(const filename_t& basename)
-    {
-        std::tm tm = spdlog::details::os::localtime();
-        std::conditional<std::is_same<filename_t::value_type, char>::value, fmt::MemoryWriter, fmt::WMemoryWriter>::type w;
-        w.write(SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}_{:02d}-{:02d}"), basename, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min);
-        return w.str();
-    }
-};
-
-/*
- * Generator of daily log file names in format basename.YYYY-MM-DD
- */
-struct dateonly_daily_file_name_calculator
-{
-    // Create filename for the form basename.YYYY-MM-DD
-    static filename_t calc_filename(const filename_t& basename)
-    {
-        std::tm tm = spdlog::details::os::localtime();
-        std::conditional<std::is_same<filename_t::value_type, char>::value, fmt::MemoryWriter, fmt::WMemoryWriter>::type w;
-        w.write(SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}"), basename, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);
-        return w.str();
-    }
-};
-
-/*
- * Rotating file sink based on date. rotates at midnight
- */
-template<class Mutex, class FileNameCalc = default_daily_file_name_calculator>
-class daily_file_sink SPDLOG_FINAL :public base_sink < Mutex >
-{
-public:
-    //create daily file sink which rotates on given time
-    daily_file_sink(
-        const filename_t& base_filename,
-        int rotation_hour,
-        int rotation_minute) : _base_filename(base_filename),
-        _rotation_h(rotation_hour),
-        _rotation_m(rotation_minute)
-    {
-        if (rotation_hour < 0 || rotation_hour > 23 || rotation_minute < 0 || rotation_minute > 59)
-            throw spdlog_ex("daily_file_sink: Invalid rotation time in ctor");
-        _rotation_tp = _next_rotation_tp();
-        _file_helper.open(FileNameCalc::calc_filename(_base_filename));
-    }
-
-
-protected:
-    void _sink_it(const details::log_msg& msg) override
-    {
-        if (std::chrono::system_clock::now() >= _rotation_tp)
-        {
-            _file_helper.open(FileNameCalc::calc_filename(_base_filename));
-            _rotation_tp = _next_rotation_tp();
-        }
-        _file_helper.write(msg);
-    }
-
-    void _flush() override
-    {
-        _file_helper.flush();
-    }
-
-private:
-    std::chrono::system_clock::time_point _next_rotation_tp()
-    {
-        auto now = std::chrono::system_clock::now();
-        time_t tnow = std::chrono::system_clock::to_time_t(now);
-        tm date = spdlog::details::os::localtime(tnow);
-        date.tm_hour = _rotation_h;
-        date.tm_min = _rotation_m;
-        date.tm_sec = 0;
-        auto rotation_time = std::chrono::system_clock::from_time_t(std::mktime(&date));
-        if (rotation_time > now)
-            return rotation_time;
-        else
-            return std::chrono::system_clock::time_point(rotation_time + std::chrono::hours(24));
-    }
-
-    filename_t _base_filename;
-    int _rotation_h;
-    int _rotation_m;
-    std::chrono::system_clock::time_point _rotation_tp;
-    details::file_helper _file_helper;
-};
-
-typedef daily_file_sink<std::mutex> daily_file_sink_mt;
-typedef daily_file_sink<details::null_mutex> daily_file_sink_st;
-}
-}
diff --git a/wasserstein/include/spdlog/sinks/msvc_sink.h b/wasserstein/include/spdlog/sinks/msvc_sink.h
deleted file mode 100644
index 68b0255..0000000
--- a/wasserstein/include/spdlog/sinks/msvc_sink.h
+++ /dev/null
@@ -1,51 +0,0 @@
-//
-// Copyright(c) 2016 Alexander Dalshov.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#if defined(_MSC_VER)
-
-#include "spdlog/sinks/base_sink.h"
-#include "spdlog/details/null_mutex.h"
-
-#include <WinBase.h>
-
-#include <mutex>
-#include <string>
-
-namespace spdlog
-{
-namespace sinks
-{
-/*
-* MSVC sink (logging using OutputDebugStringA)
-*/
-template<class Mutex>
-class msvc_sink : public base_sink < Mutex >
-{
-public:
-    explicit msvc_sink()
-    {
-    }
-
-
-
-protected:
-    void _sink_it(const details::log_msg& msg) override
-    {
-        OutputDebugStringA(msg.formatted.c_str());
-    }
-
-    void _flush() override
-    {}
-};
-
-typedef msvc_sink<std::mutex> msvc_sink_mt;
-typedef msvc_sink<details::null_mutex> msvc_sink_st;
-
-}
-}
-
-#endif
diff --git a/wasserstein/include/spdlog/sinks/null_sink.h b/wasserstein/include/spdlog/sinks/null_sink.h
deleted file mode 100644
index ed4b5e4..0000000
--- a/wasserstein/include/spdlog/sinks/null_sink.h
+++ /dev/null
@@ -1,34 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include "spdlog/sinks/base_sink.h"
-#include "spdlog/details/null_mutex.h"
-
-#include <mutex>
-
-namespace spdlog
-{
-namespace sinks
-{
-
-template <class Mutex>
-class null_sink : public base_sink < Mutex >
-{
-protected:
-    void _sink_it(const details::log_msg&) override
-    {}
-
-    void _flush() override
-    {}
-
-};
-typedef null_sink<details::null_mutex> null_sink_st;
-typedef null_sink<details::null_mutex> null_sink_mt;
-
-}
-}
-
diff --git a/wasserstein/include/spdlog/sinks/ostream_sink.h b/wasserstein/include/spdlog/sinks/ostream_sink.h
deleted file mode 100644
index f056107..0000000
--- a/wasserstein/include/spdlog/sinks/ostream_sink.h
+++ /dev/null
@@ -1,47 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include "spdlog/details/null_mutex.h"
-#include "spdlog/sinks/base_sink.h"
-
-#include <ostream>
-#include <mutex>
-
-namespace spdlog
-{
-namespace sinks
-{
-template<class Mutex>
-class ostream_sink: public base_sink<Mutex>
-{
-public:
-    explicit ostream_sink(std::ostream& os, bool force_flush=false) :_ostream(os), _force_flush(force_flush) {}
-    ostream_sink(const ostream_sink&) = delete;
-    ostream_sink& operator=(const ostream_sink&) = delete;
-    virtual ~ostream_sink() = default;
-
-protected:
-    void _sink_it(const details::log_msg& msg) override
-    {
-        _ostream.write(msg.formatted.data(), msg.formatted.size());
-        if (_force_flush)
-            _ostream.flush();
-    }
-
-    void _flush() override
-    {
-        _ostream.flush();
-    }
-
-    std::ostream& _ostream;
-    bool _force_flush;
-};
-
-typedef ostream_sink<std::mutex> ostream_sink_mt;
-typedef ostream_sink<details::null_mutex> ostream_sink_st;
-}
-}
diff --git a/wasserstein/include/spdlog/sinks/sink.h b/wasserstein/include/spdlog/sinks/sink.h
deleted file mode 100644
index 0974f33..0000000
--- a/wasserstein/include/spdlog/sinks/sink.h
+++ /dev/null
@@ -1,53 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-
-#pragma once
-
-#include "spdlog/details/log_msg.h"
-
-namespace spdlog
-{
-namespace sinks
-{
-class sink
-{
-public:
-    sink()
-    {
-        _level = level::trace;
-    }
-
-    virtual ~sink() {}
-    virtual void log(const details::log_msg& msg) = 0;
-    virtual void flush() = 0;
-
-    bool should_log(level::level_enum msg_level) const;
-    void set_level(level::level_enum log_level);
-    level::level_enum level() const;
-
-private:
-    level_t _level;
-
-};
-
-inline bool sink::should_log(level::level_enum msg_level) const
-{
-    return msg_level >= _level.load(std::memory_order_relaxed);
-}
-
-inline void sink::set_level(level::level_enum log_level)
-{
-    _level.store(log_level);
-}
-
-inline level::level_enum sink::level() const
-{
-    return static_cast<spdlog::level::level_enum>(_level.load(std::memory_order_relaxed));
-}
-
-}
-}
-
diff --git a/wasserstein/include/spdlog/sinks/stdout_sinks.h b/wasserstein/include/spdlog/sinks/stdout_sinks.h
deleted file mode 100644
index dcdcc7c..0000000
--- a/wasserstein/include/spdlog/sinks/stdout_sinks.h
+++ /dev/null
@@ -1,77 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include "spdlog/details/null_mutex.h"
-#include "spdlog/sinks/base_sink.h"
-
-#include <cstdio>
-#include <memory>
-#include <mutex>
-
-namespace spdlog
-{
-namespace sinks
-{
-
-template <class Mutex>
-class stdout_sink SPDLOG_FINAL : public base_sink<Mutex>
-{
-    using MyType = stdout_sink<Mutex>;
-public:
-    stdout_sink()
-    {}
-    static std::shared_ptr<MyType> instance()
-    {
-        static std::shared_ptr<MyType> instance = std::make_shared<MyType>();
-        return instance;
-    }
-protected:
-    void _sink_it(const details::log_msg& msg) override
-    {
-        fwrite(msg.formatted.data(), sizeof(char), msg.formatted.size(), stdout);
-        _flush();
-    }
-
-    void _flush() override
-    {
-        fflush(stdout);
-    }
-};
-
-typedef stdout_sink<details::null_mutex> stdout_sink_st;
-typedef stdout_sink<std::mutex> stdout_sink_mt;
-
-
-template <class Mutex>
-class stderr_sink SPDLOG_FINAL : public base_sink<Mutex>
-{
-    using MyType = stderr_sink<Mutex>;
-public:
-    stderr_sink()
-    {}
-    static std::shared_ptr<MyType> instance()
-    {
-        static std::shared_ptr<MyType> instance = std::make_shared<MyType>();
-        return instance;
-    }
-protected:
-    void _sink_it(const details::log_msg& msg) override
-    {
-        fwrite(msg.formatted.data(), sizeof(char), msg.formatted.size(), stderr);
-        _flush();
-    }
-
-    void _flush() override
-    {
-        fflush(stderr);
-    }
-};
-
-typedef stderr_sink<std::mutex> stderr_sink_mt;
-typedef stderr_sink<details::null_mutex> stderr_sink_st;
-}
-}
diff --git a/wasserstein/include/spdlog/sinks/syslog_sink.h b/wasserstein/include/spdlog/sinks/syslog_sink.h
deleted file mode 100644
index 0b509c4..0000000
--- a/wasserstein/include/spdlog/sinks/syslog_sink.h
+++ /dev/null
@@ -1,81 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include "spdlog/common.h"
-
-#ifdef SPDLOG_ENABLE_SYSLOG
-
-#include "spdlog/sinks/sink.h"
-#include "spdlog/details/log_msg.h"
-
-#include <array>
-#include <string>
-#include <syslog.h>
-
-
-namespace spdlog
-{
-namespace sinks
-{
-/**
- * Sink that write to syslog using the `syscall()` library call.
- *
- * Locking is not needed, as `syslog()` itself is thread-safe.
- */
-class syslog_sink : public sink
-{
-public:
-    //
-    syslog_sink(const std::string& ident = "", int syslog_option=0, int syslog_facility=LOG_USER):
-        _ident(ident)
-    {
-        _priorities[static_cast<int>(level::trace)] = LOG_DEBUG;
-        _priorities[static_cast<int>(level::debug)] = LOG_DEBUG;
-        _priorities[static_cast<int>(level::info)] = LOG_INFO;
-        _priorities[static_cast<int>(level::warn)] = LOG_WARNING;
-        _priorities[static_cast<int>(level::err)] = LOG_ERR;
-        _priorities[static_cast<int>(level::critical)] = LOG_CRIT;
-        _priorities[static_cast<int>(level::off)] = LOG_INFO;
-
-        //set ident to be program name if empty
-        ::openlog(_ident.empty()? nullptr:_ident.c_str(), syslog_option, syslog_facility);
-    }
-    ~syslog_sink()
-    {
-        ::closelog();
-    }
-
-    syslog_sink(const syslog_sink&) = delete;
-    syslog_sink& operator=(const syslog_sink&) = delete;
-
-    void log(const details::log_msg &msg) override
-    {
-        ::syslog(syslog_prio_from_level(msg), "%s", msg.raw.str().c_str());
-    }
-
-    void flush() override
-    {
-    }
-
-
-private:
-    std::array<int, 7> _priorities;
-    //must store the ident because the man says openlog might use the pointer as is and not a string copy
-    const std::string _ident;
-
-    //
-    // Simply maps spdlog's log level to syslog priority level.
-    //
-    int syslog_prio_from_level(const details::log_msg &msg) const
-    {
-        return _priorities[static_cast<int>(msg.level)];
-    }
-};
-}
-}
-
-#endif
diff --git a/wasserstein/include/spdlog/sinks/wincolor_sink.h b/wasserstein/include/spdlog/sinks/wincolor_sink.h
deleted file mode 100644
index 6611124..0000000
--- a/wasserstein/include/spdlog/sinks/wincolor_sink.h
+++ /dev/null
@@ -1,117 +0,0 @@
-//
-// Copyright(c) 2016 spdlog
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include "spdlog/sinks/base_sink.h"
-#include "spdlog/details/null_mutex.h"
-#include "spdlog/common.h"
-
-#include <mutex>
-#include <string>
-#include <map>
-#include <wincon.h>
-
-namespace spdlog
-{
-namespace sinks
-{
-/*
- * Windows color console sink. Uses WriteConsoleA to write to the console with colors
- */
-template<class Mutex>
-class wincolor_sink: public  base_sink<Mutex>
-{
-public:
-    const WORD BOLD = FOREGROUND_INTENSITY;
-    const WORD RED = FOREGROUND_RED;
-    const WORD CYAN = FOREGROUND_GREEN | FOREGROUND_BLUE;
-    const WORD WHITE = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
-    const WORD YELLOW = FOREGROUND_RED | FOREGROUND_GREEN;
-
-    wincolor_sink(HANDLE std_handle): out_handle_(std_handle)
-    {
-        colors_[level::trace] = CYAN;
-        colors_[level::debug] = CYAN;
-        colors_[level::info] = WHITE | BOLD;
-        colors_[level::warn] = YELLOW | BOLD;
-        colors_[level::err] = RED | BOLD; // red bold
-        colors_[level::critical] = BACKGROUND_RED | WHITE | BOLD; // white bold on red background
-        colors_[level::off] = 0;
-    }
-
-    virtual ~wincolor_sink()
-    {
-        this->flush();
-    }
-
-    wincolor_sink(const wincolor_sink& other) = delete;
-    wincolor_sink& operator=(const wincolor_sink& other) = delete;
-
-protected:
-    virtual void _sink_it(const details::log_msg& msg) override
-    {
-        auto color = colors_[msg.level];
-        auto orig_attribs = set_console_attribs(color);
-        WriteConsoleA(out_handle_, msg.formatted.data(), static_cast<DWORD>(msg.formatted.size()), nullptr, nullptr);
-        SetConsoleTextAttribute(out_handle_, orig_attribs); //reset to orig colors
-    }
-
-    virtual void _flush() override
-    {
-        // windows console always flushed?
-    }
-
-    // change the  color for the given level
-    void set_color(level::level_enum level, WORD color)
-    {
-        std::lock_guard<Mutex> lock(base_sink<Mutex>::_mutex);
-        colors_[level] = color;
-    }
-
-private:
-    HANDLE out_handle_;
-    std::map<level::level_enum, WORD> colors_;
-
-    // set color and return the orig console attributes (for resetting later)
-    WORD set_console_attribs(WORD attribs)
-    {
-        CONSOLE_SCREEN_BUFFER_INFO orig_buffer_info;
-        GetConsoleScreenBufferInfo(out_handle_, &orig_buffer_info);
-        SetConsoleTextAttribute(out_handle_, attribs);
-        return  orig_buffer_info.wAttributes; //return orig attribs
-    }
-};
-
-//
-// windows color console to stdout
-//
-template<class Mutex>
-class wincolor_stdout_sink: public wincolor_sink<Mutex>
-{
-public:
-    wincolor_stdout_sink() : wincolor_sink<Mutex>(GetStdHandle(STD_OUTPUT_HANDLE))
-    {}
-};
-
-typedef wincolor_stdout_sink<std::mutex> wincolor_stdout_sink_mt;
-typedef wincolor_stdout_sink<details::null_mutex> wincolor_stdout_sink_st;
-
-//
-// windows color console to stderr
-//
-template<class Mutex>
-class wincolor_stderr_sink: public wincolor_sink<Mutex>
-{
-public:
-    wincolor_stderr_sink() : wincolor_sink<Mutex>(GetStdHandle(STD_ERROR_HANDLE))
-    {}
-};
-
-typedef wincolor_stderr_sink<std::mutex> wincolor_stderr_sink_mt;
-typedef wincolor_stderr_sink<details::null_mutex> wincolor_stderr_sink_st;
-
-}
-}
diff --git a/wasserstein/include/spdlog/spdlog.h b/wasserstein/include/spdlog/spdlog.h
deleted file mode 100644
index fb4ea59..0000000
--- a/wasserstein/include/spdlog/spdlog.h
+++ /dev/null
@@ -1,187 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-// spdlog main header file.
-// see example.cpp for usage example
-
-#pragma once
-
-#define SPDLOG_VERSION "0.13.0"
-
-#include "spdlog/tweakme.h"
-#include "spdlog/common.h"
-#include "spdlog/logger.h"
-
-#include <memory>
-#include <functional>
-#include <chrono>
-#include <string>
-
-namespace spdlog
-{
-
-//
-// Return an existing logger or nullptr if a logger with such name doesn't exist.
-// example: spdlog::get("my_logger")->info("hello {}", "world");
-//
-std::shared_ptr<logger> get(const std::string& name);
-
-
-//
-// Set global formatting
-// example: spdlog::set_pattern("%Y-%m-%d %H:%M:%S.%e %l : %v");
-//
-void set_pattern(const std::string& format_string);
-void set_formatter(formatter_ptr f);
-
-//
-// Set global logging level for
-//
-void set_level(level::level_enum log_level);
-
-//
-// Set global error handler
-//
-void set_error_handler(log_err_handler);
-
-//
-// Turn on async mode (off by default) and set the queue size for each async_logger.
-// effective only for loggers created after this call.
-// queue_size: size of queue (must be power of 2):
-//    Each logger will pre-allocate a dedicated queue with queue_size entries upon construction.
-//
-// async_overflow_policy (optional, block_retry by default):
-//    async_overflow_policy::block_retry - if queue is full, block until queue has room for the new log entry.
-//    async_overflow_policy::discard_log_msg - never block and discard any new messages when queue  overflows.
-//
-// worker_warmup_cb (optional):
-//     callback function that will be called in worker thread upon start (can be used to init stuff like thread affinity)
-//
-// worker_teardown_cb (optional):
-//     callback function that will be called in worker thread upon exit
-//
-void set_async_mode(size_t queue_size, const async_overflow_policy overflow_policy = async_overflow_policy::block_retry, const std::function<void()>& worker_warmup_cb = nullptr, const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero(), const std::function<void()>& worker_teardown_cb = nullptr);
-
-// Turn off async mode
-void set_sync_mode();
-
-
-//
-// Create and register multi/single threaded basic file logger.
-// Basic logger simply writes to given file without any limitatons or rotations.
-//
-std::shared_ptr<logger> basic_logger_mt(const std::string& logger_name, const filename_t& filename, bool truncate = false);
-std::shared_ptr<logger> basic_logger_st(const std::string& logger_name, const filename_t& filename, bool truncate = false);
-
-//
-// Create and register multi/single threaded rotating file logger
-//
-std::shared_ptr<logger> rotating_logger_mt(const std::string& logger_name, const filename_t& filename, size_t max_file_size, size_t max_files);
-std::shared_ptr<logger> rotating_logger_st(const std::string& logger_name, const filename_t& filename, size_t max_file_size, size_t max_files);
-
-//
-// Create file logger which creates new file on the given time (default in  midnight):
-//
-std::shared_ptr<logger> daily_logger_mt(const std::string& logger_name, const filename_t& filename, int hour=0, int minute=0);
-std::shared_ptr<logger> daily_logger_st(const std::string& logger_name, const filename_t& filename, int hour=0, int minute=0);
-
-//
-// Create and register stdout/stderr loggers
-//
-std::shared_ptr<logger> stdout_logger_mt(const std::string& logger_name);
-std::shared_ptr<logger> stdout_logger_st(const std::string& logger_name);
-std::shared_ptr<logger> stderr_logger_mt(const std::string& logger_name);
-std::shared_ptr<logger> stderr_logger_st(const std::string& logger_name);
-//
-// Create and register colored stdout/stderr loggers
-//
-std::shared_ptr<logger> stdout_color_mt(const std::string& logger_name);
-std::shared_ptr<logger> stdout_color_st(const std::string& logger_name);
-std::shared_ptr<logger> stderr_color_mt(const std::string& logger_name);
-std::shared_ptr<logger> stderr_color_st(const std::string& logger_name);
-
-
-//
-// Create and register a syslog logger
-//
-#ifdef SPDLOG_ENABLE_SYSLOG
-std::shared_ptr<logger> syslog_logger(const std::string& logger_name, const std::string& ident = "", int syslog_option = 0);
-#endif
-
-#if defined(__ANDROID__)
-std::shared_ptr<logger> android_logger(const std::string& logger_name, const std::string& tag = "spdlog");
-#endif
-
-// Create and register a logger with a single sink
-std::shared_ptr<logger> create(const std::string& logger_name, const sink_ptr& sink);
-
-// Create and register a logger with multiple sinks
-std::shared_ptr<logger> create(const std::string& logger_name, sinks_init_list sinks);
-template<class It>
-std::shared_ptr<logger> create(const std::string& logger_name, const It& sinks_begin, const It& sinks_end);
-
-
-// Create and register a logger with templated sink type
-// Example:
-// spdlog::create<daily_file_sink_st>("mylog", "dailylog_filename");
-template <typename Sink, typename... Args>
-std::shared_ptr<spdlog::logger> create(const std::string& logger_name, Args...);
-
-// Create and register an async logger with a single sink
-std::shared_ptr<logger> create_async(const std::string& logger_name, const sink_ptr& sink, size_t queue_size, const async_overflow_policy overflow_policy = async_overflow_policy::block_retry, const std::function<void()>& worker_warmup_cb = nullptr, const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero(), const std::function<void()>& worker_teardown_cb = nullptr);
-
-// Create and register an async logger with multiple sinks
-std::shared_ptr<logger> create_async(const std::string& logger_name, sinks_init_list sinks, size_t queue_size, const async_overflow_policy overflow_policy = async_overflow_policy::block_retry, const std::function<void()>& worker_warmup_cb = nullptr, const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero(), const std::function<void()>& worker_teardown_cb = nullptr);
-template<class It>
-std::shared_ptr<logger> create_async(const std::string& logger_name, const It& sinks_begin, const It& sinks_end, size_t queue_size, const async_overflow_policy overflow_policy = async_overflow_policy::block_retry, const std::function<void()>& worker_warmup_cb = nullptr, const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero(), const std::function<void()>& worker_teardown_cb = nullptr);
-
-// Register the given logger with the given name
-void register_logger(std::shared_ptr<logger> logger);
-
-// Apply a user defined function on all registered loggers
-// Example:
-// spdlog::apply_all([&](std::shared_ptr<spdlog::logger> l) {l->flush();});
-void apply_all(std::function<void(std::shared_ptr<logger>)> fun);
-
-// Drop the reference to the given logger
-void drop(const std::string &name);
-
-// Drop all references from the registry
-void drop_all();
-
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// Trace & Debug can be switched on/off at compile time for zero cost debug statements.
-// Uncomment SPDLOG_DEBUG_ON/SPDLOG_TRACE_ON in teakme.h to enable.
-// SPDLOG_TRACE(..) will also print current file and line.
-//
-// Example:
-// spdlog::set_level(spdlog::level::trace);
-// SPDLOG_TRACE(my_logger, "some trace message");
-// SPDLOG_TRACE(my_logger, "another trace message {} {}", 1, 2);
-// SPDLOG_DEBUG(my_logger, "some debug message {} {}", 3, 4);
-// SPDLOG_DEBUG_IF(my_logger, true, "some debug message {} {}", 3, 4);
-///////////////////////////////////////////////////////////////////////////////
-
-#ifdef SPDLOG_TRACE_ON
-#define SPDLOG_STR_H(x) #x
-#define SPDLOG_STR_HELPER(x) SPDLOG_STR_H(x)
-#define SPDLOG_TRACE(logger, ...) logger->trace("[" __FILE__ " line #" SPDLOG_STR_HELPER(__LINE__) "] " __VA_ARGS__)
-#define SPDLOG_TRACE_IF(logger, flag, ...) logger->trace_if(flag, "[" __FILE__ " line #" SPDLOG_STR_HELPER(__LINE__) "] " __VA_ARGS__)
-#else
-#define SPDLOG_TRACE(logger, ...)
-#endif
-
-#ifdef SPDLOG_DEBUG_ON
-#define SPDLOG_DEBUG(logger, ...) logger->debug(__VA_ARGS__)
-#define SPDLOG_DEBUG_IF(logger, flag, ...) logger->debug_if(flag, __VA_ARGS__)
-#else
-#define SPDLOG_DEBUG(logger, ...)
-#endif
-
-}
-
-
-#include "spdlog/details/spdlog_impl.h"
diff --git a/wasserstein/include/spdlog/tweakme.h b/wasserstein/include/spdlog/tweakme.h
deleted file mode 100644
index 53f5cf7..0000000
--- a/wasserstein/include/spdlog/tweakme.h
+++ /dev/null
@@ -1,141 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// Edit this file to squeeze more performance, and to customize supported features
-//
-///////////////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////////////
-// Under Linux, the much faster CLOCK_REALTIME_COARSE clock can be used.
-// This clock is less accurate - can be off by dozens of millis - depending on the kernel HZ.
-// Uncomment to use it instead of the regular clock.
-//
-// #define SPDLOG_CLOCK_COARSE
-///////////////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////////////
-// Uncomment if date/time logging is not needed and never appear in the log pattern.
-// This will prevent spdlog from quering the clock on each log call.
-//
-// WARNING: If the log pattern contains any date/time while this flag is on, the result is undefined.
-//          You must set new pattern(spdlog::set_pattern(..") without any date/time in it
-//
-// #define SPDLOG_NO_DATETIME
-///////////////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////////////
-// Uncomment if thread id logging is not needed (i.e. no %t in the log pattern).
-// This will prevent spdlog from quering the thread id on each log call.
-//
-// WARNING: If the log pattern contains thread id (i.e, %t) while this flag is on, the result is undefined.
-//
-// #define SPDLOG_NO_THREAD_ID
-///////////////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////////////
-// Uncomment if logger name logging is not needed.
-// This will prevent spdlog from copying the logger name  on each log call.
-//
-// #define SPDLOG_NO_NAME
-///////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////
-// Uncomment to enable the SPDLOG_DEBUG/SPDLOG_TRACE macros.
-//
-// #define SPDLOG_DEBUG_ON
-// #define SPDLOG_TRACE_ON
-///////////////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////////////
-// Uncomment to avoid locking in the registry operations (spdlog::get(), spdlog::drop() spdlog::register()).
-// Use only if your code never modifes concurrently the registry.
-// Note that upon creating a logger the registry is modified by spdlog..
-//
-// #define SPDLOG_NO_REGISTRY_MUTEX
-///////////////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////////////
-// Uncomment to avoid spdlog's usage of atomic log levels
-// Use only if your code never modifies a logger's log levels concurrently by different threads.
-//
-// #define SPDLOG_NO_ATOMIC_LEVELS
-///////////////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////////////
-// Uncomment to enable usage of wchar_t for file names on Windows.
-//
-// #define SPDLOG_WCHAR_FILENAMES
-///////////////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////////////
-// Uncomment to override default eol ("\n" or "\r\n" under Linux/Windows)
-//
-// #define SPDLOG_EOL ";-)\n"
-///////////////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////////////
-// Uncomment to use your own copy of the fmt library instead of spdlog's copy.
-// In this case spdlog will try to include <fmt/format.h> so set your -I flag accordingly.
-//
-// #define SPDLOG_FMT_EXTERNAL
-///////////////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////////////
-// Uncomment to enable syslog (disabled by default)
-//
-// #define SPDLOG_ENABLE_SYSLOG
-///////////////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////////////
-// Uncomment to enable wchar_t support (convert to utf8)
-//
-// #define SPDLOG_WCHAR_TO_UTF8_SUPPORT
-///////////////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////////////
-// Uncomment to prevent child processes from inheriting log file descriptors
-//
-// #define SPDLOG_PREVENT_CHILD_FD
-///////////////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////////////
-// Uncomment to mark some types as final, allowing more optimizations in release
-// mode with recent compilers. See GCC's documentation for -Wsuggest-final-types
-// for instance.
-//
-// #define SPDLOG_FINAL final
-///////////////////////////////////////////////////////////////////////////////
-
-
-///////////////////////////////////////////////////////////////////////////////
-// Uncomment to enable message counting feature. Adds %i logger pattern that
-// prints log message sequence id.
-//
-// #define SPDLOG_ENABLE_MESSAGE_COUNTER
-///////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////
-// Uncomment to enable user defined tag names
-//
-// #define SPDLOG_LEVEL_NAMES  { "   TRACE", "   DEBUG", "    INFO",
-// " WARNING", "   ERROR", "CRITICAL", "OFF" };
-///////////////////////////////////////////////////////////////////////////////
\ No newline at end of file