From 4a90950fe55fe53c6168b676c42a774b800ea90b Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Thu, 5 Jul 2018 16:19:23 +0300
Subject: [PATCH 01/50] updated bench

---
 bench/bench.cpp | 27 ++++++++++++++++-----------
 1 file changed, 16 insertions(+), 11 deletions(-)

diff --git a/bench/bench.cpp b/bench/bench.cpp
index fe03fb20..68cdd9be 100644
--- a/bench/bench.cpp
+++ b/bench/bench.cpp
@@ -52,16 +52,24 @@ int main(int argc, char *argv[])
         cout << "Single thread, " << format(howmany) << " iterations" << endl;
         cout << "*******************************************************************************\n";
 
+        auto basic_st = spdlog::basic_logger_mt("basic_st", "logs/basic_st.log", true);
+        bench(howmany, basic_st);
+
         auto rotating_st = spdlog::rotating_logger_st("rotating_st", "logs/rotating_st.log", file_size, rotating_files);
         bench(howmany, rotating_st);
+
         auto daily_st = spdlog::daily_logger_st("daily_st", "logs/daily_st.log");
         bench(howmany, daily_st);
+
         bench(howmany, spdlog::create<null_sink_st>("null_st"));
 
         cout << "\n*******************************************************************************\n";
         cout << threads << " threads sharing same logger, " << format(howmany) << " iterations" << endl;
         cout << "*******************************************************************************\n";
 
+        auto basic_mt = spdlog::basic_logger_mt("basic_mt", "logs/basic_mt.log", true);
+        bench_mt(howmany, basic_mt, threads);
+
         auto rotating_mt = spdlog::rotating_logger_mt("rotating_mt", "logs/rotating_mt.log", file_size, rotating_files);
         bench_mt(howmany, rotating_mt, threads);
 
@@ -92,34 +100,31 @@ int main(int argc, char *argv[])
 
 void bench(int howmany, std::shared_ptr<spdlog::logger> log)
 {
+    using std::chrono::high_resolution_clock;
     cout << log->name() << "...\t\t" << flush;
-    auto start = system_clock::now();
+    auto start = high_resolution_clock::now();
     for (auto i = 0; i < howmany; ++i)
     {
         log->info("Hello logger: msg number {}", i);
     }
 
-    auto delta = system_clock::now() - start;
+    auto delta = high_resolution_clock::now() - start;
     auto delta_d = duration_cast<duration<double>>(delta).count();
     cout << "Elapsed: " << delta_d << "\t" << format(int(howmany / delta_d)) << "/sec" << endl;
 }
 
 void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count)
 {
-
+    using std::chrono::high_resolution_clock;
     cout << log->name() << "...\t\t" << flush;
-    std::atomic<int> msg_counter{0};
     vector<thread> threads;
-    auto start = system_clock::now();
+    auto start = high_resolution_clock::now();
     for (int t = 0; t < thread_count; ++t)
     {
         threads.push_back(std::thread([&]() {
-            for (;;)
+            for (int j = 0; j < howmany/thread_count; j++)
             {
-                int counter = ++msg_counter;
-                if (counter > howmany)
-                    break;
-                log->info("Hello logger: msg number {}", counter);
+                log->info("Hello logger: msg number {}", j);
             }
         }));
     }
@@ -129,7 +134,7 @@ void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count
         t.join();
     };
 
-    auto delta = system_clock::now() - start;
+        auto delta = high_resolution_clock::now() - start;
     auto delta_d = duration_cast<duration<double>>(delta).count();
     cout << "Elapsed: " << delta_d << "\t" << format(int(howmany / delta_d)) << "/sec" << endl;
 }

From bd759bfca7148a5f93d4161bc61a1878731f6259 Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Thu, 5 Jul 2018 16:34:20 +0300
Subject: [PATCH 02/50] removed force_flush from simple logger

---
 include/spdlog/sinks/simple_file_sink.h | 11 +----------
 1 file changed, 1 insertion(+), 10 deletions(-)

diff --git a/include/spdlog/sinks/simple_file_sink.h b/include/spdlog/sinks/simple_file_sink.h
index 5af863dc..f9e68b95 100644
--- a/include/spdlog/sinks/simple_file_sink.h
+++ b/include/spdlog/sinks/simple_file_sink.h
@@ -22,24 +22,16 @@ 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 &, const fmt::memory_buffer &formatted) override
     {
         file_helper_.write(formatted);
-        if (force_flush_)
-        {
-            file_helper_.flush();
-        }
     }
 
     void flush_() override
@@ -49,7 +41,6 @@ protected:
 
 private:
     details::file_helper file_helper_;
-    bool force_flush_;
 };
 
 using simple_file_sink_mt = simple_file_sink<std::mutex>;

From 69c11ea7d2a0e61cb912a4763611502697b69501 Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Thu, 5 Jul 2018 16:35:07 +0300
Subject: [PATCH 03/50] Updated bench

---
 bench/Makefile              |  11 ++--
 bench/bench.cpp             |   2 +-
 bench/spdlog-null-async.cpp | 116 ------------------------------------
 3 files changed, 5 insertions(+), 124 deletions(-)
 delete mode 100644 bench/spdlog-null-async.cpp

diff --git a/bench/Makefile b/bench/Makefile
index 24a4d7b0..98fcccb7 100644
--- a/bench/Makefile
+++ b/bench/Makefile
@@ -1,18 +1,15 @@
-CXX	?= g++
+CXX	= g++
 CXXFLAGS	= -march=native -Wall -Wextra -pedantic -std=c++11 -pthread -I../include
-CXX_RELEASE_FLAGS = -O3 -flto -DNDEBUG
+CXX_RELEASE_FLAGS = -O3 -flto
 
 
-binaries=bench spdlog-null-async
+binaries=bench
 
 all: $(binaries)
 
 bench: bench.cpp
 	$(CXX) bench.cpp -o bench $(CXXFLAGS) $(CXX_RELEASE_FLAGS)
-	
-spdlog-null-async: spdlog-null-async.cpp
-	$(CXX) spdlog-null-async.cpp -o spdlog-null-async $(CXXFLAGS) $(CXX_RELEASE_FLAGS)
-			
+				
 
 .PHONY: clean
 
diff --git a/bench/bench.cpp b/bench/bench.cpp
index 68cdd9be..52e2ffaf 100644
--- a/bench/bench.cpp
+++ b/bench/bench.cpp
@@ -32,7 +32,7 @@ void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count
 int main(int argc, char *argv[])
 {
 
-    int queue_size = 1048576;
+    int queue_size = 1000000;
     int howmany = 1000000;
     int threads = 10;
     int file_size = 30 * 1024 * 1024;
diff --git a/bench/spdlog-null-async.cpp b/bench/spdlog-null-async.cpp
deleted file mode 100644
index ee64eb92..00000000
--- a/bench/spdlog-null-async.cpp
+++ /dev/null
@@ -1,116 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-//
-// bench.cpp : spdlog benchmarks
-//
-#include "spdlog/async.h"
-#include "spdlog/async_logger.h"
-#include "spdlog/sinks/null_sink.h"
-#include "spdlog/spdlog.h"
-#include "utils.h"
-#include <atomic>
-#include <cstdlib> // EXIT_FAILURE
-#include <iostream>
-#include <memory>
-#include <string>
-#include <thread>
-
-using namespace std;
-using namespace std::chrono;
-using namespace spdlog;
-using namespace spdlog::sinks;
-using namespace utils;
-
-size_t bench_as(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count);
-
-int main(int argc, char *argv[])
-{
-
-    int howmany;
-    int tp_queue_size;
-    int tp_threads = 1;
-    int client_threads = 10;
-    int iters = 10;
-
-    try
-    {
-        if (argc < 2)
-        {
-            cout << "Usage: " << argv[0] << " <howmany> [client_threads] [q_size] [tp_threads]" << endl;
-            return (1);
-        }
-
-        howmany = atoi(argv[1]);
-        if (argc > 2)
-            client_threads = atoi(argv[2]);
-
-        if (argc > 3)
-            tp_queue_size = atoi(argv[3]);
-        else
-            tp_queue_size = howmany;
-
-        if (argc > 4)
-            tp_threads = atoi(argv[4]);
-
-        cout << "\n*******************************************************************************\n";
-        cout << "messages:\t" << format(howmany) << endl;
-        cout << "client_threads:\t" << client_threads << endl;
-        cout << "tp queue:\t" << format(tp_queue_size) << endl;
-        cout << "tp threads:\t" << tp_threads << endl;
-        cout << "*******************************************************************************\n";
-
-        size_t total_rate = 0;
-
-        for (int i = 0; i < iters; ++i)
-        {
-            spdlog::init_thread_pool(tp_queue_size, tp_threads);
-            auto as = spdlog::create_async_logger<null_sink_mt>("async(null-sink)");
-            total_rate += bench_as(howmany, as, client_threads);
-            spdlog::drop("async(null-sink)");
-        }
-        std::cout << endl;
-        std::cout << "Avg rate: " << format(total_rate / iters) << "/sec" << std::endl;
-    }
-    catch (std::exception &ex)
-    {
-        std::cerr << "Error: " << ex.what() << std::endl;
-        perror("Last error");
-        return EXIT_FAILURE;
-    }
-    return EXIT_SUCCESS;
-}
-
-// return rate/sec
-size_t bench_as(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count)
-{
-    cout << log->name() << "...\t\t" << flush;
-    std::atomic<int> msg_counter{0};
-    vector<thread> threads;
-    auto start = system_clock::now();
-    for (int t = 0; t < thread_count; ++t)
-    {
-        threads.push_back(std::thread([&]() {
-            for (;;)
-            {
-                int counter = ++msg_counter;
-                if (counter > howmany)
-                    break;
-                log->info("Hello logger: msg number {}", counter);
-            }
-        }));
-    }
-
-    for (auto &t : threads)
-    {
-        t.join();
-    }
-
-    auto delta = system_clock::now() - start;
-    auto delta_d = duration_cast<duration<double>>(delta).count();
-    auto per_sec = size_t(howmany / delta_d);
-    cout << format(per_sec) << "/sec" << endl;
-    return per_sec;
-}

From 3ebdb2fd8bb4482a2e8958e0511d2e4fbcb9dc8d Mon Sep 17 00:00:00 2001
From: Gabi Melman <gmelman1@gmail.com>
Date: Fri, 6 Jul 2018 08:40:55 +0300
Subject: [PATCH 04/50] Update logger.h

---
 include/spdlog/logger.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/spdlog/logger.h b/include/spdlog/logger.h
index 4fd88ff0..f67a07ff 100644
--- a/include/spdlog/logger.h
+++ b/include/spdlog/logger.h
@@ -119,8 +119,8 @@ public:
     // each sink gets itw own private copy of a formatter object.
     void set_pattern(const std::string &pattern, pattern_time_type pattern_time = pattern_time_type::local);
 
-    // create a FormatterT formatter all the sinks in this logger.
-    // each sink gets itw own private copy of a formatter object.
+    // create a FormatterT formatter for each sink in this logger.
+    // each sink gets its own private copy of a formatter object.
     template<class FormatterT, typename... Args>
     void set_formatter(const Args &... args);
 

From cd4dcbab36ad47fcfe6a58424c127ae1ccf14458 Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Sat, 7 Jul 2018 12:12:45 +0300
Subject: [PATCH 05/50] Renamed simple_file_sink -> basic_file_sink

---
 bench/bench.cpp                               |  4 +--
 bench/spdlog-async.cpp                        |  4 +--
 example/example.cpp                           | 14 +++++++---
 example/multisink.cpp                         |  4 +--
 include/spdlog/async.h                        |  6 ++--
 include/spdlog/sinks/base_sink.h              | 14 ++--------
 .../{simple_file_sink.h => basic_file_sink.h} | 12 ++++----
 include/spdlog/sinks/sink.h                   | 28 +++++++++----------
 include/spdlog/spdlog.h                       |  4 +--
 tests/errors.cpp                              |  8 +++---
 tests/file_log.cpp                            |  4 +--
 tests/includes.h                              |  2 +-
 tests/test_async.cpp                          |  6 ++--
 tests/test_macros.cpp                         |  5 ++--
 14 files changed, 54 insertions(+), 61 deletions(-)
 rename include/spdlog/sinks/{simple_file_sink.h => basic_file_sink.h} (72%)

diff --git a/bench/bench.cpp b/bench/bench.cpp
index 52e2ffaf..b1275f20 100644
--- a/bench/bench.cpp
+++ b/bench/bench.cpp
@@ -10,7 +10,7 @@
 #include "spdlog/sinks/daily_file_sink.h"
 #include "spdlog/sinks/null_sink.h"
 #include "spdlog/sinks/rotating_file_sink.h"
-#include "spdlog/sinks/simple_file_sink.h"
+#include "spdlog/sinks/basic_file_sink.h"
 #include "spdlog/spdlog.h"
 #include "utils.h"
 #include <atomic>
@@ -84,7 +84,7 @@ int main(int argc, char *argv[])
         for (int i = 0; i < 3; ++i)
         {
             spdlog::init_thread_pool(queue_size, 1);
-            auto as = spdlog::basic_logger_mt<spdlog::create_async>("as", "logs/basic_async.log", true);
+            auto as = spdlog::basic_logger_mt<spdlog::async_factory>("as", "logs/basic_async.log", true);
             bench_mt(howmany, as, threads);
             spdlog::drop("as");
         }
diff --git a/bench/spdlog-async.cpp b/bench/spdlog-async.cpp
index 9f2f75b9..fc4a61fe 100644
--- a/bench/spdlog-async.cpp
+++ b/bench/spdlog-async.cpp
@@ -11,7 +11,7 @@
 #include <vector>
 
 #include "spdlog/async.h"
-#include "spdlog/sinks/simple_file_sink.h"
+#include "spdlog/sinks/basic_file_sink.h"
 
 using namespace std;
 
@@ -27,7 +27,7 @@ int main(int argc, char *argv[])
     int howmany = 1000000;
     spdlog::init_thread_pool(howmany, 1);
 
-    auto logger = spdlog::create_async_logger<spdlog::sinks::simple_file_sink_mt>("file_logger", "logs/spdlog-bench-async.log", false);
+    auto logger = spdlog::create_async_logger<spdlog::sinks::basic_file_sink_mt>("file_logger", "logs/spdlog-bench-async.log", false);
     logger->set_pattern("[%Y-%m-%d %T.%F]: %L %t %v");
 
     std::cout << "To stop, press <Enter>" << std::endl;
diff --git a/example/example.cpp b/example/example.cpp
index e491518a..765dc121 100644
--- a/example/example.cpp
+++ b/example/example.cpp
@@ -12,7 +12,7 @@
 
 #include "spdlog/sinks/daily_file_sink.h"
 #include "spdlog/sinks/rotating_file_sink.h"
-#include "spdlog/sinks/simple_file_sink.h"
+#include "spdlog/sinks/basic_file_sink.h"
 #include "spdlog/sinks/stdout_color_sinks.h"
 
 #include <iostream>
@@ -29,6 +29,7 @@ int main(int, char *[])
 
     try
     {
+        spd::set_pattern("TEST PATTERN %v");
         auto console = spdlog::stdout_color_st("console");
         console->info("Welcome to spdlog!");
 
@@ -107,10 +108,15 @@ int main(int, char *[])
 #include "spdlog/async.h"
 void async_example()
 {
-    auto async_file = spd::basic_logger_mt<spdlog::create_async>("async_file_logger", "logs/async_log.txt");
-
-    // thread pool settings can be modified *before* creating the async logger:
+    // default thread pool settings can be modified *before* creating the async logger:
+    // spdlog::init_thread_pool(32768, 1); // queue with max 32k items 1 backing thread.
     // spdlog::init_thread_pool(32768, 4); // queue with max 32k items 4 backing threads.
+
+    auto async_file = spd::basic_logger_mt<spdlog::async_factory>("async_file_logger", "logs/async_log.txt");
+
+    // alternatively:
+    // auto async_file = spd::create_async<spd::sinks::basic_file_sink_mt>("async_file_logger", "logs/async_log.txt");
+
     for (int i = 0; i < 100; ++i)
     {
         async_file->info("Async message #{}", i + 1);
diff --git a/example/multisink.cpp b/example/multisink.cpp
index 98b86ce2..4b3f2d9c 100644
--- a/example/multisink.cpp
+++ b/example/multisink.cpp
@@ -15,8 +15,8 @@ int main(int, char *[])
         // Each sink can have it's own log level and a message will be logged.
         std::vector<spdlog::sink_ptr> sinks;
         sinks.push_back(std::make_shared<spdlog::sinks::stdout_sink_mt>());
-        sinks.push_back(std::make_shared<spdlog::sinks::simple_file_sink_mt>("./log_regular_file.txt"));
-        sinks.push_back(std::make_shared<spdlog::sinks::simple_file_sink_mt>("./log_debug_file.txt"));
+        sinks.push_back(std::make_shared<spdlog::sinks::basic_file_sink_mt>("./log_regular_file.txt"));
+        sinks.push_back(std::make_shared<spdlog::sinks::basic_file_sink_mt>("./log_debug_file.txt"));
 
         spdlog::logger console_multisink("multisink", sinks.begin(), sinks.end());
         console_multisink.set_level(spdlog::level::warn);
diff --git a/include/spdlog/async.h b/include/spdlog/async.h
index a0ede2ad..2e13f3b3 100644
--- a/include/spdlog/async.h
+++ b/include/spdlog/async.h
@@ -23,7 +23,7 @@ namespace spdlog {
 
 // async logger factory - creates async loggers backed with thread pool.
 // if a global thread pool doesn't already exist, create it with default queue size of 8192 items and single thread.
-struct create_async
+struct async_factory
 {
     template<typename Sink, typename... SinkArgs>
     static std::shared_ptr<async_logger> create(const std::string &logger_name, SinkArgs &&... args)
@@ -46,9 +46,9 @@ struct create_async
 };
 
 template<typename Sink, typename... SinkArgs>
-inline std::shared_ptr<spdlog::logger> create_async_logger(const std::string &logger_name, SinkArgs &&... sink_args)
+inline std::shared_ptr<spdlog::logger> create_async(const std::string &logger_name, SinkArgs &&... sink_args)
 {
-    return create_async::create<Sink>(logger_name, std::forward<SinkArgs>(sink_args)...);
+    return async_factory::create<Sink>(logger_name, std::forward<SinkArgs>(sink_args)...);
 }
 
 // set global thread pool.
diff --git a/include/spdlog/sinks/base_sink.h b/include/spdlog/sinks/base_sink.h
index 871f2b81..292a3261 100644
--- a/include/spdlog/sinks/base_sink.h
+++ b/include/spdlog/sinks/base_sink.h
@@ -6,8 +6,8 @@
 #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..
+// concrete implementation should override the sink_it_() and flush_()  methods.
+// locking is taken care of in this class - no locking needed by the implementers..
 //
 
 #include "spdlog/common.h"
@@ -26,16 +26,6 @@ public:
     {
     }
 
-    base_sink(const std::string &formatter_pattern)
-        : sink(formatter_pattern)
-    {
-    }
-
-    base_sink(std::unique_ptr<spdlog::formatter> sink_formatter)
-        : sink(std::move(sink_formatter))
-    {
-    }
-
     base_sink(const base_sink &) = delete;
     base_sink &operator=(const base_sink &) = delete;
 
diff --git a/include/spdlog/sinks/simple_file_sink.h b/include/spdlog/sinks/basic_file_sink.h
similarity index 72%
rename from include/spdlog/sinks/simple_file_sink.h
rename to include/spdlog/sinks/basic_file_sink.h
index f9e68b95..59795401 100644
--- a/include/spdlog/sinks/simple_file_sink.h
+++ b/include/spdlog/sinks/basic_file_sink.h
@@ -18,10 +18,10 @@ namespace sinks {
  * Trivial file sink with single file as target
  */
 template<class Mutex>
-class simple_file_sink SPDLOG_FINAL : public base_sink<Mutex>
+class basic_file_sink SPDLOG_FINAL : public base_sink<Mutex>
 {
 public:
-    explicit simple_file_sink(const filename_t &filename, bool truncate = false)
+    explicit basic_file_sink(const filename_t &filename, bool truncate = false)
     {
         file_helper_.open(filename, truncate);
     }
@@ -43,8 +43,8 @@ private:
     details::file_helper file_helper_;
 };
 
-using simple_file_sink_mt = simple_file_sink<std::mutex>;
-using simple_file_sink_st = simple_file_sink<details::null_mutex>;
+using basic_file_sink_mt = basic_file_sink<std::mutex>;
+using basic_file_sink_st = basic_file_sink<details::null_mutex>;
 
 } // namespace sinks
 
@@ -54,13 +54,13 @@ using simple_file_sink_st = simple_file_sink<details::null_mutex>;
 template<typename Factory = default_factory>
 inline std::shared_ptr<logger> basic_logger_mt(const std::string &logger_name, const filename_t &filename, bool truncate = false)
 {
-    return Factory::template create<sinks::simple_file_sink_mt>(logger_name, filename, truncate);
+    return Factory::template create<sinks::basic_file_sink_mt>(logger_name, filename, truncate);
 }
 
 template<typename Factory = default_factory>
 inline std::shared_ptr<logger> basic_logger_st(const std::string &logger_name, const filename_t &filename, bool truncate = false)
 {
-    return Factory::template create<sinks::simple_file_sink_st>(logger_name, filename, truncate);
+    return Factory::template create<sinks::basic_file_sink_st>(logger_name, filename, truncate);
 }
 
 } // namespace spdlog
diff --git a/include/spdlog/sinks/sink.h b/include/spdlog/sinks/sink.h
index 513e0661..9f661908 100644
--- a/include/spdlog/sinks/sink.h
+++ b/include/spdlog/sinks/sink.h
@@ -18,17 +18,17 @@ public:
         : formatter_(std::unique_ptr<spdlog::formatter>(new pattern_formatter("%+")))
     {
     }
-
-    explicit sink(const std::string &formatter_pattern)
-        : formatter_(std::unique_ptr<spdlog::formatter>(new pattern_formatter(formatter_pattern)))
-    {
-    }
-
-    // sink with custom formatter
-    explicit sink(std::unique_ptr<spdlog::formatter> sink_formatter)
-        : formatter_(std::move(sink_formatter))
-    {
-    }
+//
+//    explicit sink(const std::string &formatter_pattern)
+//        : formatter_(std::unique_ptr<spdlog::formatter>(new pattern_formatter(formatter_pattern)))
+//    {
+//    }
+//
+//    // sink with custom formatter
+//    explicit sink(std::unique_ptr<spdlog::formatter> sink_formatter)
+//        : formatter_(std::move(sink_formatter))
+//    {
+//    }
 
     virtual ~sink() = default;
 
@@ -39,10 +39,12 @@ public:
     {
         return msg_level >= level_.load(std::memory_order_relaxed);
     }
+
     void set_level(level::level_enum log_level)
     {
         level_.store(log_level);
     }
+
     level::level_enum level() const
     {
         return static_cast<spdlog::level::level_enum>(level_.load(std::memory_order_relaxed));
@@ -58,10 +60,6 @@ public:
         formatter_ = std::move(sink_formatter);
     }
 
-    spdlog::formatter *formatter()
-    {
-        return formatter_.get();
-    }
 
 protected:
     level_t level_{level::trace};
diff --git a/include/spdlog/spdlog.h b/include/spdlog/spdlog.h
index b51578fa..53c56a30 100644
--- a/include/spdlog/spdlog.h
+++ b/include/spdlog/spdlog.h
@@ -19,7 +19,7 @@
 namespace spdlog {
 
 // Default logger factory-  creates synchronous loggers
-struct create_synchronous
+struct synchronous_factory
 {
     template<typename Sink, typename... SinkArgs>
 
@@ -32,7 +32,7 @@ struct create_synchronous
     }
 };
 
-using default_factory = create_synchronous;
+using default_factory = synchronous_factory;
 
 // Create and register a logger with a templated sink type
 // The logger's level, formatter and flush level will be set according the global settings.
diff --git a/tests/errors.cpp b/tests/errors.cpp
index c3ccbe2f..1320b748 100644
--- a/tests/errors.cpp
+++ b/tests/errors.cpp
@@ -24,7 +24,7 @@ TEST_CASE("default_error_handler", "[errors]]")
     prepare_logdir();
     std::string filename = "logs/simple_log.txt";
 
-    auto logger = spdlog::create<spdlog::sinks::simple_file_sink_mt>("test-error", filename, true);
+    auto logger = spdlog::create<spdlog::sinks::basic_file_sink_mt>("test-error", filename, true);
     logger->set_pattern("%v");
     logger->info("Test message {} {}", 1);
     logger->info("Test message {}", 2);
@@ -41,7 +41,7 @@ TEST_CASE("custom_error_handler", "[errors]]")
 {
     prepare_logdir();
     std::string filename = "logs/simple_log.txt";
-    auto logger = spdlog::create<spdlog::sinks::simple_file_sink_mt>("logger", filename, true);
+    auto logger = spdlog::create<spdlog::sinks::basic_file_sink_mt>("logger", filename, true);
     logger->flush_on(spdlog::level::info);
     logger->set_error_handler([=](const std::string &) { throw custom_ex(); });
     logger->info("Good message #1");
@@ -75,7 +75,7 @@ TEST_CASE("async_error_handler", "[errors]]")
     std::string filename = "logs/simple_async_log.txt";
     {
         spdlog::init_thread_pool(128, 1);
-        auto logger = spdlog::create_async_logger<spdlog::sinks::simple_file_sink_mt>("logger", filename, true);
+        auto logger = spdlog::create_async<spdlog::sinks::basic_file_sink_mt>("logger", filename, true);
         logger->set_error_handler([=](const std::string &) {
             std::ofstream ofs("logs/custom_err.txt");
             if (!ofs)
@@ -99,7 +99,7 @@ TEST_CASE("async_error_handler2", "[errors]]")
     std::string err_msg("This is async handler error message");
     {
         spdlog::init_thread_pool(128, 1);
-        auto logger = spdlog::create_async_logger<failing_sink>("failed_logger");
+        auto logger = spdlog::create_async<failing_sink>("failed_logger");
         logger->set_error_handler([=](const std::string &) {
             std::ofstream ofs("logs/custom_err2.txt");
             if (!ofs)
diff --git a/tests/file_log.cpp b/tests/file_log.cpp
index 9cef256d..55240b78 100644
--- a/tests/file_log.cpp
+++ b/tests/file_log.cpp
@@ -8,7 +8,7 @@ TEST_CASE("simple_file_logger", "[simple_logger]]")
     prepare_logdir();
     std::string filename = "logs/simple_log";
 
-    auto logger = spdlog::create<spdlog::sinks::simple_file_sink_mt>("logger", filename);
+    auto logger = spdlog::create<spdlog::sinks::basic_file_sink_mt>("logger", filename);
     logger->set_pattern("%v");
 
     logger->info("Test message {}", 1);
@@ -24,7 +24,7 @@ TEST_CASE("flush_on", "[flush_on]]")
     prepare_logdir();
     std::string filename = "logs/simple_log";
 
-    auto logger = spdlog::create<spdlog::sinks::simple_file_sink_mt>("logger", filename);
+    auto logger = spdlog::create<spdlog::sinks::basic_file_sink_mt>("logger", filename);
     logger->set_pattern("%v");
     logger->set_level(spdlog::level::trace);
     logger->flush_on(spdlog::level::info);
diff --git a/tests/includes.h b/tests/includes.h
index 10bfb062..6a61bc06 100644
--- a/tests/includes.h
+++ b/tests/includes.h
@@ -17,6 +17,6 @@
 #include "spdlog/sinks/null_sink.h"
 #include "spdlog/sinks/ostream_sink.h"
 #include "spdlog/sinks/rotating_file_sink.h"
-#include "spdlog/sinks/simple_file_sink.h"
+#include "spdlog/sinks/basic_file_sink.h"
 #include "spdlog/sinks/stdout_color_sinks.h"
 #include "spdlog/spdlog.h"
diff --git a/tests/test_async.cpp b/tests/test_async.cpp
index 7ade2676..fd53504a 100644
--- a/tests/test_async.cpp
+++ b/tests/test_async.cpp
@@ -1,6 +1,6 @@
 #include "includes.h"
 #include "spdlog/async.h"
-#include "spdlog/sinks/simple_file_sink.h"
+#include "spdlog/sinks/basic_file_sink.h"
 #include "test_sink.h"
 
 TEST_CASE("basic async test ", "[async]")
@@ -121,7 +121,7 @@ TEST_CASE("to_file", "[async]")
     size_t tp_threads = 1;
     std::string filename = "logs/async_test.log";
     {
-        auto file_sink = std::make_shared<spdlog::sinks::simple_file_sink_mt>(filename, true);
+        auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(filename, true);
         auto tp = std::make_shared<spdlog::details::thread_pool>(messages, tp_threads);
         auto logger = std::make_shared<spdlog::async_logger>("as", std::move(file_sink), std::move(tp));
 
@@ -143,7 +143,7 @@ TEST_CASE("to_file multi-workers", "[async]")
     size_t tp_threads = 10;
     std::string filename = "logs/async_test.log";
     {
-        auto file_sink = std::make_shared<spdlog::sinks::simple_file_sink_mt>(filename, true);
+        auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(filename, true);
         auto tp = std::make_shared<spdlog::details::thread_pool>(messages, tp_threads);
         auto logger = std::make_shared<spdlog::async_logger>("as", std::move(file_sink), std::move(tp));
 
diff --git a/tests/test_macros.cpp b/tests/test_macros.cpp
index 2d165aae..0b3e0b7d 100644
--- a/tests/test_macros.cpp
+++ b/tests/test_macros.cpp
@@ -9,12 +9,11 @@ TEST_CASE("debug and trace w/o format string", "[macros]]")
     prepare_logdir();
     std::string filename = "logs/simple_log";
 
-    auto logger = spdlog::create<spdlog::sinks::simple_file_sink_mt>("logger", filename);
+    auto logger = spdlog::create<spdlog::sinks::basic_file_sink_mt>("logger", filename);
     logger->set_pattern("%v");
     logger->set_level(spdlog::level::trace);
 
     SPDLOG_TRACE(logger, "Test message 1");
-    // SPDLOG_DEBUG(logger, "Test message 2");
     SPDLOG_DEBUG(logger, "Test message 2");
     logger->flush();
 
@@ -27,7 +26,7 @@ TEST_CASE("debug and trace with format strings", "[macros]]")
     prepare_logdir();
     std::string filename = "logs/simple_log";
 
-    auto logger = spdlog::create<spdlog::sinks::simple_file_sink_mt>("logger", filename);
+    auto logger = spdlog::create<spdlog::sinks::basic_file_sink_mt>("logger", filename);
     logger->set_pattern("%v");
     logger->set_level(spdlog::level::trace);
 

From b0bf4575383fe9e1843fbb3f1fccd4bab1f6cabe Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Sat, 7 Jul 2018 12:37:17 +0300
Subject: [PATCH 06/50] updated example

---
 example/example.cpp | 152 +++++++++++++++++++++++++-------------------
 1 file changed, 86 insertions(+), 66 deletions(-)

diff --git a/example/example.cpp b/example/example.cpp
index 765dc121..4cfe164c 100644
--- a/example/example.cpp
+++ b/example/example.cpp
@@ -11,13 +11,16 @@
 #define SPDLOG_DEBUG_ON
 
 #include "spdlog/sinks/daily_file_sink.h"
-#include "spdlog/sinks/rotating_file_sink.h"
-#include "spdlog/sinks/basic_file_sink.h"
+
 #include "spdlog/sinks/stdout_color_sinks.h"
 
 #include <iostream>
 #include <memory>
 
+
+void basic_example();
+void rotating_example();
+void daily_example();
 void async_example();
 void user_defined_example();
 void err_handler_example();
@@ -29,13 +32,10 @@ int main(int, char *[])
 
     try
     {
-        spd::set_pattern("TEST PATTERN %v");
-        auto console = spdlog::stdout_color_st("console");
-        console->info("Welcome to spdlog!");
-
+        auto console = spdlog::stdout_color_mt("console");
         console->info("Welcome to spdlog!");
         console->error("Some error message with arg: {}", 1);
-        err_handler_example();
+
         // Formatting examples
         console->warn("Easy padding in numbers like {:08d}", 12);
         console->critical("Support for int: {0:d};  hex: {0:x};  oct: {0:o}; bin: {0:b}", 42);
@@ -43,33 +43,7 @@ int main(int, char *[])
         console->info("Positional args are {1} {0}..", "too", "supported");
         console->info("{:<30}", "left aligned");
 
-        spd::get("console")->info("loggers can be retrieved from a global registry using the spdlog::get(logger_name) function");
-
-        // Create basic file logger (not rotated)
-        auto my_logger = spd::basic_logger_mt("basic_logger", "logs/basic-log.txt");
-        my_logger->info("Some log message");
-
-        // Create a file rotating logger with 5mb size max and 3 rotated files
-        auto rotating_logger = spd::rotating_logger_mt("some_logger_name", "logs/rotating.txt", 1048576 * 5, 3);
-        for (int i = 0; i < 10; ++i)
-        {
-            rotating_logger->info("{} * {} equals {:>10}", i, i, i * i);
-        }
-
-        // Create a daily logger - a new file is created every day on 2:30am
-        auto daily_logger = spd::daily_logger_mt("daily_logger", "logs/daily.txt", 2, 30);
-        // trigger flush if the log severity is error or higher
-        daily_logger->flush_on(spd::level::err);
-        daily_logger->info(123.44);
-
-        // Customize msg format for all messages
-        spd::set_pattern("[%^+++%$] [%H:%M:%S %z] [thread %t] %v");
-
-        console->info("This an info message with custom format");
-        console->error("This an error message with custom format");
-
-        // Change format back to to default
-        spd::set_pattern("%+");
+        spd::get("console")->info("loggers can be retrieved from a global registry using the spdlog::get(logger_name)");
 
         // Runtime log levels
         spd::set_level(spd::level::info); // Set global log level to info
@@ -77,20 +51,34 @@ int main(int, char *[])
         console->set_level(spd::level::trace); // Set specific logger's log level
         console->debug("This message should be displayed..");
 
+
+        // Customize msg format for all loggers
+        spd::set_pattern("[%H:%M:%S %z] [%^---%L---%$] [thread %t] %v");
+        console->info("This an info message with custom format");
+
+
+
         // Compile time log levels
         // define SPDLOG_DEBUG_ON or SPDLOG_TRACE_ON
         SPDLOG_TRACE(console, "Enabled only #ifdef SPDLOG_TRACE_ON..{} ,{}", 1, 3.23);
         SPDLOG_DEBUG(console, "Enabled only #ifdef SPDLOG_DEBUG_ON.. {} ,{}", 1, 3.23);
 
-        // Asynchronous logging example
+        // various file loggers
+        basic_example();
+        rotating_example();
+        daily_example();
+
+        // async logging using a backing thread pool
         async_example();
 
-        // Log user-defined types example
+        // user defined types logging by implementing operator<<
         user_defined_example();
 
-        // Change default log error handler
+        // custom  error handler
         err_handler_example();
 
+
+
         // Apply a function on all registered loggers
         spd::apply_all([&](std::shared_ptr<spdlog::logger> l) { l->info("End of example."); });
 
@@ -104,7 +92,35 @@ int main(int, char *[])
         return 1;
     }
 }
-// must be included to use async logger
+
+
+#include "spdlog/sinks/basic_file_sink.h"
+void basic_example()
+{
+    // Create basic file logger (not rotated)
+    auto my_logger = spd::basic_logger_mt("basic_logger", "logs/basic-log.txt");
+}
+
+#include "spdlog/sinks/rotating_file_sink.h"
+void rotating_example()
+{
+    // Create a file rotating logger with 5mb size max and 3 rotated files
+    auto rotating_logger = spd::rotating_logger_mt("some_logger_name", "logs/rotating.txt", 1048576 * 5, 3);
+}
+
+#include "spdlog/sinks/daily_file_sink.h"
+void daily_example()
+{
+    // Create a daily logger - a new file is created every day on 2:30am
+    auto daily_logger = spd::daily_logger_mt("daily_logger", "logs/daily.txt", 2, 30);
+
+}
+
+
+
+
+
+
 #include "spdlog/async.h"
 void async_example()
 {
@@ -123,6 +139,38 @@ void async_example()
     }
 }
 
+
+
+// user defined types logging by implementing operator<<
+#include "spdlog/fmt/ostr.h" // must be included
+struct my_type
+{
+    int i;
+    template<typename OStream>
+    friend OStream &operator<<(OStream &os, const my_type &c)
+    {
+        return os << "[my_type i=" << c.i << "]";
+    }
+};
+
+
+void user_defined_example()
+{
+    spd::get("console")->info("user defined type: {}", my_type{14});
+}
+
+//
+// custom error handler
+//
+void err_handler_example()
+{
+    // can be set globaly or per logger(logger->set_error_handler(..))
+    spdlog::set_error_handler([](const std::string &msg) { spd::get("console")->error("*******my err handler: {}", msg); });
+    spd::get("console")->info("some invalid message to trigger an error {}{}{}{}", 3);
+    // spd::get("console")->info("some invalid message to trigger an error {}{}{}{}", 3);
+}
+
+
 // syslog example (linux/osx/freebsd)
 #ifndef _WIN32
 #include "spdlog/sinks/syslog_sink.h"
@@ -145,31 +193,3 @@ void android_example()
 }
 
 #endif
-
-// user defined types logging by implementing operator<<
-struct my_type
-{
-    int i;
-    template<typename OStream>
-    friend OStream &operator<<(OStream &os, const my_type &c)
-    {
-        return os << "[my_type i=" << c.i << "]";
-    }
-};
-
-#include "spdlog/fmt/ostr.h" // must be included
-void user_defined_example()
-{
-    spd::get("console")->info("user defined type: {}", my_type{14});
-}
-
-//
-// custom error handler
-//
-void err_handler_example()
-{
-    // can be set globaly or per logger(logger->set_error_handler(..))
-    spdlog::set_error_handler([](const std::string &msg) { spd::get("console")->error("*******my err handler: {}", msg); });
-    spd::get("console")->info("some invalid message to trigger an error {}{}{}{}", 3);
-    // spd::get("console")->info("some invalid message to trigger an error {}{}{}{}", 3);
-}

From 72f4fae207f2125ba00d51516803d161afca476e Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Sat, 7 Jul 2018 12:53:56 +0300
Subject: [PATCH 07/50] updated example

---
 example/example.cpp | 127 +++++++++++++++++++++-----------------------
 1 file changed, 62 insertions(+), 65 deletions(-)

diff --git a/example/example.cpp b/example/example.cpp
index 4cfe164c..a9d8a7b0 100644
--- a/example/example.cpp
+++ b/example/example.cpp
@@ -7,17 +7,10 @@
 //
 //
 
-#define SPDLOG_TRACE_ON
-#define SPDLOG_DEBUG_ON
-
-#include "spdlog/sinks/daily_file_sink.h"
-
-#include "spdlog/sinks/stdout_color_sinks.h"
 
 #include <iostream>
-#include <memory>
-
 
+void stdout_example();
 void basic_example();
 void rotating_example();
 void daily_example();
@@ -26,42 +19,14 @@ void user_defined_example();
 void err_handler_example();
 void syslog_example();
 
-namespace spd = spdlog;
+#include "spdlog/spdlog.h"
+
 int main(int, char *[])
 {
-
     try
     {
-        auto console = spdlog::stdout_color_mt("console");
-        console->info("Welcome to spdlog!");
-        console->error("Some error message with arg: {}", 1);
-
-        // Formatting examples
-        console->warn("Easy padding in numbers like {:08d}", 12);
-        console->critical("Support for int: {0:d};  hex: {0:x};  oct: {0:o}; bin: {0:b}", 42);
-        console->info("Support for floats {:03.2f}", 1.23456);
-        console->info("Positional args are {1} {0}..", "too", "supported");
-        console->info("{:<30}", "left aligned");
-
-        spd::get("console")->info("loggers can be retrieved from a global registry using the spdlog::get(logger_name)");
-
-        // Runtime log levels
-        spd::set_level(spd::level::info); // Set global log level to info
-        console->debug("This message should not be displayed!");
-        console->set_level(spd::level::trace); // Set specific logger's log level
-        console->debug("This message should be displayed..");
-
-
-        // Customize msg format for all loggers
-        spd::set_pattern("[%H:%M:%S %z] [%^---%L---%$] [thread %t] %v");
-        console->info("This an info message with custom format");
-
-
-
-        // Compile time log levels
-        // define SPDLOG_DEBUG_ON or SPDLOG_TRACE_ON
-        SPDLOG_TRACE(console, "Enabled only #ifdef SPDLOG_TRACE_ON..{} ,{}", 1, 3.23);
-        SPDLOG_DEBUG(console, "Enabled only #ifdef SPDLOG_DEBUG_ON.. {} ,{}", 1, 3.23);
+        // console logging example
+        stdout_example();
 
         // various file loggers
         basic_example();
@@ -78,15 +43,14 @@ int main(int, char *[])
         err_handler_example();
 
 
-
-        // Apply a function on all registered loggers
-        spd::apply_all([&](std::shared_ptr<spdlog::logger> l) { l->info("End of example."); });
+        // apply some function on all registered loggers
+        spdlog::apply_all([&](std::shared_ptr<spdlog::logger> l) { l->info("End of example."); });
 
         // Release and close all loggers
         spdlog::drop_all();
     }
     // Exceptions will only be thrown upon failed logger or sink construction (not during logging)
-    catch (const spd::spdlog_ex &ex)
+    catch (const spdlog::spdlog_ex &ex)
     {
         std::cout << "Log init failed: " << ex.what() << std::endl;
         return 1;
@@ -94,48 +58,82 @@ int main(int, char *[])
 }
 
 
+#include "spdlog/sinks/stdout_color_sinks.h" // or "/sinks/stdout_sinks.h" if no colors needed
+
+void stdout_example()
+{
+    // create color multi threaded logger
+    auto console = spdlog::stdout_color_mt("console");
+    console->info("Welcome to spdlog!");
+    console->error("Some error message with arg: {}", 1);
+
+    auto err_logger = spdlog::stderr_color_mt("error_logger");
+    err_logger ->error("Some error message");
+    // Formatting examples
+    console->warn("Easy padding in numbers like {:08d}", 12);
+    console->critical("Support for int: {0:d};  hex: {0:x};  oct: {0:o}; bin: {0:b}", 42);
+    console->info("Support for floats {:03.2f}", 1.23456);
+    console->info("Positional args are {1} {0}..", "too", "supported");
+    console->info("{:<30}", "left aligned");
+
+    spdlog::get("console")->info("loggers can be retrieved from a global registry using the spdlog::get(logger_name)");
+
+    // Runtime log levels
+    spdlog::set_level(spdlog::level::info); // Set global log level to info
+    console->debug("This message should not be displayed!");
+    console->set_level(spdlog::level::trace); // Set specific logger's log level
+    console->debug("This message should be displayed..");
+
+
+    // Customize msg format for all loggers
+    spdlog::set_pattern("[%H:%M:%S %z] [%^---%L---%$] [thread %t] %v");
+    console->info("This an info message with custom format");
+
+
+
+    // Compile time log levels
+    // define SPDLOG_DEBUG_ON or SPDLOG_TRACE_ON
+    SPDLOG_TRACE(console, "Enabled only #ifdef SPDLOG_TRACE_ON..{} ,{}", 1, 3.23);
+    SPDLOG_DEBUG(console, "Enabled only #ifdef SPDLOG_DEBUG_ON.. {} ,{}", 1, 3.23);
+
+}
+
+
 #include "spdlog/sinks/basic_file_sink.h"
 void basic_example()
 {
     // Create basic file logger (not rotated)
-    auto my_logger = spd::basic_logger_mt("basic_logger", "logs/basic-log.txt");
+    auto my_logger = spdlog::basic_logger_mt("basic_logger", "logs/basic-log.txt");
 }
 
 #include "spdlog/sinks/rotating_file_sink.h"
 void rotating_example()
 {
     // Create a file rotating logger with 5mb size max and 3 rotated files
-    auto rotating_logger = spd::rotating_logger_mt("some_logger_name", "logs/rotating.txt", 1048576 * 5, 3);
+    auto rotating_logger = spdlog::rotating_logger_mt("some_logger_name", "logs/rotating.txt", 1048576 * 5, 3);
 }
 
 #include "spdlog/sinks/daily_file_sink.h"
 void daily_example()
 {
     // Create a daily logger - a new file is created every day on 2:30am
-    auto daily_logger = spd::daily_logger_mt("daily_logger", "logs/daily.txt", 2, 30);
+    auto daily_logger = spdlog::daily_logger_mt("daily_logger", "logs/daily.txt", 2, 30);
 
 }
 
 
-
-
-
-
 #include "spdlog/async.h"
 void async_example()
 {
     // default thread pool settings can be modified *before* creating the async logger:
     // spdlog::init_thread_pool(32768, 1); // queue with max 32k items 1 backing thread.
-    // spdlog::init_thread_pool(32768, 4); // queue with max 32k items 4 backing threads.
-
-    auto async_file = spd::basic_logger_mt<spdlog::async_factory>("async_file_logger", "logs/async_log.txt");
-
+    auto async_file = spdlog::basic_logger_mt<spdlog::async_factory>("async_file_logger", "logs/async_log.txt");
     // alternatively:
-    // auto async_file = spd::create_async<spd::sinks::basic_file_sink_mt>("async_file_logger", "logs/async_log.txt");
+    // auto async_file = spdlog::create_async<spdlog::sinks::basic_file_sink_mt>("async_file_logger", "logs/async_log.txt");
 
-    for (int i = 0; i < 100; ++i)
+    for (int i = 1; i < 101; ++i)
     {
-        async_file->info("Async message #{}", i + 1);
+        async_file->info("Async message #{}", i);
     }
 }
 
@@ -156,7 +154,7 @@ struct my_type
 
 void user_defined_example()
 {
-    spd::get("console")->info("user defined type: {}", my_type{14});
+    spdlog::get("console")->info("user defined type: {}", my_type{14});
 }
 
 //
@@ -164,10 +162,9 @@ void user_defined_example()
 //
 void err_handler_example()
 {
-    // can be set globaly or per logger(logger->set_error_handler(..))
-    spdlog::set_error_handler([](const std::string &msg) { spd::get("console")->error("*******my err handler: {}", msg); });
-    spd::get("console")->info("some invalid message to trigger an error {}{}{}{}", 3);
-    // spd::get("console")->info("some invalid message to trigger an error {}{}{}{}", 3);
+    // can be set globally or per logger(logger->set_error_handler(..))
+    spdlog::set_error_handler([](const std::string &msg) { spdlog::get("console")->error("*** LOGGER ERROR ***: {}", msg); });
+    spdlog::get("console")->info("some invalid message to trigger an error {}{}{}{}", 3);
 }
 
 
@@ -177,7 +174,7 @@ void err_handler_example()
 void syslog_example()
 {
     std::string ident = "spdlog-example";
-    auto syslog_logger = spd::syslog_logger("syslog", ident, LOG_PID);
+    auto syslog_logger = spdlog::syslog_logger("syslog", ident, LOG_PID);
     syslog_logger->warn("This is warning that will end up in syslog.");
 }
 #endif
@@ -188,7 +185,7 @@ void syslog_example()
 void android_example()
 {
     std::string tag = "spdlog-android";
-    auto android_logger = spd::android_logger("android", tag);
+    auto android_logger = spdlog::android_logger("android", tag);
     android_logger->critical("Use \"adb shell logcat\" to view this message.");
 }
 

From a9a7309001ec99b8d8607f24a4277650d6d45597 Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Sat, 7 Jul 2018 13:22:09 +0300
Subject: [PATCH 08/50] fixed dist_sink.h

---
 include/spdlog/sinks/dist_sink.h | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/include/spdlog/sinks/dist_sink.h b/include/spdlog/sinks/dist_sink.h
index 1ad22120..152e45da 100644
--- a/include/spdlog/sinks/dist_sink.h
+++ b/include/spdlog/sinks/dist_sink.h
@@ -7,7 +7,6 @@
 
 #include "spdlog/details/log_msg.h"
 #include "spdlog/details/null_mutex.h"
-#include "spdlog/sink/base_sink.h"
 
 #include <algorithm>
 #include <memory>
@@ -18,22 +17,18 @@
 
 namespace spdlog {
 namespace sinks {
-template<class Mutex>
-class dist_sink : public base_sink<Mutex>
+
+template <typename Mutex>
+class dist_sink : public sink
 {
 public:
-    explicit dist_sink()
-        : sinks_()
-    {
-    }
+    dist_sink() = default;
     dist_sink(const dist_sink &) = delete;
     dist_sink &operator=(const dist_sink &) = delete;
 
-protected:
-    std::vector<std::shared_ptr<sink>> sinks_;
-
-    void sink_it_(const details::log_msg &msg) override
+    void log(const details::log_msg &msg) SPDLOG_FINAL override
     {
+        std::lock_guard<Mutex> lock(mutex_);
         for (auto &sink : sinks_)
         {
             if (sink->should_log(msg.level))
@@ -43,24 +38,29 @@ protected:
         }
     }
 
-    void flush_() override
+    void flush() SPDLOG_FINAL override
     {
+        std::lock_guard<Mutex> lock(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_);
+        std::lock_guard<Mutex> lock(mutex_);
         sinks_.push_back(sink);
     }
 
     void remove_sink(std::shared_ptr<sink> sink)
     {
-        std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
+        std::lock_guard<Mutex> lock(mutex_);
         sinks_.erase(std::remove(sinks_.begin(), sinks_.end(), sink), sinks_.end());
     }
+
+private:
+    Mutex mutex_;
+    std::vector<std::shared_ptr<sink>> sinks_;
+
 };
 
 using dist_sink_mt = dist_sink<std::mutex>;

From 39c6eb752a1c3541629ed6c8df9b9e94e27d6cde Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Sat, 7 Jul 2018 13:22:43 +0300
Subject: [PATCH 09/50] Code formatting

---
 bench/bench.cpp                        |  6 +++---
 example/example.cpp                    | 16 +---------------
 include/spdlog/details/fmt_helper.h    |  2 +-
 include/spdlog/sinks/basic_file_sink.h |  2 --
 include/spdlog/sinks/dist_sink.h       |  3 +--
 include/spdlog/sinks/sink.h            | 23 +++++++++++------------
 tests/includes.h                       |  2 +-
 7 files changed, 18 insertions(+), 36 deletions(-)

diff --git a/bench/bench.cpp b/bench/bench.cpp
index b1275f20..ec2b91e4 100644
--- a/bench/bench.cpp
+++ b/bench/bench.cpp
@@ -7,10 +7,10 @@
 // bench.cpp : spdlog benchmarks
 //
 #include "spdlog/async.h"
+#include "spdlog/sinks/basic_file_sink.h"
 #include "spdlog/sinks/daily_file_sink.h"
 #include "spdlog/sinks/null_sink.h"
 #include "spdlog/sinks/rotating_file_sink.h"
-#include "spdlog/sinks/basic_file_sink.h"
 #include "spdlog/spdlog.h"
 #include "utils.h"
 #include <atomic>
@@ -122,7 +122,7 @@ void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count
     for (int t = 0; t < thread_count; ++t)
     {
         threads.push_back(std::thread([&]() {
-            for (int j = 0; j < howmany/thread_count; j++)
+            for (int j = 0; j < howmany / thread_count; j++)
             {
                 log->info("Hello logger: msg number {}", j);
             }
@@ -134,7 +134,7 @@ void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count
         t.join();
     };
 
-        auto delta = high_resolution_clock::now() - start;
+    auto delta = high_resolution_clock::now() - start;
     auto delta_d = duration_cast<duration<double>>(delta).count();
     cout << "Elapsed: " << delta_d << "\t" << format(int(howmany / delta_d)) << "/sec" << endl;
 }
diff --git a/example/example.cpp b/example/example.cpp
index a9d8a7b0..eb520a25 100644
--- a/example/example.cpp
+++ b/example/example.cpp
@@ -7,7 +7,6 @@
 //
 //
 
-
 #include <iostream>
 
 void stdout_example();
@@ -42,7 +41,6 @@ int main(int, char *[])
         // custom  error handler
         err_handler_example();
 
-
         // apply some function on all registered loggers
         spdlog::apply_all([&](std::shared_ptr<spdlog::logger> l) { l->info("End of example."); });
 
@@ -57,7 +55,6 @@ int main(int, char *[])
     }
 }
 
-
 #include "spdlog/sinks/stdout_color_sinks.h" // or "/sinks/stdout_sinks.h" if no colors needed
 
 void stdout_example()
@@ -68,7 +65,7 @@ void stdout_example()
     console->error("Some error message with arg: {}", 1);
 
     auto err_logger = spdlog::stderr_color_mt("error_logger");
-    err_logger ->error("Some error message");
+    err_logger->error("Some error message");
     // Formatting examples
     console->warn("Easy padding in numbers like {:08d}", 12);
     console->critical("Support for int: {0:d};  hex: {0:x};  oct: {0:o}; bin: {0:b}", 42);
@@ -84,21 +81,16 @@ void stdout_example()
     console->set_level(spdlog::level::trace); // Set specific logger's log level
     console->debug("This message should be displayed..");
 
-
     // Customize msg format for all loggers
     spdlog::set_pattern("[%H:%M:%S %z] [%^---%L---%$] [thread %t] %v");
     console->info("This an info message with custom format");
 
-
-
     // Compile time log levels
     // define SPDLOG_DEBUG_ON or SPDLOG_TRACE_ON
     SPDLOG_TRACE(console, "Enabled only #ifdef SPDLOG_TRACE_ON..{} ,{}", 1, 3.23);
     SPDLOG_DEBUG(console, "Enabled only #ifdef SPDLOG_DEBUG_ON.. {} ,{}", 1, 3.23);
-
 }
 
-
 #include "spdlog/sinks/basic_file_sink.h"
 void basic_example()
 {
@@ -118,10 +110,8 @@ void daily_example()
 {
     // Create a daily logger - a new file is created every day on 2:30am
     auto daily_logger = spdlog::daily_logger_mt("daily_logger", "logs/daily.txt", 2, 30);
-
 }
 
-
 #include "spdlog/async.h"
 void async_example()
 {
@@ -137,8 +127,6 @@ void async_example()
     }
 }
 
-
-
 // user defined types logging by implementing operator<<
 #include "spdlog/fmt/ostr.h" // must be included
 struct my_type
@@ -151,7 +139,6 @@ struct my_type
     }
 };
 
-
 void user_defined_example()
 {
     spdlog::get("console")->info("user defined type: {}", my_type{14});
@@ -167,7 +154,6 @@ void err_handler_example()
     spdlog::get("console")->info("some invalid message to trigger an error {}{}{}{}", 3);
 }
 
-
 // syslog example (linux/osx/freebsd)
 #ifndef _WIN32
 #include "spdlog/sinks/syslog_sink.h"
diff --git a/include/spdlog/details/fmt_helper.h b/include/spdlog/details/fmt_helper.h
index f728b176..4fb0f3f5 100644
--- a/include/spdlog/details/fmt_helper.h
+++ b/include/spdlog/details/fmt_helper.h
@@ -122,7 +122,7 @@ inline void pad6(size_t n, fmt::memory_buffer &dest)
         dest.push_back('0');
         dest.push_back('0');
         dest.push_back('0');
-    }   
+    }
     append_int(n, dest);
 }
 
diff --git a/include/spdlog/sinks/basic_file_sink.h b/include/spdlog/sinks/basic_file_sink.h
index 59795401..ffa92be0 100644
--- a/include/spdlog/sinks/basic_file_sink.h
+++ b/include/spdlog/sinks/basic_file_sink.h
@@ -26,8 +26,6 @@ public:
         file_helper_.open(filename, truncate);
     }
 
-
-
 protected:
     void sink_it_(const details::log_msg &, const fmt::memory_buffer &formatted) override
     {
diff --git a/include/spdlog/sinks/dist_sink.h b/include/spdlog/sinks/dist_sink.h
index 152e45da..80861247 100644
--- a/include/spdlog/sinks/dist_sink.h
+++ b/include/spdlog/sinks/dist_sink.h
@@ -18,7 +18,7 @@
 namespace spdlog {
 namespace sinks {
 
-template <typename Mutex>
+template<typename Mutex>
 class dist_sink : public sink
 {
 public:
@@ -60,7 +60,6 @@ public:
 private:
     Mutex mutex_;
     std::vector<std::shared_ptr<sink>> sinks_;
-
 };
 
 using dist_sink_mt = dist_sink<std::mutex>;
diff --git a/include/spdlog/sinks/sink.h b/include/spdlog/sinks/sink.h
index 9f661908..c18e5781 100644
--- a/include/spdlog/sinks/sink.h
+++ b/include/spdlog/sinks/sink.h
@@ -18,17 +18,17 @@ public:
         : formatter_(std::unique_ptr<spdlog::formatter>(new pattern_formatter("%+")))
     {
     }
-//
-//    explicit sink(const std::string &formatter_pattern)
-//        : formatter_(std::unique_ptr<spdlog::formatter>(new pattern_formatter(formatter_pattern)))
-//    {
-//    }
-//
-//    // sink with custom formatter
-//    explicit sink(std::unique_ptr<spdlog::formatter> sink_formatter)
-//        : formatter_(std::move(sink_formatter))
-//    {
-//    }
+    //
+    //    explicit sink(const std::string &formatter_pattern)
+    //        : formatter_(std::unique_ptr<spdlog::formatter>(new pattern_formatter(formatter_pattern)))
+    //    {
+    //    }
+    //
+    //    // sink with custom formatter
+    //    explicit sink(std::unique_ptr<spdlog::formatter> sink_formatter)
+    //        : formatter_(std::move(sink_formatter))
+    //    {
+    //    }
 
     virtual ~sink() = default;
 
@@ -60,7 +60,6 @@ public:
         formatter_ = std::move(sink_formatter);
     }
 
-
 protected:
     level_t level_{level::trace};
     std::unique_ptr<spdlog::formatter> formatter_;
diff --git a/tests/includes.h b/tests/includes.h
index 6a61bc06..c9056a02 100644
--- a/tests/includes.h
+++ b/tests/includes.h
@@ -13,10 +13,10 @@
 #define SPDLOG_DEBUG_ON
 
 #include "spdlog/async.h"
+#include "spdlog/sinks/basic_file_sink.h"
 #include "spdlog/sinks/daily_file_sink.h"
 #include "spdlog/sinks/null_sink.h"
 #include "spdlog/sinks/ostream_sink.h"
 #include "spdlog/sinks/rotating_file_sink.h"
-#include "spdlog/sinks/basic_file_sink.h"
 #include "spdlog/sinks/stdout_color_sinks.h"
 #include "spdlog/spdlog.h"

From bde4c7149f1a79a692ef9247c600b4f7b1432e8e Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Sat, 7 Jul 2018 13:38:15 +0300
Subject: [PATCH 10/50] Renamed traits to console globals

---
 .../spdlog/details/{traits.h => console_globals.h}    |  8 ++++----
 include/spdlog/sinks/ansicolor_sink.h                 | 11 ++++++-----
 include/spdlog/sinks/wincolor_sink.h                  | 10 +++++-----
 3 files changed, 15 insertions(+), 14 deletions(-)
 rename include/spdlog/details/{traits.h => console_globals.h} (87%)

diff --git a/include/spdlog/details/traits.h b/include/spdlog/details/console_globals.h
similarity index 87%
rename from include/spdlog/details/traits.h
rename to include/spdlog/details/console_globals.h
index d494cf73..58f86a95 100644
--- a/include/spdlog/details/traits.h
+++ b/include/spdlog/details/console_globals.h
@@ -7,7 +7,7 @@
 #include "stdio.h"
 namespace spdlog {
 namespace details {
-struct console_stdout_trait
+struct console_stdout_stream
 {
     static FILE *stream()
     {
@@ -21,7 +21,7 @@ struct console_stdout_trait
 #endif
 };
 
-struct console_stderr_trait
+struct console_stderr_stream
 {
     static FILE *stream()
     {
@@ -35,7 +35,7 @@ struct console_stderr_trait
 #endif
 };
 
-struct console_mutex_trait
+struct console_global_mutex
 {
     using mutex_t = std::mutex;
     static mutex_t &console_mutex()
@@ -45,7 +45,7 @@ struct console_mutex_trait
     }
 };
 
-struct console_null_mutex_trait
+struct console_global_nullmutex
 {
     using mutex_t = null_mutex;
     static mutex_t &console_mutex()
diff --git a/include/spdlog/sinks/ansicolor_sink.h b/include/spdlog/sinks/ansicolor_sink.h
index d817dffb..f72f6196 100644
--- a/include/spdlog/sinks/ansicolor_sink.h
+++ b/include/spdlog/sinks/ansicolor_sink.h
@@ -7,7 +7,7 @@
 
 #include "spdlog/details/null_mutex.h"
 #include "spdlog/details/os.h"
-#include "spdlog/details/traits.h"
+#include "spdlog/details/console_globals.h"
 
 #include <memory>
 #include <mutex>
@@ -132,10 +132,11 @@ private:
     std::unordered_map<level::level_enum, std::string, level::level_hasher> colors_;
 };
 
-using ansicolor_stdout_sink_mt = ansicolor_sink<details::console_stdout_trait, details::console_mutex_trait>;
-using ansicolor_stdout_sink_st = ansicolor_sink<details::console_stdout_trait, details::console_null_mutex_trait>;
-using ansicolor_stderr_sink_mt = ansicolor_sink<details::console_stderr_trait, details::console_mutex_trait>;
-using ansicolor_stderr_sink_st = ansicolor_sink<details::console_stderr_trait, details::console_null_mutex_trait>;
+using ansicolor_stdout_sink_mt = ansicolor_sink<details::console_stdout_stream, details::console_global_mutex>;
+using ansicolor_stdout_sink_st = ansicolor_sink<details::console_stdout_stream, details::console_global_nullmutex>;
+
+using ansicolor_stderr_sink_mt = ansicolor_sink<details::console_stderr_stream, details::console_global_mutex>;
+using ansicolor_stderr_sink_st = ansicolor_sink<details::console_stderr_stream, details::console_global_nullmutex>;
 
 } // namespace sinks
 
diff --git a/include/spdlog/sinks/wincolor_sink.h b/include/spdlog/sinks/wincolor_sink.h
index 9b93dc13..b4604e35 100644
--- a/include/spdlog/sinks/wincolor_sink.h
+++ b/include/spdlog/sinks/wincolor_sink.h
@@ -8,7 +8,7 @@
 #include "../fmt/fmt.h"
 #include "spdlog/common.h"
 #include "spdlog/details/null_mutex.h"
-#include "spdlog/details/traits.h"
+#include "spdlog/details/console_globals.h"
 #include "spdlog/sinks/sink.h"
 
 #include <memory>
@@ -116,11 +116,11 @@ private:
     std::unordered_map<level::level_enum, WORD, level::level_hasher> colors_;
 };
 
-using wincolor_stdout_sink_mt = wincolor_sink<details::console_stdout_trait, details::console_mutex_trait>;
-using wincolor_stdout_sink_st = wincolor_sink<details::console_stdout_trait, details::console_null_mutex_trait>;
+using wincolor_stdout_sink_mt = wincolor_sink<details::console_stdout_stream, details::console_global_mutex>;
+using wincolor_stdout_sink_st = wincolor_sink<details::console_stdout_stream, details::console_global_nullmutex>;
 
-using wincolor_stderr_sink_mt = wincolor_sink<details::console_stderr_trait, details::console_mutex_trait>;
-using wincolor_stderr_sink_st = wincolor_sink<details::console_stderr_trait, details::console_null_mutex_trait>;
+using wincolor_stderr_sink_mt = wincolor_sink<details::console_stderr_stream, details::console_global_mutex>;
+using wincolor_stderr_sink_st = wincolor_sink<details::console_stderr_stream, details::console_global_nullmutex>;
 
 } // namespace sinks
 } // namespace spdlog

From 9dc44c39e7c6f5687feff44b9b2cddd8f8fb3e30 Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Sat, 7 Jul 2018 14:04:31 +0300
Subject: [PATCH 11/50] Fixed bugs in stdout_sinks and in msvc

---
 example/Makefile                              |  2 +-
 example/example.cpp                           |  6 ++--
 include/spdlog/details/fmt_helper.h           |  4 +++
 .../spdlog/details/pattern_formatter_impl.h   | 12 ++++----
 include/spdlog/details/registry.h             |  6 ++--
 include/spdlog/details/thread_pool.h          | 16 +++++------
 include/spdlog/formatter.h                    |  2 --
 include/spdlog/sinks/android_sink.h           |  4 +--
 include/spdlog/sinks/ansicolor_sink.h         | 10 +++----
 include/spdlog/sinks/msvc_sink.h              |  7 +++--
 include/spdlog/sinks/sink.h                   |  1 +
 include/spdlog/sinks/stdout_sinks.h           | 28 +++++++++++--------
 include/spdlog/sinks/wincolor_sink.h          | 10 +++----
 include/spdlog/sinks/windebug_sink.h          | 27 ------------------
 14 files changed, 59 insertions(+), 76 deletions(-)
 delete mode 100644 include/spdlog/sinks/windebug_sink.h

diff --git a/example/Makefile b/example/Makefile
index 38c43f19..0f085d18 100644
--- a/example/Makefile
+++ b/example/Makefile
@@ -1,5 +1,5 @@
 CXX	= g++
-CXX_FLAGS = -Wall -Wextra -pedantic -std=c++11 -pthread -I../include
+CXX_FLAGS = -Wall -Wextra -pedantic -std=c++11 -pthread -I../include -fmax-errors=1
 CXX_RELEASE_FLAGS = -O3 -march=native
 CXX_DEBUG_FLAGS= -g
 
diff --git a/example/example.cpp b/example/example.cpp
index eb520a25..757f6756 100644
--- a/example/example.cpp
+++ b/example/example.cpp
@@ -55,16 +55,16 @@ int main(int, char *[])
     }
 }
 
-#include "spdlog/sinks/stdout_color_sinks.h" // or "/sinks/stdout_sinks.h" if no colors needed
+#include "spdlog/sinks/stdout_sinks.h" // or "/sinks/stdout_sinks.h" if no colors needed
 
 void stdout_example()
 {
     // create color multi threaded logger
-    auto console = spdlog::stdout_color_mt("console");
+    auto console = spdlog::stdout_logger_mt("console");
     console->info("Welcome to spdlog!");
     console->error("Some error message with arg: {}", 1);
 
-    auto err_logger = spdlog::stderr_color_mt("error_logger");
+    auto err_logger = spdlog::stderr_logger_mt("error_logger");
     err_logger->error("Some error message");
     // Formatting examples
     console->warn("Easy padding in numbers like {:08d}", 12);
diff --git a/include/spdlog/details/fmt_helper.h b/include/spdlog/details/fmt_helper.h
index 4fb0f3f5..743d9a3c 100644
--- a/include/spdlog/details/fmt_helper.h
+++ b/include/spdlog/details/fmt_helper.h
@@ -88,6 +88,10 @@ inline void pad3(int n, fmt::memory_buffer &dest)
 
 inline void pad6(size_t n, fmt::memory_buffer &dest)
 {
+    // todo: maybe replace this implementation with
+    // pad3(n / 1000, dest);
+    // pad3(n % 1000, dest);
+
     if (n > 99999)
     {
         append_int(n, dest);
diff --git a/include/spdlog/details/pattern_formatter_impl.h b/include/spdlog/details/pattern_formatter_impl.h
index 1b25fb79..e2cd5a95 100644
--- a/include/spdlog/details/pattern_formatter_impl.h
+++ b/include/spdlog/details/pattern_formatter_impl.h
@@ -533,7 +533,7 @@ public:
         , last_log_secs_(0)
     {
         std::memset(&cached_tm_, 0, sizeof(cached_tm_));
-        compile_pattern(pattern);
+        compile_pattern_(pattern);
     }
 
     pattern_formatter(const pattern_formatter &) = default;
@@ -544,7 +544,7 @@ public:
         auto secs = std::chrono::duration_cast<std::chrono::seconds>(msg.time.time_since_epoch());
         if (secs != last_log_secs_)
         {
-            cached_tm_ = get_time(msg);
+            cached_tm_ = get_time_(msg);
             last_log_secs_ = secs;
         }
 #endif
@@ -563,7 +563,7 @@ private:
     std::chrono::seconds last_log_secs_;
 
     std::vector<std::unique_ptr<details::flag_formatter>> formatters_;
-    std::tm get_time(const details::log_msg &msg)
+    std::tm get_time_(const details::log_msg &msg)
     {
         if (pattern_time_ == pattern_time_type::local)
         {
@@ -572,7 +572,7 @@ private:
         return details::os::gmtime(log_clock::to_time_t(msg.time));
     }
 
-    void handle_flag(char flag)
+    void handle_flag_(char flag)
     {
         switch (flag)
         {
@@ -717,7 +717,7 @@ private:
         }
     }
 
-    void compile_pattern(const std::string &pattern)
+    void compile_pattern_(const std::string &pattern)
     {
         auto end = pattern.end();
         std::unique_ptr<details::aggregate_formatter> user_chars;
@@ -732,7 +732,7 @@ private:
                 // if(
                 if (++it != end)
                 {
-                    handle_flag(*it);
+                    handle_flag_(*it);
                 }
                 else
                 {
diff --git a/include/spdlog/details/registry.h b/include/spdlog/details/registry.h
index 85111d23..87495de1 100644
--- a/include/spdlog/details/registry.h
+++ b/include/spdlog/details/registry.h
@@ -36,7 +36,7 @@ public:
     {
         std::lock_guard<Mutex> lock(mutex_);
         auto logger_name = new_logger->name();
-        throw_if_exists(logger_name);
+        throw_if_exists_(logger_name);
         loggers_[logger_name] = new_logger;
     }
 
@@ -44,7 +44,7 @@ public:
     {
         std::lock_guard<Mutex> lock(mutex_);
         auto logger_name = new_logger->name();
-        throw_if_exists(logger_name);
+        throw_if_exists_(logger_name);
 
         // create default formatter if not exists
 
@@ -162,7 +162,7 @@ public:
 private:
     registry_t<Mutex>() = default;
 
-    void throw_if_exists(const std::string &logger_name)
+    void throw_if_exists_(const std::string &logger_name)
     {
         if (loggers_.find(logger_name) != loggers_.end())
         {
diff --git a/include/spdlog/details/thread_pool.h b/include/spdlog/details/thread_pool.h
index 9019823a..35641e43 100644
--- a/include/spdlog/details/thread_pool.h
+++ b/include/spdlog/details/thread_pool.h
@@ -95,7 +95,7 @@ public:
         }
         for (size_t i = 0; i < threads_n; i++)
         {
-            threads_.emplace_back(std::bind(&thread_pool::worker_loop, this));
+            threads_.emplace_back(std::bind(&thread_pool::worker_loop_, this));
         }
     }
 
@@ -106,7 +106,7 @@ public:
         {
             for (size_t i = 0; i < threads_.size(); i++)
             {
-                post_async_msg(async_msg(async_msg_type::terminate), async_overflow_policy::block_retry);
+                post_async_msg_(async_msg(async_msg_type::terminate), async_overflow_policy::block_retry);
             }
 
             for (auto &t : threads_)
@@ -123,12 +123,12 @@ public:
     void post_log(async_logger_ptr &&worker_ptr, details::log_msg &&msg, async_overflow_policy overflow_policy)
     {
         async_msg async_m(std::forward<async_logger_ptr>(worker_ptr), async_msg_type::log, std::forward<log_msg>(msg));
-        post_async_msg(std::move(async_m), overflow_policy);
+        post_async_msg_(std::move(async_m), overflow_policy);
     }
 
     void post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy)
     {
-        post_async_msg(async_msg(std::move(worker_ptr), async_msg_type::flush), overflow_policy);
+        post_async_msg_(async_msg(std::move(worker_ptr), async_msg_type::flush), overflow_policy);
     }
 
 private:
@@ -136,7 +136,7 @@ private:
 
     std::vector<std::thread> threads_;
 
-    void post_async_msg(async_msg &&new_msg, async_overflow_policy overflow_policy)
+    void post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy)
     {
         if (overflow_policy == async_overflow_policy::block_retry)
         {
@@ -148,14 +148,14 @@ private:
         }
     }
 
-    void worker_loop()
+    void worker_loop_()
     {
-        while (process_next_msg()) {};
+        while (process_next_msg_()) {};
     }
 
     // process next message in the queue
     // return true if this thread should still be active (while no terminate msg was received)
-    bool process_next_msg()
+    bool process_next_msg_()
     {
         async_msg incoming_async_msg;
         bool dequeued = q_.dequeue_for(incoming_async_msg, std::chrono::seconds(10));
diff --git a/include/spdlog/formatter.h b/include/spdlog/formatter.h
index ec343f83..39d86524 100644
--- a/include/spdlog/formatter.h
+++ b/include/spdlog/formatter.h
@@ -17,5 +17,3 @@ public:
     virtual void format(const details::log_msg &msg, fmt::memory_buffer &dest) = 0;
 };
 } // namespace spdlog
-
-#include "details/pattern_formatter_impl.h"
diff --git a/include/spdlog/sinks/android_sink.h b/include/spdlog/sinks/android_sink.h
index 9b1259e1..97515db9 100644
--- a/include/spdlog/sinks/android_sink.h
+++ b/include/spdlog/sinks/android_sink.h
@@ -38,7 +38,7 @@ public:
 
     void log(const details::log_msg &msg) override
     {
-        const android_LogPriority priority = convert_to_android(msg.level);
+        const android_LogPriority priority = convert_to_android_(msg.level);
         fmt::memory_buffer formatted;
         if (use_raw_msg_)
         {
@@ -70,7 +70,7 @@ public:
     void flush() override {}
 
 private:
-    static android_LogPriority convert_to_android(spdlog::level::level_enum level)
+    static android_LogPriority convert_to_android_(spdlog::level::level_enum level)
     {
         switch (level)
         {
diff --git a/include/spdlog/sinks/ansicolor_sink.h b/include/spdlog/sinks/ansicolor_sink.h
index f72f6196..961062ac 100644
--- a/include/spdlog/sinks/ansicolor_sink.h
+++ b/include/spdlog/sinks/ansicolor_sink.h
@@ -5,9 +5,9 @@
 
 #pragma once
 
+#include "spdlog/details/console_globals.h"
 #include "spdlog/details/null_mutex.h"
 #include "spdlog/details/os.h"
-#include "spdlog/details/console_globals.h"
 
 #include <memory>
 #include <mutex>
@@ -22,14 +22,14 @@ namespace sinks {
  * of the message.
  * If no color terminal detected, omit the escape codes.
  */
-template<class StreamTrait, class ConsoleMutexTrait>
+template<class TargetStream, class ConsoleMutex>
 class ansicolor_sink : public sink
 {
 public:
-    using mutex_t = typename ConsoleMutexTrait::mutex_t;
+    using mutex_t = typename ConsoleMutex::mutex_t;
     ansicolor_sink()
-        : target_file_(StreamTrait::stream())
-        , mutex_(ConsoleMutexTrait::console_mutex())
+        : target_file_(TargetStream::stream())
+        , mutex_(ConsoleMutex::console_mutex())
 
     {
         should_do_colors_ = details::os::in_terminal(target_file_) && details::os::is_color_terminal();
diff --git a/include/spdlog/sinks/msvc_sink.h b/include/spdlog/sinks/msvc_sink.h
index b12a1b49..4c45635a 100644
--- a/include/spdlog/sinks/msvc_sink.h
+++ b/include/spdlog/sinks/msvc_sink.h
@@ -27,9 +27,9 @@ public:
     explicit msvc_sink() {}
 
 protected:
-    void sink_it_(const details::log_msg &msg) override
+    void sink_it_(const details::log_msg &, const fmt::memory_buffer &formatted) override
     {
-        OutputDebugStringA(msg.formatted.c_str());
+        OutputDebugStringA(fmt::to_string(formatted).c_str());
     }
 
     void flush_() override {}
@@ -38,6 +38,9 @@ protected:
 using msvc_sink_mt = msvc_sink<std::mutex>;
 using msvc_sink_st = msvc_sink<details::null_mutex>;
 
+using windebug_sink_mt = msvc_sink_mt;
+using windebug_sink_st = msvc_sink_st;
+
 } // namespace sinks
 } // namespace spdlog
 
diff --git a/include/spdlog/sinks/sink.h b/include/spdlog/sinks/sink.h
index c18e5781..2c2a764c 100644
--- a/include/spdlog/sinks/sink.h
+++ b/include/spdlog/sinks/sink.h
@@ -6,6 +6,7 @@
 #pragma once
 
 #include "spdlog/details/log_msg.h"
+#include "spdlog/details/pattern_formatter_impl.h"
 #include "spdlog/formatter.h"
 
 namespace spdlog {
diff --git a/include/spdlog/sinks/stdout_sinks.h b/include/spdlog/sinks/stdout_sinks.h
index 80854730..5d25a954 100644
--- a/include/spdlog/sinks/stdout_sinks.h
+++ b/include/spdlog/sinks/stdout_sinks.h
@@ -5,26 +5,27 @@
 
 #pragma once
 
+#include "spdlog/details/console_globals.h"
 #include "spdlog/details/null_mutex.h"
-#include "spdlog/details/traits.h"
 #include "spdlog/spdlog.h"
 
 #include <cstdio>
 #include <memory>
 #include <mutex>
+#include <spdlog/details/console_globals.h>
 
 namespace spdlog {
 
 namespace sinks {
 
-template<class StdoutTrait, class ConsoleMutexTrait>
+template<class TargetStream, class ConsoleMutex>
 class stdout_sink : public sink
 {
 public:
-    using mutex_t = typename ConsoleMutexTrait::mutex_t;
+    using mutex_t = typename ConsoleMutex::mutex_t;
     stdout_sink()
-        : mutex_(ConsoleMutexTrait::console_mutex())
-        , file_(StdoutTrait::stream())
+        : mutex_(ConsoleMutex::console_mutex())
+        , file_(TargetStream::stream())
     {
     }
     ~stdout_sink() = default;
@@ -35,14 +36,16 @@ public:
     void log(const details::log_msg &msg) override
     {
         std::lock_guard<mutex_t> lock(mutex_);
-        fwrite(msg.formatted.data(), sizeof(char), msg.formatted.size(), file_);
-        fflush(StdoutTrait::stream());
+        fmt::memory_buffer formatted;
+        formatter_->format(msg, formatted);
+        fwrite(formatted.data(), sizeof(char), formatted.size(), file_);
+        fflush(TargetStream::stream());
     }
 
     void flush() override
     {
         std::lock_guard<mutex_t> lock(mutex_);
-        fflush(StdoutTrait::stream());
+        fflush(TargetStream::stream());
     }
 
 private:
@@ -50,10 +53,11 @@ private:
     FILE *file_;
 };
 
-using stdout_sink_mt = stdout_sink<details::console_stdout_trait, details::console_mutex_trait>;
-using stdout_sink_st = stdout_sink<details::console_stdout_trait, details::console_null_mutex_trait>;
-using stderr_sink_mt = stdout_sink<details::console_stderr_trait, details::console_mutex_trait>;
-using stderr_sink_st = stdout_sink<details::console_stderr_trait, details::console_null_mutex_trait>;
+using stdout_sink_mt = stdout_sink<details::console_stdout_stream, details::console_global_mutex>;
+using stdout_sink_st = stdout_sink<details::console_stdout_stream, details::console_global_nullmutex>;
+
+using stderr_sink_mt = stdout_sink<details::console_stderr_stream, details::console_global_mutex>;
+using stderr_sink_st = stdout_sink<details::console_stderr_stream, details::console_global_nullmutex>;
 
 } // namespace sinks
 
diff --git a/include/spdlog/sinks/wincolor_sink.h b/include/spdlog/sinks/wincolor_sink.h
index b4604e35..7199db11 100644
--- a/include/spdlog/sinks/wincolor_sink.h
+++ b/include/spdlog/sinks/wincolor_sink.h
@@ -7,8 +7,8 @@
 
 #include "../fmt/fmt.h"
 #include "spdlog/common.h"
-#include "spdlog/details/null_mutex.h"
 #include "spdlog/details/console_globals.h"
+#include "spdlog/details/null_mutex.h"
 #include "spdlog/sinks/sink.h"
 
 #include <memory>
@@ -22,7 +22,7 @@ namespace sinks {
 /*
  * Windows color console sink. Uses WriteConsoleA to write to the console with colors
  */
-template<class HandleTrait, class ConsoleMutexTrait>
+template<class OutHandle, class ConsoleMutex>
 class wincolor_sink : public sink
 {
 public:
@@ -34,8 +34,8 @@ public:
     const WORD YELLOW = FOREGROUND_RED | FOREGROUND_GREEN;
 
     wincolor_sink()
-        : out_handle_(HandleTrait::handle())
-        , mutex_(ConsoleMutexTrait::console_mutex())
+        : out_handle_(OutHandle::handle())
+        , mutex_(ConsoleMutex::console_mutex())
     {
         colors_[level::trace] = WHITE;
         colors_[level::debug] = CYAN;
@@ -90,7 +90,7 @@ public:
     }
 
 private:
-    using mutex_t = typename ConsoleMutexTrait::mutex_t;
+    using mutex_t = typename ConsoleMutex::mutex_t;
     // set color and return the orig console attributes (for resetting later)
     WORD set_console_attribs(WORD attribs)
     {
diff --git a/include/spdlog/sinks/windebug_sink.h b/include/spdlog/sinks/windebug_sink.h
deleted file mode 100644
index 15ffdc2e..00000000
--- a/include/spdlog/sinks/windebug_sink.h
+++ /dev/null
@@ -1,27 +0,0 @@
-//
-// Copyright(c) 2017 Alexander Dalshov.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#if defined(_WIN32)
-
-#include "spdlog/sinks/msvc_sink.h"
-
-namespace spdlog {
-namespace sinks {
-
-/*
- * Windows debug sink (logging using OutputDebugStringA, synonym for msvc_sink)
- */
-template<class Mutex>
-using windebug_sink = msvc_sink<Mutex>;
-
-using windebug_sink_mt = msvc_sink_mt;
-using windebug_sink_st = msvc_sink_st;
-
-} // namespace sinks
-} // namespace spdlog
-
-#endif

From 745b9e32ed20c78731484bd443b5f443e7bc4464 Mon Sep 17 00:00:00 2001
From: Gabi Melman <gmelman1@gmail.com>
Date: Sat, 7 Jul 2018 15:03:34 +0300
Subject: [PATCH 12/50] Update example.cpp

---
 example/example.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/example/example.cpp b/example/example.cpp
index 757f6756..872ffdf2 100644
--- a/example/example.cpp
+++ b/example/example.cpp
@@ -55,7 +55,7 @@ int main(int, char *[])
     }
 }
 
-#include "spdlog/sinks/stdout_sinks.h" // or "/sinks/stdout_sinks.h" if no colors needed
+#include "spdlog/sinks/stdout_color_sinks.h" // or "/sinks/stdout_sinks.h" if no colors needed
 
 void stdout_example()
 {

From 5fddfca7c67a4a886ab0f9fbb2ccb86111bf5c51 Mon Sep 17 00:00:00 2001
From: Gabi Melman <gmelman1@gmail.com>
Date: Sat, 7 Jul 2018 15:03:57 +0300
Subject: [PATCH 13/50] Update example.cpp

---
 example/example.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/example/example.cpp b/example/example.cpp
index 872ffdf2..4b526841 100644
--- a/example/example.cpp
+++ b/example/example.cpp
@@ -56,7 +56,6 @@ int main(int, char *[])
 }
 
 #include "spdlog/sinks/stdout_color_sinks.h" // or "/sinks/stdout_sinks.h" if no colors needed
-
 void stdout_example()
 {
     // create color multi threaded logger

From 4fc59e3e7bf67e75083f4778492540297f5f510e Mon Sep 17 00:00:00 2001
From: Gabi Melman <gmelman1@gmail.com>
Date: Sat, 7 Jul 2018 15:05:01 +0300
Subject: [PATCH 14/50] Update example.cpp

---
 example/example.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/example/example.cpp b/example/example.cpp
index 4b526841..3cd1d533 100644
--- a/example/example.cpp
+++ b/example/example.cpp
@@ -65,6 +65,7 @@ void stdout_example()
 
     auto err_logger = spdlog::stderr_logger_mt("error_logger");
     err_logger->error("Some error message");
+    
     // Formatting examples
     console->warn("Easy padding in numbers like {:08d}", 12);
     console->critical("Support for int: {0:d};  hex: {0:x};  oct: {0:o}; bin: {0:b}", 42);

From b07069fb4d3c1d88a37188561120219d0fd93369 Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Sat, 7 Jul 2018 15:27:17 +0300
Subject: [PATCH 15/50] Fixed example

---
 example/example.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/example/example.cpp b/example/example.cpp
index 3cd1d533..4a851942 100644
--- a/example/example.cpp
+++ b/example/example.cpp
@@ -59,11 +59,11 @@ int main(int, char *[])
 void stdout_example()
 {
     // create color multi threaded logger
-    auto console = spdlog::stdout_logger_mt("console");
+    auto console = spdlog::stdout_color_mt("console");
     console->info("Welcome to spdlog!");
     console->error("Some error message with arg: {}", 1);
 
-    auto err_logger = spdlog::stderr_logger_mt("error_logger");
+    auto err_logger = spdlog::stderr_color_mt("error_logger");
     err_logger->error("Some error message");
     
     // Formatting examples

From cbc4db8649f3ff13f886e42c9c12ba9b15765e94 Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Sat, 7 Jul 2018 15:34:25 +0300
Subject: [PATCH 16/50] Renamed filename and other small formatter changes

---
 .../{pattern_formatter_impl.h => pattern_formatter.h}      | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)
 rename include/spdlog/details/{pattern_formatter_impl.h => pattern_formatter.h} (98%)

diff --git a/include/spdlog/details/pattern_formatter_impl.h b/include/spdlog/details/pattern_formatter.h
similarity index 98%
rename from include/spdlog/details/pattern_formatter_impl.h
rename to include/spdlog/details/pattern_formatter.h
index e2cd5a95..3d54c883 100644
--- a/include/spdlog/details/pattern_formatter_impl.h
+++ b/include/spdlog/details/pattern_formatter.h
@@ -176,7 +176,6 @@ class d_formatter SPDLOG_FINAL : public flag_formatter
 {
     void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
     {
-        // fmt::format_to(dest, "{:02}", tm_time.tm_mday);
         fmt_helper::pad2(tm_time.tm_mday, dest);
     }
 };
@@ -265,7 +264,7 @@ class p_formatter SPDLOG_FINAL : public flag_formatter
 {
     void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
     {
-        fmt::format_to(dest, "{}", ampm(tm_time));
+        fmt_helper::append_c_str(ampm(tm_time), dest);
     }
 };
 
@@ -274,13 +273,13 @@ class r_formatter SPDLOG_FINAL : public flag_formatter
 {
     void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
     {
-        // fmt::format_to(dest, "{:02}:{:02}:{:02} {}", to12h(tm_time), tm_time.tm_min, tm_time.tm_sec, ampm(tm_time));
         fmt_helper::pad2(to12h(tm_time), dest);
         dest.push_back(':');
         fmt_helper::pad2(tm_time.tm_min, dest);
         dest.push_back(':');
         fmt_helper::pad2(tm_time.tm_sec, dest);
-        fmt::format_to(dest, " {}", ampm(tm_time));
+        dest.push_back(' ');
+        fmt_helper::append_c_str(ampm(tm_time), dest);
     }
 };
 

From c9331594bb2dddf5de9ee6ba79317b67ed049220 Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Sat, 7 Jul 2018 16:15:17 +0300
Subject: [PATCH 17/50] Renamed file to pattern_forammter.h and fixed utc
 support

---
 example/example.cpp                        | 2 +-
 include/spdlog/details/logger_impl.h       | 4 ++--
 include/spdlog/details/pattern_formatter.h | 9 +++++----
 include/spdlog/details/registry.h          | 8 +++++---
 include/spdlog/logger.h                    | 2 +-
 include/spdlog/sinks/sink.h                | 2 +-
 include/spdlog/spdlog.h                    | 4 ++--
 7 files changed, 17 insertions(+), 14 deletions(-)

diff --git a/example/example.cpp b/example/example.cpp
index 4a851942..113cf454 100644
--- a/example/example.cpp
+++ b/example/example.cpp
@@ -65,7 +65,7 @@ void stdout_example()
 
     auto err_logger = spdlog::stderr_color_mt("error_logger");
     err_logger->error("Some error message");
-    
+
     // Formatting examples
     console->warn("Easy padding in numbers like {:08d}", 12);
     console->critical("Support for int: {0:d};  hex: {0:x};  oct: {0:o}; bin: {0:b}", 42);
diff --git a/include/spdlog/details/logger_impl.h b/include/spdlog/details/logger_impl.h
index 5a61a709..dc3dcfa5 100644
--- a/include/spdlog/details/logger_impl.h
+++ b/include/spdlog/details/logger_impl.h
@@ -46,9 +46,9 @@ inline void spdlog::logger::set_formatter(const Args &... args)
     }
 }
 
-inline void spdlog::logger::set_pattern(const std::string &pattern, pattern_time_type pattern_time)
+inline void spdlog::logger::set_pattern(const std::string &pattern, pattern_time_type time_type)
 {
-    set_formatter<spdlog::pattern_formatter>(pattern, pattern_time);
+    set_formatter<spdlog::pattern_formatter>(pattern, time_type);
 }
 
 template<typename... Args>
diff --git a/include/spdlog/details/pattern_formatter.h b/include/spdlog/details/pattern_formatter.h
index 3d54c883..a5ebe923 100644
--- a/include/spdlog/details/pattern_formatter.h
+++ b/include/spdlog/details/pattern_formatter.h
@@ -525,10 +525,10 @@ private:
 class pattern_formatter SPDLOG_FINAL : public formatter
 {
 public:
-    explicit pattern_formatter(const std::string &pattern, pattern_time_type pattern_time = pattern_time_type::local,
+    explicit pattern_formatter(const std::string &pattern, pattern_time_type time_type = pattern_time_type::local,
         std::string eol = spdlog::details::os::default_eol)
         : eol_(std::move(eol))
-        , pattern_time_(pattern_time)
+        , pattern_time_type_(time_type)
         , last_log_secs_(0)
     {
         std::memset(&cached_tm_, 0, sizeof(cached_tm_));
@@ -557,14 +557,15 @@ public:
 
 private:
     const std::string eol_;
-    const pattern_time_type pattern_time_;
+    pattern_time_type pattern_time_type_;
     std::tm cached_tm_;
     std::chrono::seconds last_log_secs_;
 
     std::vector<std::unique_ptr<details::flag_formatter>> formatters_;
+
     std::tm get_time_(const details::log_msg &msg)
     {
-        if (pattern_time_ == pattern_time_type::local)
+        if (pattern_time_type_ == pattern_time_type::local)
         {
             return details::os::localtime(log_clock::to_time_t(msg.time));
         }
diff --git a/include/spdlog/details/registry.h b/include/spdlog/details/registry.h
index 87495de1..6de2f57a 100644
--- a/include/spdlog/details/registry.h
+++ b/include/spdlog/details/registry.h
@@ -48,7 +48,7 @@ public:
 
         // create default formatter if not exists
 
-        new_logger->set_pattern(formatter_pattern_);
+        new_logger->set_formatter<pattern_formatter>(formatter_pattern_, pattern_time_type_);
 
         if (err_handler_)
         {
@@ -81,13 +81,14 @@ public:
         return tp_;
     }
 
-    void set_pattern(const std::string &pattern)
+    void set_pattern(const std::string &pattern, pattern_time_type time_type)
     {
         std::lock_guard<Mutex> lock(mutex_);
         formatter_pattern_ = pattern;
+        pattern_time_type_ = time_type;
         for (auto &l : loggers_)
         {
-            l.second->set_pattern(pattern);
+            l.second->set_pattern(pattern, time_type);
         }
     }
 
@@ -174,6 +175,7 @@ private:
     Mutex tp_mutex_;
     std::unordered_map<std::string, std::shared_ptr<logger>> loggers_;
     std::string formatter_pattern_ = "%+";
+    pattern_time_type pattern_time_type_ = pattern_time_type::local;
     level::level_enum level_ = level::info;
     level::level_enum flush_level_ = level::off;
     log_err_handler err_handler_;
diff --git a/include/spdlog/logger.h b/include/spdlog/logger.h
index f67a07ff..5d67bf8d 100644
--- a/include/spdlog/logger.h
+++ b/include/spdlog/logger.h
@@ -117,7 +117,7 @@ public:
 
     // create a pattern formatter all the sinks in this logger.
     // each sink gets itw own private copy of a formatter object.
-    void set_pattern(const std::string &pattern, pattern_time_type pattern_time = pattern_time_type::local);
+    void set_pattern(const std::string &pattern, pattern_time_type time_type = pattern_time_type::local);
 
     // create a FormatterT formatter for each sink in this logger.
     // each sink gets its own private copy of a formatter object.
diff --git a/include/spdlog/sinks/sink.h b/include/spdlog/sinks/sink.h
index 2c2a764c..39eb0abb 100644
--- a/include/spdlog/sinks/sink.h
+++ b/include/spdlog/sinks/sink.h
@@ -6,7 +6,7 @@
 #pragma once
 
 #include "spdlog/details/log_msg.h"
-#include "spdlog/details/pattern_formatter_impl.h"
+#include "spdlog/details/pattern_formatter.h"
 #include "spdlog/formatter.h"
 
 namespace spdlog {
diff --git a/include/spdlog/spdlog.h b/include/spdlog/spdlog.h
index 53c56a30..90148d6f 100644
--- a/include/spdlog/spdlog.h
+++ b/include/spdlog/spdlog.h
@@ -57,9 +57,9 @@ inline 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");
 //
-inline void set_pattern(const std::string &format_string)
+inline void set_pattern(const std::string &format_string, pattern_time_type time_type = pattern_time_type::local)
 {
-    details::registry::instance().set_pattern(format_string);
+    details::registry::instance().set_pattern(format_string, time_type);
 }
 
 //

From 775e410b000d8a1e1bb3766bd21add5db12b5108 Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Sat, 7 Jul 2018 16:29:05 +0300
Subject: [PATCH 18/50] Fixed issue #747

---
 include/spdlog/details/logger_impl.h | 24 ++++++++++++------------
 include/spdlog/logger.h              | 12 ++++++------
 2 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/include/spdlog/details/logger_impl.h b/include/spdlog/details/logger_impl.h
index dc3dcfa5..75ce7c6c 100644
--- a/include/spdlog/details/logger_impl.h
+++ b/include/spdlog/details/logger_impl.h
@@ -101,39 +101,39 @@ inline void spdlog::logger::log(level::level_enum lvl, const T &msg)
 }
 
 template<typename Arg1, typename... Args>
-inline void spdlog::logger::trace(const char *fmt, const Arg1 &arg1, const Args &... args)
+inline void spdlog::logger::trace(const char *fmt, const Args &... args)
 {
-    log(level::trace, fmt, arg1, args...);
+    log(level::trace, fmt, args...);
 }
 
 template<typename Arg1, typename... Args>
-inline void spdlog::logger::debug(const char *fmt, const Arg1 &arg1, const Args &... args)
+inline void spdlog::logger::debug(const char *fmt, const Args &... args)
 {
-    log(level::debug, fmt, arg1, args...);
+    log(level::debug, fmt, args...);
 }
 
 template<typename Arg1, typename... Args>
-inline void spdlog::logger::info(const char *fmt, const Arg1 &arg1, const Args &... args)
+inline void spdlog::logger::info(const char *fmt, const Args &... args)
 {
-    log(level::info, fmt, arg1, args...);
+    log(level::info, fmt, args...);
 }
 
 template<typename Arg1, typename... Args>
-inline void spdlog::logger::warn(const char *fmt, const Arg1 &arg1, const Args &... args)
+inline void spdlog::logger::warn(const char *fmt, const Args &... args)
 {
-    log(level::warn, fmt, arg1, args...);
+    log(level::warn, fmt, args...);
 }
 
 template<typename Arg1, typename... Args>
-inline void spdlog::logger::error(const char *fmt, const Arg1 &arg1, const Args &... args)
+inline void spdlog::logger::error(const char *fmt, const Args &... args)
 {
-    log(level::err, fmt, arg1, args...);
+    log(level::err, fmt, args...);
 }
 
 template<typename Arg1, typename... Args>
-inline void spdlog::logger::critical(const char *fmt, const Arg1 &arg1, const Args &... args)
+inline void spdlog::logger::critical(const char *fmt, const Args &... args)
 {
-    log(level::critical, fmt, arg1, args...);
+    log(level::critical, fmt, args...);
 }
 
 template<typename T>
diff --git a/include/spdlog/logger.h b/include/spdlog/logger.h
index 5d67bf8d..6828312e 100644
--- a/include/spdlog/logger.h
+++ b/include/spdlog/logger.h
@@ -46,22 +46,22 @@ public:
     void log(level::level_enum lvl, const char *msg);
 
     template<typename Arg1, typename... Args>
-    void trace(const char *fmt, const Arg1 &, const Args &... args);
+    void trace(const char *fmt, const Args &... args);
 
     template<typename Arg1, typename... Args>
-    void debug(const char *fmt, const Arg1 &, const Args &... args);
+    void debug(const char *fmt, const Args &... args);
 
     template<typename Arg1, typename... Args>
-    void info(const char *fmt, const Arg1 &, const Args &... args);
+    void info(const char *fmt, const Args &... args);
 
     template<typename Arg1, typename... Args>
-    void warn(const char *fmt, const Arg1 &, const Args &... args);
+    void warn(const char *fmt, const Args &... args);
 
     template<typename Arg1, typename... Args>
-    void error(const char *fmt, const Arg1 &, const Args &... args);
+    void error(const char *fmt, const Args &... args);
 
     template<typename Arg1, typename... Args>
-    void critical(const char *fmt, const Arg1 &, const Args &... args);
+    void critical(const char *fmt, const Args &... args);
 
 #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
     template<typename... Args>

From 4f1ce9189f6ef4b1b96fe017c56c24c5513f8514 Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Sat, 7 Jul 2018 16:40:29 +0300
Subject: [PATCH 19/50] Fixed issue #747

---
 include/spdlog/details/logger_impl.h | 12 ++++++------
 include/spdlog/logger.h              | 12 ++++++------
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/include/spdlog/details/logger_impl.h b/include/spdlog/details/logger_impl.h
index 75ce7c6c..9b9b467f 100644
--- a/include/spdlog/details/logger_impl.h
+++ b/include/spdlog/details/logger_impl.h
@@ -100,37 +100,37 @@ inline void spdlog::logger::log(level::level_enum lvl, const T &msg)
     SPDLOG_CATCH_AND_HANDLE
 }
 
-template<typename Arg1, typename... Args>
+template<typename... Args>
 inline void spdlog::logger::trace(const char *fmt, const Args &... args)
 {
     log(level::trace, fmt, args...);
 }
 
-template<typename Arg1, typename... Args>
+template<typename... Args>
 inline void spdlog::logger::debug(const char *fmt, const Args &... args)
 {
     log(level::debug, fmt, args...);
 }
 
-template<typename Arg1, typename... Args>
+template<typename... Args>
 inline void spdlog::logger::info(const char *fmt, const Args &... args)
 {
     log(level::info, fmt, args...);
 }
 
-template<typename Arg1, typename... Args>
+template<typename... Args>
 inline void spdlog::logger::warn(const char *fmt, const Args &... args)
 {
     log(level::warn, fmt, args...);
 }
 
-template<typename Arg1, typename... Args>
+template<typename... Args>
 inline void spdlog::logger::error(const char *fmt, const Args &... args)
 {
     log(level::err, fmt, args...);
 }
 
-template<typename Arg1, typename... Args>
+template<typename... Args>
 inline void spdlog::logger::critical(const char *fmt, const Args &... args)
 {
     log(level::critical, fmt, args...);
diff --git a/include/spdlog/logger.h b/include/spdlog/logger.h
index 6828312e..372d8314 100644
--- a/include/spdlog/logger.h
+++ b/include/spdlog/logger.h
@@ -45,22 +45,22 @@ public:
     template<typename... Args>
     void log(level::level_enum lvl, const char *msg);
 
-    template<typename Arg1, typename... Args>
+    template<typename... Args>
     void trace(const char *fmt, const Args &... args);
 
-    template<typename Arg1, typename... Args>
+    template<typename... Args>
     void debug(const char *fmt, const Args &... args);
 
-    template<typename Arg1, typename... Args>
+    template<typename... Args>
     void info(const char *fmt, const Args &... args);
 
-    template<typename Arg1, typename... Args>
+    template<typename... Args>
     void warn(const char *fmt, const Args &... args);
 
-    template<typename Arg1, typename... Args>
+    template<typename... Args>
     void error(const char *fmt, const Args &... args);
 
-    template<typename Arg1, typename... Args>
+    template<typename... Args>
     void critical(const char *fmt, const Args &... args);
 
 #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT

From 7ed8e1b59d15a126e6cc9d58b5b5dec4184b42f5 Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Sun, 8 Jul 2018 00:53:50 +0300
Subject: [PATCH 20/50] renamed async block  policy

---
 include/spdlog/async.h               |  2 +-
 include/spdlog/async_logger.h        |  6 +++---
 include/spdlog/common.h              |  5 +++--
 include/spdlog/details/thread_pool.h |  5 ++---
 tests/test_async.cpp                 | 10 +++++-----
 5 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/include/spdlog/async.h b/include/spdlog/async.h
index 2e13f3b3..3aab7a89 100644
--- a/include/spdlog/async.h
+++ b/include/spdlog/async.h
@@ -39,7 +39,7 @@ struct async_factory
         }
 
         auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);
-        auto new_logger = std::make_shared<async_logger>(logger_name, std::move(sink), std::move(tp), async_overflow_policy::block_retry);
+        auto new_logger = std::make_shared<async_logger>(logger_name, std::move(sink), std::move(tp), async_overflow_policy::block);
         registry::instance().register_and_init(new_logger);
         return new_logger;
     }
diff --git a/include/spdlog/async_logger.h b/include/spdlog/async_logger.h
index e4badf14..4faaabc8 100644
--- a/include/spdlog/async_logger.h
+++ b/include/spdlog/async_logger.h
@@ -34,13 +34,13 @@ class async_logger SPDLOG_FINAL : public std::enable_shared_from_this<async_logg
 public:
     template<class It>
     async_logger(const std::string &logger_name, const It &begin, const It &end, std::weak_ptr<details::thread_pool> tp,
-        async_overflow_policy overflow_policy = async_overflow_policy::block_retry);
+        async_overflow_policy overflow_policy = async_overflow_policy::block);
 
     async_logger(const std::string &logger_name, sinks_init_list sinks, std::weak_ptr<details::thread_pool> tp,
-        async_overflow_policy overflow_policy = async_overflow_policy::block_retry);
+        async_overflow_policy overflow_policy = async_overflow_policy::block);
 
     async_logger(const std::string &logger_name, sink_ptr single_sink, std::weak_ptr<details::thread_pool> tp,
-        async_overflow_policy overflow_policy = async_overflow_policy::block_retry);
+        async_overflow_policy overflow_policy = async_overflow_policy::block);
 
 protected:
     void sink_it_(details::log_msg &msg) override;
diff --git a/include/spdlog/common.h b/include/spdlog/common.h
index 34c91714..9e0697b2 100644
--- a/include/spdlog/common.h
+++ b/include/spdlog/common.h
@@ -63,6 +63,7 @@ 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
@@ -126,8 +127,8 @@ using level_hasher = std::hash<int>;
 //
 enum class async_overflow_policy
 {
-    block_retry,    // Block until message can be enqueued
-    overrun_oldeset // Discard oldest message in the queue if full when trying to add new item.
+    block,          // Block until message can be enqueued
+    overrun_oldest  // Discard oldest message in the queue if full when trying to add new item.
 };
 
 //
diff --git a/include/spdlog/details/thread_pool.h b/include/spdlog/details/thread_pool.h
index 35641e43..4c4792df 100644
--- a/include/spdlog/details/thread_pool.h
+++ b/include/spdlog/details/thread_pool.h
@@ -106,14 +106,13 @@ public:
         {
             for (size_t i = 0; i < threads_.size(); i++)
             {
-                post_async_msg_(async_msg(async_msg_type::terminate), async_overflow_policy::block_retry);
+                post_async_msg_(async_msg(async_msg_type::terminate), async_overflow_policy::block);
             }
 
             for (auto &t : threads_)
             {
                 t.join();
             }
-            // std::cout << "~thread_pool()  msg_counter_: " << msg_counter_ << std::endl;
         }
         catch (...)
         {
@@ -138,7 +137,7 @@ private:
 
     void post_async_msg_(async_msg &&new_msg, async_overflow_policy overflow_policy)
     {
-        if (overflow_policy == async_overflow_policy::block_retry)
+        if (overflow_policy == async_overflow_policy::block)
         {
             q_.enqueue(std::move(new_msg));
         }
diff --git a/tests/test_async.cpp b/tests/test_async.cpp
index fd53504a..467b37a6 100644
--- a/tests/test_async.cpp
+++ b/tests/test_async.cpp
@@ -11,7 +11,7 @@ TEST_CASE("basic async test ", "[async]")
     size_t messages = 256;
     {
         auto tp = std::make_shared<details::thread_pool>(queue_size, 1);
-        auto logger = std::make_shared<async_logger>("as", test_sink, tp, async_overflow_policy::block_retry);
+        auto logger = std::make_shared<async_logger>("as", test_sink, tp, async_overflow_policy::block);
         for (size_t i = 0; i < messages; i++)
         {
             logger->info("Hello message #{}", i);
@@ -30,7 +30,7 @@ TEST_CASE("discard policy ", "[async]")
     size_t messages = 1024;
     {
         auto tp = std::make_shared<details::thread_pool>(queue_size, 1);
-        auto logger = std::make_shared<async_logger>("as", test_sink, tp, async_overflow_policy::overrun_oldeset);
+        auto logger = std::make_shared<async_logger>("as", test_sink, tp, async_overflow_policy::overrun_oldest);
         for (size_t i = 0; i < messages; i++)
         {
             logger->info("Hello message #{}", i);
@@ -48,7 +48,7 @@ TEST_CASE("flush", "[async]")
     size_t messages = 256;
     {
         auto tp = std::make_shared<details::thread_pool>(queue_size, 1);
-        auto logger = std::make_shared<async_logger>("as", test_sink, tp, async_overflow_policy::block_retry);
+        auto logger = std::make_shared<async_logger>("as", test_sink, tp, async_overflow_policy::block);
         for (size_t i = 0; i < messages; i++)
         {
             logger->info("Hello message #{}", i);
@@ -69,7 +69,7 @@ TEST_CASE("tp->wait_empty() ", "[async]")
     size_t messages = 100;
 
     auto tp = std::make_shared<details::thread_pool>(messages, 2);
-    auto logger = std::make_shared<async_logger>("as", test_sink, tp, async_overflow_policy::block_retry);
+    auto logger = std::make_shared<async_logger>("as", test_sink, tp, async_overflow_policy::block);
     for (size_t i = 0; i < messages; i++)
     {
         logger->info("Hello message #{}", i);
@@ -90,7 +90,7 @@ TEST_CASE("multi threads", "[async]")
     size_t n_threads = 10;
     {
         auto tp = std::make_shared<details::thread_pool>(queue_size, 1);
-        auto logger = std::make_shared<async_logger>("as", test_sink, tp, async_overflow_policy::block_retry);
+        auto logger = std::make_shared<async_logger>("as", test_sink, tp, async_overflow_policy::block);
 
         std::vector<std::thread> threads;
         for (size_t i = 0; i < n_threads; i++)

From 45da6c9c33f8177c4cf381e56a8baf0dcebf0c2d Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Sun, 8 Jul 2018 00:56:05 +0300
Subject: [PATCH 21/50] spelling

---
 include/spdlog/details/async_logger_impl.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/spdlog/details/async_logger_impl.h b/include/spdlog/details/async_logger_impl.h
index 9b3b86d3..a3e6fb98 100644
--- a/include/spdlog/details/async_logger_impl.h
+++ b/include/spdlog/details/async_logger_impl.h
@@ -60,7 +60,7 @@ inline void spdlog::async_logger::flush_()
     }
     else
     {
-        throw spdlog_ex("async flush: thread pool doens't exist anymore");
+        throw spdlog_ex("async flush: thread pool doesn't exist anymore");
     }
 }
 

From 887326e715e4e2025e264040e6ee78ea79f10f2b Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Sun, 8 Jul 2018 01:41:32 +0300
Subject: [PATCH 22/50] minor code cleanup

---
 include/spdlog/common.h                    |  4 ++--
 include/spdlog/details/pattern_formatter.h | 12 ++++--------
 include/spdlog/sinks/sink.h                | 12 +-----------
 3 files changed, 7 insertions(+), 21 deletions(-)

diff --git a/include/spdlog/common.h b/include/spdlog/common.h
index 9e0697b2..521ee1e3 100644
--- a/include/spdlog/common.h
+++ b/include/spdlog/common.h
@@ -127,8 +127,8 @@ using level_hasher = std::hash<int>;
 //
 enum class async_overflow_policy
 {
-    block,          // Block until message can be enqueued
-    overrun_oldest  // Discard oldest message in the queue if full when trying to add new item.
+    block,         // Block until message can be enqueued
+    overrun_oldest // Discard oldest message in the queue if full when trying to add new item.
 };
 
 //
diff --git a/include/spdlog/details/pattern_formatter.h b/include/spdlog/details/pattern_formatter.h
index a5ebe923..02c749f7 100644
--- a/include/spdlog/details/pattern_formatter.h
+++ b/include/spdlog/details/pattern_formatter.h
@@ -329,23 +329,19 @@ public:
         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 = '-';
+            dest.push_back('-');
         }
         else
         {
-            sign = '+';
+            dest.push_back('+');
         }
 
-        int h = total_minutes / 60;
-        int m = total_minutes % 60;
-        dest.push_back(sign);
-        fmt_helper::pad2(h, dest);
+        fmt_helper::pad2(total_minutes / 60, dest); //hours
         dest.push_back(':');
-        fmt_helper::pad2(m, dest);
+        fmt_helper::pad2(total_minutes % 60, dest); //minutes
     }
 
 private:
diff --git a/include/spdlog/sinks/sink.h b/include/spdlog/sinks/sink.h
index 39eb0abb..bc044f3d 100644
--- a/include/spdlog/sinks/sink.h
+++ b/include/spdlog/sinks/sink.h
@@ -19,17 +19,7 @@ public:
         : formatter_(std::unique_ptr<spdlog::formatter>(new pattern_formatter("%+")))
     {
     }
-    //
-    //    explicit sink(const std::string &formatter_pattern)
-    //        : formatter_(std::unique_ptr<spdlog::formatter>(new pattern_formatter(formatter_pattern)))
-    //    {
-    //    }
-    //
-    //    // sink with custom formatter
-    //    explicit sink(std::unique_ptr<spdlog::formatter> sink_formatter)
-    //        : formatter_(std::move(sink_formatter))
-    //    {
-    //    }
+
 
     virtual ~sink() = default;
 

From f4771be70edfafdec30f2a15c3186d640d9bc2bf Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Sun, 8 Jul 2018 11:03:43 +0300
Subject: [PATCH 23/50] Upgraded to fmt 5.1.0

---
 include/spdlog/fmt/bundled/core.h       | 1907 +++----
 include/spdlog/fmt/bundled/format-inl.h |  792 +--
 include/spdlog/fmt/bundled/format.cc    |   46 -
 include/spdlog/fmt/bundled/format.h     | 6463 +++++++++++------------
 include/spdlog/fmt/bundled/ostream.h    |  211 +-
 include/spdlog/fmt/bundled/posix.h      |  559 +-
 include/spdlog/fmt/bundled/printf.h     | 1148 ++--
 include/spdlog/fmt/bundled/ranges.h     |  431 +-
 include/spdlog/fmt/bundled/time.h       |  261 +-
 9 files changed, 5382 insertions(+), 6436 deletions(-)
 delete mode 100644 include/spdlog/fmt/bundled/format.cc

diff --git a/include/spdlog/fmt/bundled/core.h b/include/spdlog/fmt/bundled/core.h
index 60135a0f..1303f559 100644
--- a/include/spdlog/fmt/bundled/core.h
+++ b/include/spdlog/fmt/bundled/core.h
@@ -19,187 +19,199 @@
 #define FMT_VERSION 50100
 
 #ifdef __has_feature
-#define FMT_HAS_FEATURE(x) __has_feature(x)
+# define FMT_HAS_FEATURE(x) __has_feature(x)
 #else
-#define FMT_HAS_FEATURE(x) 0
+# define FMT_HAS_FEATURE(x) 0
 #endif
 
 #ifdef __has_include
-#define FMT_HAS_INCLUDE(x) __has_include(x)
+# define FMT_HAS_INCLUDE(x) __has_include(x)
 #else
-#define FMT_HAS_INCLUDE(x) 0
+# define FMT_HAS_INCLUDE(x) 0
 #endif
 
 #ifdef __has_cpp_attribute
-#define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
+# define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
 #else
-#define FMT_HAS_CPP_ATTRIBUTE(x) 0
+# define FMT_HAS_CPP_ATTRIBUTE(x) 0
 #endif
 
 #if defined(__GNUC__) && !defined(__clang__)
-#define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
+# define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
 #else
-#define FMT_GCC_VERSION 0
+# define FMT_GCC_VERSION 0
 #endif
 
 #if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__)
-#define FMT_HAS_GXX_CXX11 FMT_GCC_VERSION
+# define FMT_HAS_GXX_CXX11 FMT_GCC_VERSION
 #else
-#define FMT_HAS_GXX_CXX11 0
+# define FMT_HAS_GXX_CXX11 0
 #endif
 
 #ifdef _MSC_VER
-#define FMT_MSC_VER _MSC_VER
+# define FMT_MSC_VER _MSC_VER
 #else
-#define FMT_MSC_VER 0
+# define FMT_MSC_VER 0
 #endif
 
 // Check if relaxed c++14 constexpr is supported.
 // GCC doesn't allow throw in constexpr until version 6 (bug 67371).
 #ifndef FMT_USE_CONSTEXPR
-#define FMT_USE_CONSTEXPR                                                                                                                  \
-    (FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VER >= 1910 || (FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L))
+# define FMT_USE_CONSTEXPR \
+  (FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VER >= 1910 || \
+   (FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L))
 #endif
 #if FMT_USE_CONSTEXPR
-#define FMT_CONSTEXPR constexpr
-#define FMT_CONSTEXPR_DECL constexpr
+# define FMT_CONSTEXPR constexpr
+# define FMT_CONSTEXPR_DECL constexpr
 #else
-#define FMT_CONSTEXPR inline
-#define FMT_CONSTEXPR_DECL
+# define FMT_CONSTEXPR inline
+# define FMT_CONSTEXPR_DECL
 #endif
 
 #ifndef FMT_OVERRIDE
-#if 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
+# if 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
 
-#if FMT_HAS_FEATURE(cxx_explicit_conversions) || FMT_MSC_VER >= 1800
-#define FMT_EXPLICIT explicit
+#if FMT_HAS_FEATURE(cxx_explicit_conversions) || \
+    FMT_MSC_VER >= 1800
+# define FMT_EXPLICIT explicit
 #else
-#define FMT_EXPLICIT
+# define FMT_EXPLICIT
 #endif
 
 #ifndef FMT_NULL
-#if FMT_HAS_FEATURE(cxx_nullptr) || (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1600
-#define FMT_NULL nullptr
-#define FMT_USE_NULLPTR 1
-#else
-#define FMT_NULL NULL
-#endif
+# if FMT_HAS_FEATURE(cxx_nullptr) || \
+   (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || \
+   FMT_MSC_VER >= 1600
+#  define FMT_NULL nullptr
+#  define FMT_USE_NULLPTR 1
+# else
+#  define FMT_NULL NULL
+# endif
 #endif
 
 #ifndef FMT_USE_NULLPTR
-#define FMT_USE_NULLPTR 0
+# define FMT_USE_NULLPTR 0
 #endif
 
 #if FMT_HAS_CPP_ATTRIBUTE(noreturn)
-#define FMT_NORETURN [[noreturn]]
+# define FMT_NORETURN [[noreturn]]
 #else
-#define FMT_NORETURN
+# define FMT_NORETURN
 #endif
 
 // Check if exceptions are disabled.
 #if defined(__GNUC__) && !defined(__EXCEPTIONS)
-#define FMT_EXCEPTIONS 0
+# define FMT_EXCEPTIONS 0
 #elif FMT_MSC_VER && !_HAS_EXCEPTIONS
-#define FMT_EXCEPTIONS 0
+# define FMT_EXCEPTIONS 0
 #endif
 #ifndef FMT_EXCEPTIONS
-#define FMT_EXCEPTIONS 1
+# define FMT_EXCEPTIONS 1
 #endif
 
 // Define FMT_USE_NOEXCEPT to make fmt use noexcept (C++11 feature).
 #ifndef FMT_USE_NOEXCEPT
-#define FMT_USE_NOEXCEPT 0
+# define FMT_USE_NOEXCEPT 0
 #endif
 
-#if FMT_USE_NOEXCEPT || FMT_HAS_FEATURE(cxx_noexcept) || (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900
-#define FMT_DETECTED_NOEXCEPT noexcept
+#if FMT_USE_NOEXCEPT || FMT_HAS_FEATURE(cxx_noexcept) || \
+    (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || \
+    FMT_MSC_VER >= 1900
+# define FMT_DETECTED_NOEXCEPT noexcept
 #else
-#define FMT_DETECTED_NOEXCEPT throw()
+# define FMT_DETECTED_NOEXCEPT throw()
 #endif
 
 #ifndef FMT_NOEXCEPT
-#if FMT_EXCEPTIONS
-#define FMT_NOEXCEPT FMT_DETECTED_NOEXCEPT
-#else
-#define FMT_NOEXCEPT
-#endif
+# if FMT_EXCEPTIONS
+#  define FMT_NOEXCEPT FMT_DETECTED_NOEXCEPT
+# else
+#  define FMT_NOEXCEPT
+# endif
 #endif
 
 // This is needed because GCC still uses throw() in its headers when exceptions
 // are disabled.
 #if FMT_GCC_VERSION
-#define FMT_DTOR_NOEXCEPT FMT_DETECTED_NOEXCEPT
+# define FMT_DTOR_NOEXCEPT FMT_DETECTED_NOEXCEPT
 #else
-#define FMT_DTOR_NOEXCEPT FMT_NOEXCEPT
+# define FMT_DTOR_NOEXCEPT FMT_NOEXCEPT
 #endif
 
 #ifndef FMT_BEGIN_NAMESPACE
-#if FMT_HAS_FEATURE(cxx_inline_namespaces) || FMT_GCC_VERSION >= 404 || FMT_MSC_VER >= 1900
-#define FMT_INLINE_NAMESPACE inline namespace
-#define FMT_END_NAMESPACE                                                                                                                  \
-    }                                                                                                                                      \
-    }
-#else
-#define FMT_INLINE_NAMESPACE namespace
-#define FMT_END_NAMESPACE                                                                                                                  \
-    }                                                                                                                                      \
-    using namespace v5;                                                                                                                    \
-    }
-#endif
-#define FMT_BEGIN_NAMESPACE                                                                                                                \
-    namespace fmt {                                                                                                                        \
-    FMT_INLINE_NAMESPACE v5                                                                                                                \
-    {
+# if FMT_HAS_FEATURE(cxx_inline_namespaces) || FMT_GCC_VERSION >= 404 || \
+     FMT_MSC_VER >= 1900
+#  define FMT_INLINE_NAMESPACE inline namespace
+#  define FMT_END_NAMESPACE }}
+# else
+#  define FMT_INLINE_NAMESPACE namespace
+#  define FMT_END_NAMESPACE } using namespace v5; }
+# endif
+# define FMT_BEGIN_NAMESPACE namespace fmt { FMT_INLINE_NAMESPACE v5 {
 #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
+# 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
+# define FMT_API
 #endif
 
 #ifndef FMT_ASSERT
-#define FMT_ASSERT(condition, message) assert((condition) && message)
+# define FMT_ASSERT(condition, message) assert((condition) && message)
 #endif
 
 #define FMT_DELETED = delete
 
 // A macro to disallow the copy construction and assignment.
-#define FMT_DISALLOW_COPY_AND_ASSIGN(Type)                                                                                                 \
-    Type(const Type &) FMT_DELETED;                                                                                                        \
+#define FMT_DISALLOW_COPY_AND_ASSIGN(Type) \
+    Type(const Type &) FMT_DELETED; \
     void operator=(const Type &) FMT_DELETED
 
 // libc++ supports string_view in pre-c++17.
-#if (FMT_HAS_INCLUDE(<string_view>) && (__cplusplus > 201402L || defined(_LIBCPP_VERSION))) ||                                             \
+#if (FMT_HAS_INCLUDE(<string_view>) && \
+      (__cplusplus > 201402L || defined(_LIBCPP_VERSION))) || \
     (defined(_MSVC_LANG) && _MSVC_LANG > 201402L && _MSC_VER >= 1910)
-#include <string_view>
-#define FMT_USE_STD_STRING_VIEW
-#elif (FMT_HAS_INCLUDE(<experimental / string_view>) && __cplusplus >= 201402L)
-#include <experimental/string_view>
-#define FMT_USE_EXPERIMENTAL_STRING_VIEW
+# include <string_view>
+# define FMT_USE_STD_STRING_VIEW
+#elif (FMT_HAS_INCLUDE(<experimental/string_view>) && \
+       __cplusplus >= 201402L)
+# include <experimental/string_view>
+# define FMT_USE_EXPERIMENTAL_STRING_VIEW
 #endif
 
 // std::result_of is defined in <functional> in gcc 4.4.
 #if FMT_GCC_VERSION && FMT_GCC_VERSION <= 404
-#include <functional>
+# include <functional>
 #endif
 
 FMT_BEGIN_NAMESPACE
 
-// An implementation of declval for pre-C++11 compilers such as gcc 4.
 namespace internal {
-template<typename T>
+
+// An implementation of declval for pre-C++11 compilers such as gcc 4.
+template <typename T>
 typename std::add_rvalue_reference<T>::type declval() FMT_NOEXCEPT;
+
+// Casts nonnegative integer to unsigned.
+template <typename Int>
+FMT_CONSTEXPR typename std::make_unsigned<Int>::type to_unsigned(Int value) {
+  FMT_ASSERT(value >= 0, "negative value");
+  return static_cast<typename std::make_unsigned<Int>::type>(value);
+}
+
 }
 
 /**
@@ -209,484 +221,361 @@ typename std::add_rvalue_reference<T>::type declval() FMT_NOEXCEPT;
   compiled with a different ``-std`` option than the client code (which is not
   recommended).
  */
-template<typename Char>
-class basic_string_view
-{
-private:
-    const Char *data_;
-    size_t size_;
+template <typename Char>
+class basic_string_view {
+ private:
+  const Char *data_;
+  size_t size_;
 
-public:
-    typedef Char char_type;
-    typedef const Char *iterator;
+ public:
+  typedef Char char_type;
+  typedef const Char *iterator;
 
-    // Standard basic_string_view type.
+  // Standard basic_string_view type.
 #if defined(FMT_USE_STD_STRING_VIEW)
-    typedef std::basic_string_view<Char> type;
+  typedef std::basic_string_view<Char> type;
 #elif defined(FMT_USE_EXPERIMENTAL_STRING_VIEW)
-    typedef std::experimental::basic_string_view<Char> type;
+  typedef std::experimental::basic_string_view<Char> type;
 #else
-    struct type
-    {
-        const char *data() const
-        {
-            return FMT_NULL;
-        }
-        size_t size() const
-        {
-            return 0;
-        }
-    };
+  struct type {
+    const char *data() const { return FMT_NULL; }
+    size_t size() const { return 0; }
+  };
 #endif
 
-    FMT_CONSTEXPR basic_string_view() FMT_NOEXCEPT : data_(FMT_NULL), size_(0) {}
+  FMT_CONSTEXPR basic_string_view() FMT_NOEXCEPT : data_(FMT_NULL), size_(0) {}
 
-    /** Constructs a string reference object from a C string and a size. */
-    FMT_CONSTEXPR basic_string_view(const Char *s, size_t str_size) FMT_NOEXCEPT : data_(s), size_(str_size) {}
+  /** Constructs a string reference object from a C string and a size. */
+  FMT_CONSTEXPR basic_string_view(const Char *s, size_t count) FMT_NOEXCEPT
+    : data_(s), size_(count) {}
 
-    /**
-      \rst
-      Constructs a string reference object from a C string computing
-      the size with ``std::char_traits<Char>::length``.
-      \endrst
-     */
-    basic_string_view(const Char *s)
-        : data_(s)
-        , size_(std::char_traits<Char>::length(s))
-    {
-    }
+  /**
+    \rst
+    Constructs a string reference object from a C string computing
+    the size with ``std::char_traits<Char>::length``.
+    \endrst
+   */
+  basic_string_view(const Char *s)
+    : data_(s), size_(std::char_traits<Char>::length(s)) {}
 
-    /** Constructs a string reference from a ``std::basic_string`` object. */
-    template<typename Alloc>
-    FMT_CONSTEXPR basic_string_view(const std::basic_string<Char, Alloc> &s) FMT_NOEXCEPT : data_(s.c_str()), size_(s.size())
-    {
-    }
+  /** Constructs a string reference from a ``std::basic_string`` object. */
+  template <typename Alloc>
+  FMT_CONSTEXPR basic_string_view(
+      const std::basic_string<Char, Alloc> &s) FMT_NOEXCEPT
+  : data_(s.c_str()), size_(s.size()) {}
 
-    FMT_CONSTEXPR basic_string_view(type s) FMT_NOEXCEPT : data_(s.data()), size_(s.size()) {}
+  FMT_CONSTEXPR basic_string_view(type s) FMT_NOEXCEPT
+  : data_(s.data()), size_(s.size()) {}
 
-    /** Returns a pointer to the string data. */
-    const Char *data() const
-    {
-        return data_;
-    }
+  /** Returns a pointer to the string data. */
+  const Char *data() const { return data_; }
 
-    /** Returns the string size. */
-    FMT_CONSTEXPR size_t size() const
-    {
-        return size_;
-    }
+  /** Returns the string size. */
+  FMT_CONSTEXPR size_t size() const { return size_; }
 
-    FMT_CONSTEXPR iterator begin() const
-    {
-        return data_;
-    }
-    FMT_CONSTEXPR iterator end() const
-    {
-        return data_ + size_;
-    }
+  FMT_CONSTEXPR iterator begin() const { return data_; }
+  FMT_CONSTEXPR iterator end() const { return data_ + size_; }
 
-    FMT_CONSTEXPR void remove_prefix(size_t n)
-    {
-        data_ += n;
-        size_ -= n;
-    }
+  FMT_CONSTEXPR void remove_prefix(size_t n) {
+    data_ += n;
+    size_ -= n;
+  }
 
-    // Lexicographically compare this string reference to other.
-    int compare(basic_string_view other) const
-    {
-        size_t str_size = size_ < other.size_ ? size_ : other.size_;
-        int result = std::char_traits<Char>::compare(data_, other.data_, str_size);
-        if (result == 0)
-            result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);
-        return result;
-    }
+  // Lexicographically compare this string reference to other.
+  int compare(basic_string_view other) const {
+    size_t str_size = size_ < other.size_ ? size_ : other.size_;
+    int result = std::char_traits<Char>::compare(data_, other.data_, str_size);
+    if (result == 0)
+      result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);
+    return result;
+  }
 
-    friend bool operator==(basic_string_view lhs, basic_string_view rhs)
-    {
-        return lhs.compare(rhs) == 0;
-    }
-    friend bool operator!=(basic_string_view lhs, basic_string_view rhs)
-    {
-        return lhs.compare(rhs) != 0;
-    }
-    friend bool operator<(basic_string_view lhs, basic_string_view rhs)
-    {
-        return lhs.compare(rhs) < 0;
-    }
-    friend bool operator<=(basic_string_view lhs, basic_string_view rhs)
-    {
-        return lhs.compare(rhs) <= 0;
-    }
-    friend bool operator>(basic_string_view lhs, basic_string_view rhs)
-    {
-        return lhs.compare(rhs) > 0;
-    }
-    friend bool operator>=(basic_string_view lhs, basic_string_view rhs)
-    {
-        return lhs.compare(rhs) >= 0;
-    }
+  friend bool operator==(basic_string_view lhs, basic_string_view rhs) {
+    return lhs.compare(rhs) == 0;
+  }
+  friend bool operator!=(basic_string_view lhs, basic_string_view rhs) {
+    return lhs.compare(rhs) != 0;
+  }
+  friend bool operator<(basic_string_view lhs, basic_string_view rhs) {
+    return lhs.compare(rhs) < 0;
+  }
+  friend bool operator<=(basic_string_view lhs, basic_string_view rhs) {
+    return lhs.compare(rhs) <= 0;
+  }
+  friend bool operator>(basic_string_view lhs, basic_string_view rhs) {
+    return lhs.compare(rhs) > 0;
+  }
+  friend bool operator>=(basic_string_view lhs, basic_string_view rhs) {
+    return lhs.compare(rhs) >= 0;
+  }
 };
 
 typedef basic_string_view<char> string_view;
 typedef basic_string_view<wchar_t> wstring_view;
 
-template<typename Context>
+template <typename Context>
 class basic_format_arg;
 
-template<typename Context>
+template <typename Context>
 class basic_format_args;
 
 // A formatter for objects of type T.
-template<typename T, typename Char = char, typename Enable = void>
+template <typename T, typename Char = char, typename Enable = void>
 struct formatter;
 
 namespace internal {
 
 /** A contiguous memory buffer with an optional growing ability. */
-template<typename T>
-class basic_buffer
-{
-private:
-    FMT_DISALLOW_COPY_AND_ASSIGN(basic_buffer);
+template <typename T>
+class basic_buffer {
+ private:
+  FMT_DISALLOW_COPY_AND_ASSIGN(basic_buffer);
 
-    T *ptr_;
-    std::size_t size_;
-    std::size_t capacity_;
+  T *ptr_;
+  std::size_t size_;
+  std::size_t capacity_;
 
-protected:
-    basic_buffer(T *p = FMT_NULL, std::size_t buf_size = 0, std::size_t buf_capacity = 0) FMT_NOEXCEPT : ptr_(p),
-                                                                                                         size_(buf_size),
-                                                                                                         capacity_(buf_capacity)
-    {
-    }
+ protected:
+  basic_buffer(T *p = FMT_NULL, std::size_t sz = 0, std::size_t cap = 0)
+    FMT_NOEXCEPT: ptr_(p), size_(sz), capacity_(cap) {}
 
-    /** Sets the buffer data and capacity. */
-    void set(T *buf_data, std::size_t buf_capacity) FMT_NOEXCEPT
-    {
-        ptr_ = buf_data;
-        capacity_ = buf_capacity;
-    }
+  /** Sets the buffer data and capacity. */
+  void set(T *buf_data, std::size_t buf_capacity) FMT_NOEXCEPT {
+    ptr_ = buf_data;
+    capacity_ = buf_capacity;
+  }
 
-    /** Increases the buffer capacity to hold at least *capacity* elements. */
-    virtual void grow(std::size_t capacity) = 0;
+  /** Increases the buffer capacity to hold at least *capacity* elements. */
+  virtual void grow(std::size_t capacity) = 0;
 
-public:
-    typedef T value_type;
-    typedef const T &const_reference;
+ public:
+  typedef T value_type;
+  typedef const T &const_reference;
 
-    virtual ~basic_buffer() {}
+  virtual ~basic_buffer() {}
 
-    T *begin() FMT_NOEXCEPT
-    {
-        return ptr_;
-    }
-    T *end() FMT_NOEXCEPT
-    {
-        return ptr_ + size_;
-    }
+  T *begin() FMT_NOEXCEPT { return ptr_; }
+  T *end() FMT_NOEXCEPT { return ptr_ + size_; }
 
-    /** Returns the size of this buffer. */
-    std::size_t size() const FMT_NOEXCEPT
-    {
-        return size_;
-    }
+  /** Returns the size of this buffer. */
+  std::size_t size() const FMT_NOEXCEPT { return size_; }
 
-    /** Returns the capacity of this buffer. */
-    std::size_t capacity() const FMT_NOEXCEPT
-    {
-        return capacity_;
-    }
+  /** Returns the capacity of this buffer. */
+  std::size_t capacity() const FMT_NOEXCEPT { return capacity_; }
 
-    /** Returns a pointer to the buffer data. */
-    T *data() FMT_NOEXCEPT
-    {
-        return ptr_;
-    }
+  /** Returns a pointer to the buffer data. */
+  T *data() FMT_NOEXCEPT { return ptr_; }
 
-    /** Returns a pointer to the buffer data. */
-    const T *data() const FMT_NOEXCEPT
-    {
-        return ptr_;
-    }
+  /** Returns a pointer to the buffer data. */
+  const T *data() const FMT_NOEXCEPT { return ptr_; }
 
-    /**
-      Resizes the buffer. If T is a POD type new elements may not be initialized.
-     */
-    void resize(std::size_t new_size)
-    {
-        reserve(new_size);
-        size_ = new_size;
-    }
+  /**
+    Resizes the buffer. If T is a POD type new elements may not be initialized.
+   */
+  void resize(std::size_t new_size) {
+    reserve(new_size);
+    size_ = new_size;
+  }
 
-    /** Reserves space to store at least *buf_capacity* elements. */
-    void reserve(std::size_t buf_capacity)
-    {
-        if (buf_capacity > capacity_)
-            grow(buf_capacity);
-    }
+  /** Reserves space to store at least *capacity* elements. */
+  void reserve(std::size_t new_capacity) {
+    if (new_capacity > capacity_)
+      grow(new_capacity);
+  }
 
-    void push_back(const T &value)
-    {
-        reserve(size_ + 1);
-        ptr_[size_++] = value;
-    }
+  void push_back(const T &value) {
+    reserve(size_ + 1);
+    ptr_[size_++] = value;
+  }
 
-    /** Appends data to the end of the buffer. */
-    template<typename U>
-    void append(const U *begin, const U *end);
+  /** 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];
-    }
+  T &operator[](std::size_t index) { return ptr_[index]; }
+  const T &operator[](std::size_t index) const { return ptr_[index]; }
 };
 
 typedef basic_buffer<char> buffer;
 typedef basic_buffer<wchar_t> wbuffer;
 
 // A container-backed buffer.
-template<typename Container>
-class container_buffer : public basic_buffer<typename Container::value_type>
-{
-private:
-    Container &container_;
+template <typename Container>
+class container_buffer : public basic_buffer<typename Container::value_type> {
+ private:
+  Container &container_;
 
-protected:
-    void grow(std::size_t capacity) FMT_OVERRIDE
-    {
-        container_.resize(capacity);
-        this->set(&container_[0], capacity);
-    }
+ protected:
+  void grow(std::size_t capacity) FMT_OVERRIDE {
+    container_.resize(capacity);
+    this->set(&container_[0], capacity);
+  }
 
-public:
-    explicit container_buffer(Container &c)
-        : basic_buffer<typename Container::value_type>(&c[0], c.size(), c.size())
-        , container_(c)
-    {
-    }
+ public:
+  explicit container_buffer(Container &c)
+    : basic_buffer<typename Container::value_type>(&c[0], c.size(), c.size()),
+      container_(c) {}
 };
 
-struct error_handler
-{
-    FMT_CONSTEXPR error_handler() {}
-    FMT_CONSTEXPR error_handler(const error_handler &) {}
+struct error_handler {
+  FMT_CONSTEXPR error_handler() {}
+  FMT_CONSTEXPR error_handler(const error_handler &) {}
 
-    // This function is intentionally not constexpr to give a compile-time error.
-    FMT_API void on_error(const char *message);
+  // This function is intentionally not constexpr to give a compile-time error.
+  FMT_API void on_error(const char *message);
 };
 
 // Formatting of wide characters and strings into a narrow output is disallowed:
 //   fmt::format("{}", L"test"); // error
 // To fix this, use a wide format string:
 //   fmt::format(L"{}", L"test");
-template<typename Char>
-inline void require_wchar()
-{
-    static_assert(std::is_same<wchar_t, Char>::value, "formatting of wide characters into a narrow output is disallowed");
+template <typename Char>
+inline void require_wchar() {
+  static_assert(
+      std::is_same<wchar_t, Char>::value,
+      "formatting of wide characters into a narrow output is disallowed");
 }
 
-template<typename Char>
+template <typename Char>
 struct named_arg_base;
 
-template<typename T, typename Char>
+template <typename T, typename Char>
 struct named_arg;
 
-template<typename T>
-struct is_named_arg : std::false_type
-{
+template <typename T>
+struct is_named_arg : std::false_type {};
+
+template <typename T, typename Char>
+struct is_named_arg<named_arg<T, Char>> : std::true_type {};
+
+enum type {
+  none_type, named_arg_type,
+  // Integer types should go first,
+  int_type, uint_type, long_long_type, ulong_long_type, bool_type, char_type,
+  last_integer_type = char_type,
+  // followed by floating-point types.
+  double_type, long_double_type, last_numeric_type = long_double_type,
+  cstring_type, string_type, pointer_type, custom_type
 };
 
-template<typename T, typename Char>
-struct is_named_arg<named_arg<T, Char>> : std::true_type
-{
-};
-
-enum type
-{
-    none_type,
-    named_arg_type,
-    // Integer types should go first,
-    int_type,
-    uint_type,
-    long_long_type,
-    ulong_long_type,
-    bool_type,
-    char_type,
-    last_integer_type = char_type,
-    // followed by floating-point types.
-    double_type,
-    long_double_type,
-    last_numeric_type = long_double_type,
-    cstring_type,
-    string_type,
-    pointer_type,
-    custom_type
-};
-
-FMT_CONSTEXPR bool is_integral(type t)
-{
-    FMT_ASSERT(t != internal::named_arg_type, "invalid argument type");
-    return t > internal::none_type && t <= internal::last_integer_type;
+FMT_CONSTEXPR bool is_integral(type t) {
+  FMT_ASSERT(t != internal::named_arg_type, "invalid argument type");
+  return t > internal::none_type && t <= internal::last_integer_type;
 }
 
-FMT_CONSTEXPR bool is_arithmetic(type t)
-{
-    FMT_ASSERT(t != internal::named_arg_type, "invalid argument type");
-    return t > internal::none_type && t <= internal::last_numeric_type;
+FMT_CONSTEXPR bool is_arithmetic(type t) {
+  FMT_ASSERT(t != internal::named_arg_type, "invalid argument type");
+  return t > internal::none_type && t <= internal::last_numeric_type;
 }
 
-template<typename T, typename Char, bool ENABLE = true>
-struct convert_to_int
-{
-    enum
-    {
-        value = !std::is_arithmetic<T>::value && std::is_convertible<T, int>::value
-    };
+template <typename T, typename Char, bool ENABLE = true>
+struct convert_to_int {
+  enum {
+    value = !std::is_arithmetic<T>::value && std::is_convertible<T, int>::value
+  };
 };
 
-template<typename Char>
-struct string_value
-{
-    const Char *value;
-    std::size_t size;
+template <typename Char>
+struct string_value {
+  const Char *value;
+  std::size_t size;
 };
 
-template<typename Context>
-struct custom_value
-{
-    const void *value;
-    void (*format)(const void *arg, Context &ctx);
+template <typename Context>
+struct custom_value {
+  const void *value;
+  void (*format)(const void *arg, Context &ctx);
 };
 
 // A formatting argument value.
-template<typename Context>
-class value
-{
-public:
-    typedef typename Context::char_type char_type;
+template <typename Context>
+class value {
+ public:
+  typedef typename Context::char_type char_type;
 
-    union
-    {
-        int int_value;
-        unsigned uint_value;
-        long long long_long_value;
-        unsigned long long ulong_long_value;
-        double double_value;
-        long double long_double_value;
-        const void *pointer;
-        string_value<char_type> string;
-        string_value<signed char> sstring;
-        string_value<unsigned char> ustring;
-        custom_value<Context> custom;
-    };
+  union {
+    int int_value;
+    unsigned uint_value;
+    long long long_long_value;
+    unsigned long long ulong_long_value;
+    double double_value;
+    long double long_double_value;
+    const void *pointer;
+    string_value<char_type> string;
+    string_value<signed char> sstring;
+    string_value<unsigned char> ustring;
+    custom_value<Context> custom;
+  };
 
-    FMT_CONSTEXPR value(int val = 0)
-        : int_value(val)
-    {
-    }
-    value(unsigned val)
-    {
-        uint_value = val;
-    }
-    value(long long val)
-    {
-        long_long_value = val;
-    }
-    value(unsigned long long val)
-    {
-        ulong_long_value = val;
-    }
-    value(double val)
-    {
-        double_value = val;
-    }
-    value(long double val)
-    {
-        long_double_value = val;
-    }
-    value(const char_type *val)
-    {
-        string.value = val;
-    }
-    value(const signed char *val)
-    {
-        static_assert(std::is_same<char, char_type>::value, "incompatible string types");
-        sstring.value = val;
-    }
-    value(const unsigned char *val)
-    {
-        static_assert(std::is_same<char, char_type>::value, "incompatible string types");
-        ustring.value = val;
-    }
-    value(basic_string_view<char_type> val)
-    {
-        string.value = val.data();
-        string.size = val.size();
-    }
-    value(const void *val)
-    {
-        pointer = val;
-    }
+  FMT_CONSTEXPR value(int val = 0) : int_value(val) {}
+  value(unsigned val) { uint_value = val; }
+  value(long long val) { long_long_value = val; }
+  value(unsigned long long val) { ulong_long_value = val; }
+  value(double val) { double_value = val; }
+  value(long double val) { long_double_value = val; }
+  value(const char_type *val) { string.value = val; }
+  value(const signed char *val) {
+    static_assert(std::is_same<char, char_type>::value,
+                  "incompatible string types");
+    sstring.value = val;
+  }
+  value(const unsigned char *val) {
+    static_assert(std::is_same<char, char_type>::value,
+                  "incompatible string types");
+    ustring.value = val;
+  }
+  value(basic_string_view<char_type> val) {
+    string.value = val.data();
+    string.size = val.size();
+  }
+  value(const void *val) { pointer = val; }
 
-    template<typename T>
-    explicit value(const T &val)
-    {
-        custom.value = &val;
-        custom.format = &format_custom_arg<T>;
-    }
+  template <typename T>
+  explicit value(const T &val) {
+    custom.value = &val;
+    custom.format = &format_custom_arg<T>;
+  }
 
-    const named_arg_base<char_type> &as_named_arg()
-    {
-        return *static_cast<const named_arg_base<char_type> *>(pointer);
-    }
+  const named_arg_base<char_type> &as_named_arg() {
+    return *static_cast<const named_arg_base<char_type>*>(pointer);
+  }
 
-private:
-    // Formats an argument of a custom type, such as a user-defined class.
-    template<typename T>
-    static void format_custom_arg(const void *arg, Context &ctx)
-    {
-        // Get the formatter type through the context to allow different contexts
-        // have different extension points, e.g. `formatter<T>` for `format` and
-        // `printf_formatter<T>` for `printf`.
-        typename Context::template formatter_type<T>::type f;
-        auto &&parse_ctx = ctx.parse_context();
-        parse_ctx.advance_to(f.parse(parse_ctx));
-        ctx.advance_to(f.format(*static_cast<const T *>(arg), ctx));
-    }
+ private:
+  // Formats an argument of a custom type, such as a user-defined class.
+  template <typename T>
+  static void format_custom_arg(const void *arg, Context &ctx) {
+    // Get the formatter type through the context to allow different contexts
+    // have different extension points, e.g. `formatter<T>` for `format` and
+    // `printf_formatter<T>` for `printf`.
+    typename Context::template formatter_type<T>::type f;
+    auto &&parse_ctx = ctx.parse_context();
+    parse_ctx.advance_to(f.parse(parse_ctx));
+    ctx.advance_to(f.format(*static_cast<const T*>(arg), ctx));
+  }
 };
 
-template<typename Context, type TYPE>
-struct typed_value : value<Context>
-{
-    static const type type_tag = TYPE;
+template <typename Context, type TYPE>
+struct typed_value : value<Context> {
+  static const type type_tag = TYPE;
 
-    template<typename T>
-    FMT_CONSTEXPR typed_value(const T &val)
-        : value<Context>(val)
-    {
-    }
+  template <typename T>
+  FMT_CONSTEXPR typed_value(const T &val) : value<Context>(val) {}
 };
 
-template<typename Context, typename T>
+template <typename Context, typename T>
 FMT_CONSTEXPR basic_format_arg<Context> make_arg(const T &value);
 
-#define FMT_MAKE_VALUE(TAG, ArgType, ValueType)                                                                                            \
-    template<typename C>                                                                                                                   \
-    FMT_CONSTEXPR typed_value<C, TAG> make_value(ArgType val)                                                                              \
-    {                                                                                                                                      \
-        return static_cast<ValueType>(val);                                                                                                \
-    }
+#define FMT_MAKE_VALUE(TAG, ArgType, ValueType) \
+  template <typename C> \
+  FMT_CONSTEXPR typed_value<C, TAG> make_value(ArgType val) { \
+    return static_cast<ValueType>(val); \
+  }
 
-#define FMT_MAKE_VALUE_SAME(TAG, Type)                                                                                                     \
-    template<typename C>                                                                                                                   \
-    FMT_CONSTEXPR typed_value<C, TAG> make_value(Type val)                                                                                 \
-    {                                                                                                                                      \
-        return val;                                                                                                                        \
-    }
+#define FMT_MAKE_VALUE_SAME(TAG, Type) \
+  template <typename C> \
+  FMT_CONSTEXPR typed_value<C, TAG> make_value(Type val) { \
+    return val; \
+  }
 
 FMT_MAKE_VALUE(bool_type, bool, int)
 FMT_MAKE_VALUE(int_type, short, int)
@@ -696,10 +585,15 @@ FMT_MAKE_VALUE_SAME(uint_type, unsigned)
 
 // 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.
-typedef std::conditional<sizeof(long) == sizeof(int), int, long long>::type long_type;
-FMT_MAKE_VALUE((sizeof(long) == sizeof(int) ? int_type : long_long_type), long, long_type)
-typedef std::conditional<sizeof(unsigned long) == sizeof(unsigned), unsigned, unsigned long long>::type ulong_type;
-FMT_MAKE_VALUE((sizeof(unsigned long) == sizeof(unsigned) ? uint_type : ulong_long_type), unsigned long, ulong_type)
+typedef std::conditional<sizeof(long) == sizeof(int), int, long long>::type
+        long_type;
+FMT_MAKE_VALUE(
+    (sizeof(long) == sizeof(int) ? int_type : long_long_type), long, long_type)
+typedef std::conditional<sizeof(unsigned long) == sizeof(unsigned),
+                         unsigned, unsigned long long>::type ulong_type;
+FMT_MAKE_VALUE(
+    (sizeof(unsigned long) == sizeof(unsigned) ? uint_type : ulong_long_type),
+    unsigned long, ulong_type)
 
 FMT_MAKE_VALUE_SAME(long_long_type, long long)
 FMT_MAKE_VALUE_SAME(ulong_long_type, unsigned long long)
@@ -708,11 +602,10 @@ FMT_MAKE_VALUE(uint_type, unsigned char, unsigned)
 FMT_MAKE_VALUE(char_type, char, int)
 
 #if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
-template<typename C>
-inline typed_value<C, char_type> make_value(wchar_t val)
-{
-    require_wchar<typename C::char_type>();
-    return static_cast<int>(val);
+template <typename C>
+inline typed_value<C, char_type> make_value(wchar_t val) {
+  require_wchar<typename C::char_type>();
+  return static_cast<int>(val);
 }
 #endif
 
@@ -722,204 +615,170 @@ FMT_MAKE_VALUE_SAME(long_double_type, long double)
 
 // Formatting of wide strings into a narrow buffer and multibyte strings
 // into a wide buffer is disallowed (https://github.com/fmtlib/fmt/pull/606).
-FMT_MAKE_VALUE(cstring_type, typename C::char_type *, const typename C::char_type *)
-FMT_MAKE_VALUE(cstring_type, const typename C::char_type *, const typename C::char_type *)
+FMT_MAKE_VALUE(cstring_type, typename C::char_type*,
+               const typename C::char_type*)
+FMT_MAKE_VALUE(cstring_type, const typename C::char_type*,
+               const typename C::char_type*)
 
-FMT_MAKE_VALUE(cstring_type, signed char *, const signed char *)
-FMT_MAKE_VALUE_SAME(cstring_type, const signed char *)
-FMT_MAKE_VALUE(cstring_type, unsigned char *, const unsigned char *)
-FMT_MAKE_VALUE_SAME(cstring_type, const unsigned char *)
+FMT_MAKE_VALUE(cstring_type, signed char*, const signed char*)
+FMT_MAKE_VALUE_SAME(cstring_type, const signed char*)
+FMT_MAKE_VALUE(cstring_type, unsigned char*, const unsigned char*)
+FMT_MAKE_VALUE_SAME(cstring_type, const unsigned char*)
 FMT_MAKE_VALUE_SAME(string_type, basic_string_view<typename C::char_type>)
-FMT_MAKE_VALUE(string_type, typename basic_string_view<typename C::char_type>::type, basic_string_view<typename C::char_type>)
-FMT_MAKE_VALUE(string_type, const std::basic_string<typename C::char_type> &, basic_string_view<typename C::char_type>)
-FMT_MAKE_VALUE(pointer_type, void *, const void *)
-FMT_MAKE_VALUE_SAME(pointer_type, const void *)
+FMT_MAKE_VALUE(string_type,
+               typename basic_string_view<typename C::char_type>::type,
+               basic_string_view<typename C::char_type>)
+FMT_MAKE_VALUE(string_type, const std::basic_string<typename C::char_type>&,
+               basic_string_view<typename C::char_type>)
+FMT_MAKE_VALUE(pointer_type, void*, const void*)
+FMT_MAKE_VALUE_SAME(pointer_type, const void*)
 
 #if FMT_USE_NULLPTR
-FMT_MAKE_VALUE(pointer_type, std::nullptr_t, const void *)
+FMT_MAKE_VALUE(pointer_type, std::nullptr_t, const void*)
 #endif
 
 // Formatting of arbitrary pointers is disallowed. 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.
-template<typename C, typename T>
-typename std::enable_if<!std::is_same<T, typename C::char_type>::value>::type make_value(const T *)
-{
-    static_assert(!sizeof(T), "formatting of non-void pointers is disallowed");
+template <typename C, typename T>
+typename std::enable_if<!std::is_same<T, typename C::char_type>::value>::type
+    make_value(const T *) {
+  static_assert(!sizeof(T), "formatting of non-void pointers is disallowed");
 }
 
-template<typename C, typename T>
-inline typename std::enable_if<std::is_enum<T>::value && convert_to_int<T, typename C::char_type>::value, typed_value<C, int_type>>::type
-make_value(const T &val)
-{
-    return static_cast<int>(val);
-}
+template <typename C, typename T>
+inline typename std::enable_if<
+    std::is_enum<T>::value && convert_to_int<T, typename C::char_type>::value,
+    typed_value<C, int_type>>::type
+  make_value(const T &val) { return static_cast<int>(val); }
 
-template<typename C, typename T, typename Char = typename C::char_type>
-inline typename std::enable_if<!convert_to_int<T, Char>::value && !std::is_convertible<T, basic_string_view<Char>>::value,
+template <typename C, typename T, typename Char = typename C::char_type>
+inline typename std::enable_if<
+    !convert_to_int<T, Char>::value &&
+    !std::is_convertible<T, basic_string_view<Char>>::value,
     // Implicit conversion to std::string is not handled here because it's
     // unsafe: https://github.com/fmtlib/fmt/issues/729
     typed_value<C, custom_type>>::type
-make_value(const T &val)
-{
-    return val;
-}
+  make_value(const T &val) { return val; }
 
-template<typename C, typename T>
-typed_value<C, named_arg_type> make_value(const named_arg<T, typename C::char_type> &val)
-{
-    basic_format_arg<C> arg = make_arg<C>(val.value);
-    std::memcpy(val.data, &arg, sizeof(arg));
-    return static_cast<const void *>(&val);
+template <typename C, typename T>
+typed_value<C, named_arg_type>
+    make_value(const named_arg<T, typename C::char_type> &val) {
+  basic_format_arg<C> arg = make_arg<C>(val.value);
+  std::memcpy(val.data, &arg, sizeof(arg));
+  return static_cast<const void*>(&val);
 }
 
 // Maximum number of arguments with packed types.
-enum
-{
-    max_packed_args = 15
-};
+enum { max_packed_args = 15 };
 
-template<typename Context>
+template <typename Context>
 class arg_map;
 
-template<typename>
+template <typename>
 struct result_of;
 
-template<typename F, typename... Args>
-struct result_of<F(Args...)>
-{
-    // A workaround for gcc 4.4 that doesn't allow F to be a reference.
-    typedef typename std::result_of<typename std::remove_reference<F>::type(Args...)>::type type;
+template <typename F, typename... Args>
+struct result_of<F(Args...)> {
+  // A workaround for gcc 4.4 that doesn't allow F to be a reference.
+  typedef typename std::result_of<
+    typename std::remove_reference<F>::type(Args...)>::type type;
 };
-} // namespace internal
+}
 
 // A formatting argument. It is a trivially copyable/constructible type to
 // allow storage in basic_memory_buffer.
-template<typename Context>
-class basic_format_arg
-{
-private:
-    internal::value<Context> value_;
-    internal::type type_;
+template <typename Context>
+class basic_format_arg {
+ private:
+  internal::value<Context> value_;
+  internal::type type_;
 
-    template<typename ContextType, typename T>
-    friend FMT_CONSTEXPR basic_format_arg<ContextType> internal::make_arg(const T &value);
+  template <typename ContextType, typename T>
+  friend FMT_CONSTEXPR basic_format_arg<ContextType>
+    internal::make_arg(const T &value);
 
-    template<typename Visitor, typename Ctx>
-    friend FMT_CONSTEXPR typename internal::result_of<Visitor(int)>::type visit(Visitor &&vis, basic_format_arg<Ctx> arg);
+  template <typename Visitor, typename Ctx>
+  friend FMT_CONSTEXPR typename internal::result_of<Visitor(int)>::type
+    visit(Visitor &&vis, basic_format_arg<Ctx> arg);
 
-    friend class basic_format_args<Context>;
-    friend class internal::arg_map<Context>;
+  friend class basic_format_args<Context>;
+  friend class internal::arg_map<Context>;
 
-    typedef typename Context::char_type char_type;
+  typedef typename Context::char_type char_type;
 
-public:
-    class handle
-    {
-    public:
-        explicit handle(internal::custom_value<Context> custom)
-            : custom_(custom)
-        {
-        }
+ public:
+  class handle {
+   public:
+    explicit handle(internal::custom_value<Context> custom): custom_(custom) {}
 
-        void format(Context &ctx) const
-        {
-            custom_.format(custom_.value, ctx);
-        }
+    void format(Context &ctx) const { custom_.format(custom_.value, ctx); }
 
-    private:
-        internal::custom_value<Context> custom_;
-    };
+   private:
+    internal::custom_value<Context> custom_;
+  };
 
-    FMT_CONSTEXPR basic_format_arg()
-        : type_(internal::none_type)
-    {
-    }
+  FMT_CONSTEXPR basic_format_arg() : type_(internal::none_type) {}
 
-    FMT_EXPLICIT operator bool() const FMT_NOEXCEPT
-    {
-        return type_ != internal::none_type;
-    }
+  FMT_EXPLICIT operator bool() const FMT_NOEXCEPT {
+    return type_ != internal::none_type;
+  }
 
-    internal::type type() const
-    {
-        return type_;
-    }
+  internal::type type() const { return type_; }
 
-    bool is_integral() const
-    {
-        return internal::is_integral(type_);
-    }
-    bool is_arithmetic() const
-    {
-        return internal::is_arithmetic(type_);
-    }
+  bool is_integral() const { return internal::is_integral(type_); }
+  bool is_arithmetic() const { return internal::is_arithmetic(type_); }
 };
 
 // Parsing context consisting of a format string range being parsed and an
 // argument counter for automatic indexing.
-template<typename Char, typename ErrorHandler = internal::error_handler>
-class basic_parse_context : private ErrorHandler
-{
-private:
-    basic_string_view<Char> format_str_;
-    int next_arg_id_;
+template <typename Char, typename ErrorHandler = internal::error_handler>
+class basic_parse_context : private ErrorHandler {
+ private:
+  basic_string_view<Char> format_str_;
+  int next_arg_id_;
 
-public:
-    typedef Char char_type;
-    typedef typename basic_string_view<Char>::iterator iterator;
+ public:
+  typedef Char char_type;
+  typedef typename basic_string_view<Char>::iterator iterator;
 
-    explicit FMT_CONSTEXPR basic_parse_context(basic_string_view<Char> format_str, ErrorHandler eh = ErrorHandler())
-        : ErrorHandler(eh)
-        , format_str_(format_str)
-        , next_arg_id_(0)
-    {
+  explicit FMT_CONSTEXPR basic_parse_context(
+      basic_string_view<Char> format_str, ErrorHandler eh = ErrorHandler())
+    : ErrorHandler(eh), format_str_(format_str), next_arg_id_(0) {}
+
+  // Returns an iterator to the beginning of the format string range being
+  // parsed.
+  FMT_CONSTEXPR iterator begin() const FMT_NOEXCEPT {
+    return format_str_.begin();
+  }
+
+  // Returns an iterator past the end of the format string range being parsed.
+  FMT_CONSTEXPR iterator end() const FMT_NOEXCEPT { return format_str_.end(); }
+
+  // Advances the begin iterator to ``it``.
+  FMT_CONSTEXPR void advance_to(iterator it) {
+    format_str_.remove_prefix(internal::to_unsigned(it - begin()));
+  }
+
+  // Returns the next argument index.
+  FMT_CONSTEXPR unsigned next_arg_id();
+
+  FMT_CONSTEXPR bool check_arg_id(unsigned) {
+    if (next_arg_id_ > 0) {
+      on_error("cannot switch from automatic to manual argument indexing");
+      return false;
     }
+    next_arg_id_ = -1;
+    return true;
+  }
+  void check_arg_id(basic_string_view<Char>) {}
 
-    // Returns an iterator to the beginning of the format string range being
-    // parsed.
-    FMT_CONSTEXPR iterator begin() const FMT_NOEXCEPT
-    {
-        return format_str_.begin();
-    }
+  FMT_CONSTEXPR void on_error(const char *message) {
+    ErrorHandler::on_error(message);
+  }
 
-    // Returns an iterator past the end of the format string range being parsed.
-    FMT_CONSTEXPR iterator end() const FMT_NOEXCEPT
-    {
-        return format_str_.end();
-    }
-
-    // Advances the begin iterator to ``it``.
-    FMT_CONSTEXPR void advance_to(iterator it)
-    {
-        format_str_.remove_prefix(it - begin());
-    }
-
-    // Returns the next argument index.
-    FMT_CONSTEXPR unsigned next_arg_id();
-
-    FMT_CONSTEXPR bool check_arg_id(unsigned)
-    {
-        if (next_arg_id_ > 0)
-        {
-            on_error("cannot switch from automatic to manual argument indexing");
-            return false;
-        }
-        next_arg_id_ = -1;
-        return true;
-    }
-    void check_arg_id(basic_string_view<Char>) {}
-
-    FMT_CONSTEXPR void on_error(const char *message)
-    {
-        ErrorHandler::on_error(message);
-    }
-
-    FMT_CONSTEXPR ErrorHandler error_handler() const
-    {
-        return *this;
-    }
+  FMT_CONSTEXPR ErrorHandler error_handler() const { return *this; }
 };
 
 typedef basic_parse_context<char> parse_context;
@@ -927,246 +786,195 @@ typedef basic_parse_context<wchar_t> wparse_context;
 
 namespace internal {
 // A map from argument names to their values for named arguments.
-template<typename Context>
-class arg_map
-{
-private:
-    FMT_DISALLOW_COPY_AND_ASSIGN(arg_map);
+template <typename Context>
+class arg_map {
+ private:
+  FMT_DISALLOW_COPY_AND_ASSIGN(arg_map);
 
-    typedef typename Context::char_type char_type;
+  typedef typename Context::char_type char_type;
 
-    struct entry
-    {
-        basic_string_view<char_type> name;
-        basic_format_arg<Context> arg;
-    };
+  struct entry {
+    basic_string_view<char_type> name;
+    basic_format_arg<Context> arg;
+  };
 
-    entry *map_;
-    unsigned size_;
+  entry *map_;
+  unsigned size_;
 
-    void push_back(value<Context> val)
-    {
-        const internal::named_arg_base<char_type> &named = val.as_named_arg();
-        map_[size_] = entry{named.name, named.template deserialize<Context>()};
-        ++size_;
-    }
-
-public:
-    arg_map()
-        : map_(FMT_NULL)
-        , size_(0)
-    {
-    }
-    void init(const basic_format_args<Context> &args);
-    ~arg_map()
-    {
-        delete[] map_;
-    }
-
-    basic_format_arg<Context> find(basic_string_view<char_type> name) const
-    {
-        // The list is unsorted, so just return the first matching name.
-        for (entry *it = map_, *end = map_ + size_; it != end; ++it)
-        {
-            if (it->name == name)
-                return it->arg;
-        }
-        return basic_format_arg<Context>();
+  void push_back(value<Context> val) {
+    const internal::named_arg_base<char_type> &named = val.as_named_arg();
+    map_[size_] = entry{named.name, named.template deserialize<Context>()};
+    ++size_;
+  }
+
+ public:
+  arg_map() : map_(FMT_NULL), size_(0) {}
+  void init(const basic_format_args<Context> &args);
+  ~arg_map() { delete [] map_; }
+
+  basic_format_arg<Context> find(basic_string_view<char_type> name) const {
+    // The list is unsorted, so just return the first matching name.
+    for (entry *it = map_, *end = map_ + size_; it != end; ++it) {
+      if (it->name == name)
+        return it->arg;
     }
+    return basic_format_arg<Context>();
+  }
 };
 
-template<typename OutputIt, typename Context, typename Char>
-class context_base
-{
-public:
-    typedef OutputIt iterator;
+template <typename OutputIt, typename Context, typename Char>
+class context_base {
+ public:
+  typedef OutputIt iterator;
 
-private:
-    basic_parse_context<Char> parse_context_;
-    iterator out_;
-    basic_format_args<Context> args_;
+ private:
+  basic_parse_context<Char> parse_context_;
+  iterator out_;
+  basic_format_args<Context> args_;
 
-protected:
-    typedef Char char_type;
-    typedef basic_format_arg<Context> format_arg;
+ protected:
+  typedef Char char_type;
+  typedef basic_format_arg<Context> format_arg;
 
-    context_base(OutputIt out, basic_string_view<char_type> format_str, basic_format_args<Context> ctx_args)
-        : parse_context_(format_str)
-        , out_(out)
-        , args_(ctx_args)
-    {
-    }
+  context_base(OutputIt out, basic_string_view<char_type> format_str,
+               basic_format_args<Context> ctx_args)
+  : parse_context_(format_str), out_(out), args_(ctx_args) {}
 
-    // Returns the argument with specified index.
-    format_arg do_get_arg(unsigned arg_id)
-    {
-        format_arg arg = args_.get(arg_id);
-        if (!arg)
-            parse_context_.on_error("argument index out of range");
-        return arg;
-    }
+  // Returns the argument with specified index.
+  format_arg do_get_arg(unsigned arg_id) {
+    format_arg arg = args_.get(arg_id);
+    if (!arg)
+      parse_context_.on_error("argument index out of range");
+    return arg;
+  }
 
-    // Checks if manual indexing is used and returns the argument with
-    // specified index.
-    format_arg get_arg(unsigned arg_id)
-    {
-        return this->parse_context().check_arg_id(arg_id) ? this->do_get_arg(arg_id) : format_arg();
-    }
+  // Checks if manual indexing is used and returns the argument with
+  // specified index.
+  format_arg get_arg(unsigned arg_id) {
+    return this->parse_context().check_arg_id(arg_id) ?
+      this->do_get_arg(arg_id) : format_arg();
+  }
 
-public:
-    basic_parse_context<char_type> &parse_context()
-    {
-        return parse_context_;
-    }
+ public:
+  basic_parse_context<char_type> &parse_context() {
+    return parse_context_;
+  }
 
-    internal::error_handler error_handler()
-    {
-        return parse_context_.error_handler();
-    }
+  internal::error_handler error_handler() {
+    return parse_context_.error_handler();
+  }
 
-    void on_error(const char *message)
-    {
-        parse_context_.on_error(message);
-    }
+  void on_error(const char *message) { parse_context_.on_error(message); }
 
-    // Returns an iterator to the beginning of the output range.
-    iterator out()
-    {
-        return out_;
-    }
-    iterator begin()
-    {
-        return out_;
-    } // deprecated
+  // Returns an iterator to the beginning of the output range.
+  iterator out() { return out_; }
+  iterator begin() { return out_; }  // deprecated
 
-    // Advances the begin iterator to ``it``.
-    void advance_to(iterator it)
-    {
-        out_ = it;
-    }
+  // Advances the begin iterator to ``it``.
+  void advance_to(iterator it) { out_ = it; }
 
-    basic_format_args<Context> args() const
-    {
-        return args_;
-    }
+  basic_format_args<Context> args() const { return args_; }
 };
 
 // Extracts a reference to the container from back_insert_iterator.
-template<typename Container>
-inline Container &get_container(std::back_insert_iterator<Container> it)
-{
-    typedef std::back_insert_iterator<Container> bi_iterator;
-    struct accessor : bi_iterator
-    {
-        accessor(bi_iterator iter)
-            : bi_iterator(iter)
-        {
-        }
-        using bi_iterator::container;
-    };
-    return *accessor(it).container;
+template <typename Container>
+inline Container &get_container(std::back_insert_iterator<Container> it) {
+  typedef std::back_insert_iterator<Container> bi_iterator;
+  struct accessor: bi_iterator {
+    accessor(bi_iterator iter) : bi_iterator(iter) {}
+    using bi_iterator::container;
+  };
+  return *accessor(it).container;
 }
-} // namespace internal
+}  // namespace internal
 
 // Formatting context.
-template<typename OutputIt, typename Char>
-class basic_format_context : public internal::context_base<OutputIt, basic_format_context<OutputIt, Char>, Char>
-{
-public:
-    /** The character type for the output. */
-    typedef Char char_type;
+template <typename OutputIt, typename Char>
+class basic_format_context :
+  public internal::context_base<
+    OutputIt, basic_format_context<OutputIt, Char>, Char> {
+ public:
+  /** The character type for the output. */
+  typedef Char char_type;
 
-    // using formatter_type = formatter<T, char_type>;
-    template<typename T>
-    struct formatter_type
-    {
-        typedef formatter<T, char_type> type;
-    };
+  // using formatter_type = formatter<T, char_type>;
+  template <typename T>
+  struct formatter_type { typedef formatter<T, char_type> type; };
 
-private:
-    internal::arg_map<basic_format_context> map_;
+ private:
+  internal::arg_map<basic_format_context> map_;
 
-    FMT_DISALLOW_COPY_AND_ASSIGN(basic_format_context);
+  FMT_DISALLOW_COPY_AND_ASSIGN(basic_format_context);
 
-    typedef internal::context_base<OutputIt, basic_format_context, Char> base;
-    typedef typename base::format_arg format_arg;
-    using base::get_arg;
+  typedef internal::context_base<OutputIt, basic_format_context, Char> base;
+  typedef typename base::format_arg format_arg;
+  using base::get_arg;
 
-public:
-    using typename base::iterator;
+ public:
+  using typename base::iterator;
 
-    /**
-     Constructs a ``basic_format_context`` object. References to the arguments are
-     stored in the object so make sure they have appropriate lifetimes.
-     */
-    basic_format_context(OutputIt out, basic_string_view<char_type> format_str, basic_format_args<basic_format_context> ctx_args)
-        : base(out, format_str, ctx_args)
-    {
-    }
+  /**
+   Constructs a ``basic_format_context`` object. References to the arguments are
+   stored in the object so make sure they have appropriate lifetimes.
+   */
+  basic_format_context(OutputIt out, basic_string_view<char_type> format_str,
+                basic_format_args<basic_format_context> ctx_args)
+    : base(out, format_str, ctx_args) {}
 
-    format_arg next_arg()
-    {
-        return this->do_get_arg(this->parse_context().next_arg_id());
-    }
-    format_arg get_arg(unsigned arg_id)
-    {
-        return this->do_get_arg(arg_id);
-    }
+  format_arg next_arg() {
+    return this->do_get_arg(this->parse_context().next_arg_id());
+  }
+  format_arg get_arg(unsigned arg_id) { return this->do_get_arg(arg_id); }
 
-    // Checks if manual indexing is used and returns the argument with the
-    // specified name.
-    format_arg get_arg(basic_string_view<char_type> name);
+  // Checks if manual indexing is used and returns the argument with the
+  // specified name.
+  format_arg get_arg(basic_string_view<char_type> name);
 };
 
-template<typename Char>
-struct buffer_context
-{
-    typedef basic_format_context<std::back_insert_iterator<internal::basic_buffer<Char>>, Char> type;
+template <typename Char>
+struct buffer_context {
+  typedef basic_format_context<
+    std::back_insert_iterator<internal::basic_buffer<Char>>, Char> type;
 };
 typedef buffer_context<char>::type format_context;
 typedef buffer_context<wchar_t>::type wformat_context;
 
 namespace internal {
-template<typename Context, typename T>
-struct get_type
-{
-    typedef decltype(make_value<Context>(declval<typename std::decay<T>::type &>())) value_type;
-    static const type value = value_type::type_tag;
+template <typename Context, typename T>
+struct get_type {
+  typedef decltype(make_value<Context>(
+        declval<typename std::decay<T>::type&>())) value_type;
+  static const type value = value_type::type_tag;
 };
 
-template<typename Context>
-FMT_CONSTEXPR uint64_t get_types()
-{
-    return 0;
+template <typename Context>
+FMT_CONSTEXPR unsigned long long get_types() { return 0; }
+
+template <typename Context, typename Arg, typename... Args>
+FMT_CONSTEXPR unsigned long long get_types() {
+  return get_type<Context, Arg>::value | (get_types<Context, Args...>() << 4);
 }
 
-template<typename Context, typename Arg, typename... Args>
-FMT_CONSTEXPR uint64_t get_types()
-{
-    return get_type<Context, Arg>::value | (get_types<Context, Args...>() << 4);
+template <typename Context, typename T>
+FMT_CONSTEXPR basic_format_arg<Context> make_arg(const T &value) {
+  basic_format_arg<Context> arg;
+  arg.type_ = get_type<Context, T>::value;
+  arg.value_ = make_value<Context>(value);
+  return arg;
 }
 
-template<typename Context, typename T>
-FMT_CONSTEXPR basic_format_arg<Context> make_arg(const T &value)
-{
-    basic_format_arg<Context> arg;
-    arg.type_ = get_type<Context, T>::value;
-    arg.value_ = make_value<Context>(value);
-    return arg;
+template <bool IS_PACKED, typename Context, typename T>
+inline typename std::enable_if<IS_PACKED, value<Context>>::type
+    make_arg(const T &value) {
+  return make_value<Context>(value);
 }
 
-template<bool IS_PACKED, typename Context, typename T>
-inline typename std::enable_if<IS_PACKED, value<Context>>::type make_arg(const T &value)
-{
-    return make_value<Context>(value);
+template <bool IS_PACKED, typename Context, typename T>
+inline typename std::enable_if<!IS_PACKED, basic_format_arg<Context>>::type
+    make_arg(const T &value) {
+  return make_arg<Context>(value);
 }
-
-template<bool IS_PACKED, typename Context, typename T>
-inline typename std::enable_if<!IS_PACKED, basic_format_arg<Context>>::type make_arg(const T &value)
-{
-    return make_arg<Context>(value);
 }
-} // namespace internal
 
 /**
   \rst
@@ -1175,51 +983,54 @@ inline typename std::enable_if<!IS_PACKED, basic_format_arg<Context>>::type make
   such as `~fmt::vformat`.
   \endrst
  */
-template<typename Context, typename... Args>
-class format_arg_store
-{
-private:
-    static const size_t NUM_ARGS = sizeof...(Args);
+template <typename Context, typename ...Args>
+class format_arg_store {
+ private:
+  static const size_t NUM_ARGS = sizeof...(Args);
 
-    // Packed is a macro on MinGW so use IS_PACKED instead.
-    static const bool IS_PACKED = NUM_ARGS < internal::max_packed_args;
+  // Packed is a macro on MinGW so use IS_PACKED instead.
+  static const bool IS_PACKED = NUM_ARGS < internal::max_packed_args;
 
-    typedef typename std::conditional<IS_PACKED, internal::value<Context>, basic_format_arg<Context>>::type value_type;
+  typedef typename std::conditional<IS_PACKED,
+    internal::value<Context>, basic_format_arg<Context>>::type value_type;
 
-    // If the arguments are not packed, add one more element to mark the end.
-    value_type data_[NUM_ARGS + (IS_PACKED && NUM_ARGS != 0 ? 0 : 1)];
+  // If the arguments are not packed, add one more element to mark the end.
+  static const size_t DATA_SIZE =
+          NUM_ARGS + (IS_PACKED && NUM_ARGS != 0 ? 0 : 1);
+  value_type data_[DATA_SIZE];
 
-    friend class basic_format_args<Context>;
+  friend class basic_format_args<Context>;
 
-    static FMT_CONSTEXPR int64_t get_types()
-    {
-        return IS_PACKED ? static_cast<int64_t>(internal::get_types<Context, Args...>()) : -static_cast<int64_t>(NUM_ARGS);
-    }
+  static FMT_CONSTEXPR long long get_types() {
+    return IS_PACKED ?
+      static_cast<long long>(internal::get_types<Context, Args...>()) :
+      -static_cast<long long>(NUM_ARGS);
+  }
 
-public:
+ public:
 #if FMT_USE_CONSTEXPR
-    static constexpr int64_t TYPES = get_types();
+  static constexpr long long TYPES = get_types();
 #else
-    static const int64_t TYPES;
+  static const long long TYPES;
 #endif
 
-#if FMT_GCC_VERSION && FMT_GCC_VERSION <= 405
-    // Workaround an array initialization bug in gcc 4.5 and earlier.
-    format_arg_store(const Args &... args)
-    {
-        data_ = {internal::make_arg<IS_PACKED, Context>(args)...};
-    }
+#if (FMT_GCC_VERSION && FMT_GCC_VERSION <= 405) || \
+    (FMT_MSC_VER && FMT_MSC_VER <= 1800)
+  // Workaround array initialization issues in gcc <= 4.5 and MSVC <= 2013.
+  format_arg_store(const Args &... args) {
+    value_type init[DATA_SIZE] =
+      {internal::make_arg<IS_PACKED, Context>(args)...};
+    std::memcpy(data_, init, sizeof(init));
+  }
 #else
-    format_arg_store(const Args &... args)
-        : data_{internal::make_arg<IS_PACKED, Context>(args)...}
-    {
-    }
+  format_arg_store(const Args &... args)
+    : data_{internal::make_arg<IS_PACKED, Context>(args)...} {}
 #endif
 };
 
 #if !FMT_USE_CONSTEXPR
-template<typename Context, typename... Args>
-const int64_t format_arg_store<Context, Args...>::TYPES = get_types();
+template <typename Context, typename ...Args>
+const long long format_arg_store<Context, Args...>::TYPES = get_types();
 #endif
 
 /**
@@ -1229,164 +1040,136 @@ const int64_t format_arg_store<Context, Args...>::TYPES = get_types();
   be omitted in which case it defaults to `~fmt::context`.
   \endrst
  */
-template<typename Context, typename... Args>
-inline format_arg_store<Context, Args...> make_format_args(const Args &... args)
-{
-    return format_arg_store<Context, Args...>(args...);
+template <typename Context, typename ...Args>
+inline format_arg_store<Context, Args...>
+    make_format_args(const Args & ... args) {
+  return format_arg_store<Context, Args...>(args...);
 }
 
-template<typename... Args>
-inline format_arg_store<format_context, Args...> make_format_args(const Args &... args)
-{
-    return format_arg_store<format_context, Args...>(args...);
+template <typename ...Args>
+inline format_arg_store<format_context, Args...>
+    make_format_args(const Args & ... args) {
+  return format_arg_store<format_context, Args...>(args...);
 }
 
 /** Formatting arguments. */
-template<typename Context>
-class basic_format_args
-{
-public:
-    typedef unsigned size_type;
-    typedef basic_format_arg<Context> format_arg;
+template <typename Context>
+class basic_format_args {
+ public:
+  typedef unsigned size_type;
+  typedef basic_format_arg<Context>  format_arg;
 
-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<Context> *values_;
-        const format_arg *args_;
-    };
+ private:
+  // To reduce compiled code size per formatting function call, types of first
+  // max_packed_args arguments are passed in the types_ field.
+  unsigned long long 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<Context> *values_;
+    const format_arg *args_;
+  };
 
-    typename internal::type type(unsigned index) const
-    {
-        unsigned shift = index * 4;
-        uint64_t mask = 0xf;
-        return static_cast<typename internal::type>((types_ & (mask << shift)) >> shift);
+  typename internal::type type(unsigned index) const {
+    unsigned shift = index * 4;
+    unsigned long long mask = 0xf;
+    return static_cast<typename internal::type>(
+      (types_ & (mask << shift)) >> shift);
+  }
+
+  friend class internal::arg_map<Context>;
+
+  void set_data(const internal::value<Context> *values) { values_ = values; }
+  void set_data(const format_arg *args) { args_ = args; }
+
+  format_arg do_get(size_type index) const {
+    long long signed_types = static_cast<long long>(types_);
+    if (signed_types < 0) {
+      unsigned long long num_args = static_cast<unsigned long long>(-signed_types);
+      return index < num_args ? args_[index] : format_arg();
     }
+    format_arg arg;
+    if (index > internal::max_packed_args)
+      return arg;
+    arg.type_ = type(index);
+    if (arg.type_ == internal::none_type)
+      return arg;
+    internal::value<Context> &val = arg.value_;
+    val = values_[index];
+    return arg;
+  }
 
-    friend class internal::arg_map<Context>;
+ public:
+  basic_format_args() : types_(0) {}
 
-    void set_data(const internal::value<Context> *values)
-    {
-        values_ = values;
-    }
-    void set_data(const format_arg *args)
-    {
-        args_ = args;
-    }
+  /**
+   \rst
+   Constructs a `basic_format_args` object from `~fmt::format_arg_store`.
+   \endrst
+   */
+  template <typename... Args>
+  basic_format_args(const format_arg_store<Context, Args...> &store)
+  : types_(static_cast<unsigned long long>(store.TYPES)) {
+    set_data(store.data_);
+  }
 
-    format_arg do_get(size_type index) const
-    {
-        int64_t signed_types = static_cast<int64_t>(types_);
-        if (signed_types < 0)
-        {
-            uint64_t num_args = -signed_types;
-            return index < num_args ? args_[index] : format_arg();
-        }
-        format_arg arg;
-        if (index > internal::max_packed_args)
-            return arg;
-        arg.type_ = type(index);
-        if (arg.type_ == internal::none_type)
-            return arg;
-        internal::value<Context> &val = arg.value_;
-        val = values_[index];
-        return arg;
-    }
+  /** Returns the argument at specified index. */
+  format_arg get(size_type index) const {
+    format_arg arg = do_get(index);
+    return arg.type_ == internal::named_arg_type ?
+          arg.value_.as_named_arg().template deserialize<Context>() : arg;
+  }
 
-public:
-    basic_format_args()
-        : types_(0)
-    {
-    }
-
-    /**
-     \rst
-     Constructs a `basic_format_args` object from `~fmt::format_arg_store`.
-     \endrst
-     */
-    template<typename... Args>
-    basic_format_args(const format_arg_store<Context, Args...> &store)
-        : types_(store.TYPES)
-    {
-        set_data(store.data_);
-    }
-
-    /** Returns the argument at specified index. */
-    format_arg get(size_type index) const
-    {
-        format_arg arg = do_get(index);
-        return arg.type_ == internal::named_arg_type ? arg.value_.as_named_arg().template deserialize<Context>() : arg;
-    }
-
-    unsigned max_size() const
-    {
-        int64_t signed_types = static_cast<int64_t>(types_);
-        return static_cast<unsigned>(signed_types < 0 ? -signed_types : static_cast<int64_t>(internal::max_packed_args));
-    }
+  unsigned max_size() const {
+    long long signed_types = static_cast<long long>(types_);
+    return static_cast<unsigned>(
+        signed_types < 0 ?
+        -signed_types : static_cast<long long>(internal::max_packed_args));
+  }
 };
 
 /** An alias to ``basic_format_args<context>``. */
 // It is a separate type rather than a typedef to make symbols readable.
-struct format_args : basic_format_args<format_context>
-{
-    template<typename... Args>
-    format_args(Args &&... arg)
-        : basic_format_args<format_context>(std::forward<Args>(arg)...)
-    {
-    }
+struct format_args: basic_format_args<format_context> {
+  template <typename ...Args>
+  format_args(Args && ... arg)
+  : basic_format_args<format_context>(std::forward<Args>(arg)...) {}
 };
-struct wformat_args : basic_format_args<wformat_context>
-{
-    template<typename... Args>
-    wformat_args(Args &&... arg)
-        : basic_format_args<wformat_context>(std::forward<Args>(arg)...)
-    {
-    }
+struct wformat_args : basic_format_args<wformat_context> {
+  template <typename ...Args>
+  wformat_args(Args && ... arg)
+  : basic_format_args<wformat_context>(std::forward<Args>(arg)...) {}
 };
 
 namespace internal {
-template<typename Char>
-struct named_arg_base
-{
-    basic_string_view<Char> name;
+template <typename Char>
+struct named_arg_base {
+  basic_string_view<Char> name;
 
-    // Serialized value<context>.
-    mutable char data[sizeof(basic_format_arg<format_context>)];
+  // Serialized value<context>.
+  mutable char data[sizeof(basic_format_arg<format_context>)];
 
-    named_arg_base(basic_string_view<Char> nm)
-        : name(nm)
-    {
-    }
+  named_arg_base(basic_string_view<Char> nm) : name(nm) {}
 
-    template<typename Context>
-    basic_format_arg<Context> deserialize() const
-    {
-        basic_format_arg<Context> arg;
-        std::memcpy(&arg, data, sizeof(basic_format_arg<Context>));
-        return arg;
-    }
+  template <typename Context>
+  basic_format_arg<Context> deserialize() const {
+    basic_format_arg<Context> arg;
+    std::memcpy(&arg, data, sizeof(basic_format_arg<Context>));
+    return arg;
+  }
 };
 
-template<typename T, typename Char>
-struct named_arg : named_arg_base<Char>
-{
-    const T &value;
+template <typename T, typename Char>
+struct named_arg : named_arg_base<Char> {
+  const T &value;
 
-    named_arg(basic_string_view<Char> name, const T &val)
-        : named_arg_base<Char>(name)
-        , value(val)
-    {
-    }
+  named_arg(basic_string_view<Char> name, const T &val)
+    : named_arg_base<Char>(name), value(val) {}
 };
-} // namespace internal
+}
 
 /**
   \rst
@@ -1397,93 +1180,73 @@ struct named_arg : named_arg_base<Char>
     fmt::print("Elapsed time: {s:.2f} seconds", fmt::arg("s", 1.23));
   \endrst
  */
-template<typename T>
-inline internal::named_arg<T, char> arg(string_view name, const T &arg)
-{
-    return internal::named_arg<T, char>(name, arg);
+template <typename T>
+inline internal::named_arg<T, char> arg(string_view name, const T &arg) {
+  return internal::named_arg<T, char>(name, arg);
 }
 
-template<typename T>
-inline internal::named_arg<T, wchar_t> arg(wstring_view name, const T &arg)
-{
-    return internal::named_arg<T, wchar_t>(name, arg);
+template <typename T>
+inline internal::named_arg<T, wchar_t> arg(wstring_view name, const T &arg) {
+  return internal::named_arg<T, wchar_t>(name, arg);
 }
 
 // This function template is deleted intentionally to disable nested named
 // arguments as in ``format("{}", arg("a", arg("b", 42)))``.
-template<typename S, typename T, typename Char>
+template <typename S, typename T, typename Char>
 void arg(S, internal::named_arg<T, Char>) FMT_DELETED;
 
-enum color
-{
-    black,
-    red,
-    green,
-    yellow,
-    blue,
-    magenta,
-    cyan,
-    white
-};
-
+#ifndef FMT_EXTENDED_COLORS
+// color and (v)print_colored are deprecated.
+enum color { black, red, green, yellow, blue, magenta, cyan, white };
 FMT_API void vprint_colored(color c, string_view format, format_args args);
 FMT_API void vprint_colored(color c, wstring_view format, wformat_args args);
-
-/**
-  Formats a string and prints it to stdout using ANSI escape sequences to
-  specify color (experimental).
-  Example:
-    fmt::print_colored(fmt::RED, "Elapsed time: {0:.2f} seconds", 1.23);
- */
-template<typename... Args>
-inline void print_colored(color c, string_view format_str, const Args &... args)
-{
-    vprint_colored(c, format_str, make_format_args(args...));
+template <typename... Args>
+inline void print_colored(color c, string_view format_str,
+                          const Args & ... args) {
+  vprint_colored(c, format_str, make_format_args(args...));
 }
-
-template<typename... Args>
-inline void print_colored(color c, wstring_view format_str, const Args &... args)
-{
-    vprint_colored(c, format_str, make_format_args<wformat_context>(args...));
+template <typename... Args>
+inline void print_colored(color c, wstring_view format_str,
+                          const Args & ... args) {
+  vprint_colored(c, format_str, make_format_args<wformat_context>(args...));
 }
+#endif
 
-format_context::iterator vformat_to(internal::buffer &buf, string_view format_str, format_args args);
-wformat_context::iterator vformat_to(internal::wbuffer &buf, wstring_view format_str, wformat_args args);
+format_context::iterator vformat_to(
+    internal::buffer &buf, string_view format_str, format_args args);
+wformat_context::iterator vformat_to(
+    internal::wbuffer &buf, wstring_view format_str, wformat_args args);
 
-template<typename Container>
-struct is_contiguous : std::false_type
-{
-};
+template <typename Container>
+struct is_contiguous : std::false_type {};
 
-template<typename Char>
-struct is_contiguous<std::basic_string<Char>> : std::true_type
-{
-};
+template <typename Char>
+struct is_contiguous<std::basic_string<Char>> : std::true_type {};
 
-template<typename Char>
-struct is_contiguous<internal::basic_buffer<Char>> : std::true_type
-{
-};
+template <typename Char>
+struct is_contiguous<internal::basic_buffer<Char>> : std::true_type {};
 
 /** Formats a string and writes the output to ``out``. */
-template<typename Container>
-typename std::enable_if<is_contiguous<Container>::value, std::back_insert_iterator<Container>>::type vformat_to(
-    std::back_insert_iterator<Container> out, string_view format_str, format_args args)
-{
-    auto &container = internal::get_container(out);
-    internal::container_buffer<Container> buf(container);
-    vformat_to(buf, format_str, args);
-    return std::back_inserter(container);
+template <typename Container>
+typename std::enable_if<
+  is_contiguous<Container>::value, std::back_insert_iterator<Container>>::type
+    vformat_to(std::back_insert_iterator<Container> out,
+               string_view format_str, format_args args) {
+  auto& container = internal::get_container(out);
+  internal::container_buffer<Container> buf(container);
+  vformat_to(buf, format_str, args);
+  return std::back_inserter(container);
 }
 
-template<typename Container>
-typename std::enable_if<is_contiguous<Container>::value, std::back_insert_iterator<Container>>::type vformat_to(
-    std::back_insert_iterator<Container> out, wstring_view format_str, wformat_args args)
-{
-    auto &container = internal::get_container(out);
-    internal::container_buffer<Container> buf(container);
-    vformat_to(buf, format_str, args);
-    return std::back_inserter(container);
+template <typename Container>
+typename std::enable_if<
+  is_contiguous<Container>::value, std::back_insert_iterator<Container>>::type
+  vformat_to(std::back_insert_iterator<Container> out,
+             wstring_view format_str, wformat_args args) {
+  auto& container = internal::get_container(out);
+  internal::container_buffer<Container> buf(container);
+  vformat_to(buf, format_str, args);
+  return std::back_inserter(container);
 }
 
 std::string vformat(string_view format_str, format_args args);
@@ -1499,20 +1262,18 @@ std::wstring vformat(wstring_view format_str, wformat_args args);
     std::string message = fmt::format("The answer is {}", 42);
   \endrst
 */
-template<typename... Args>
-inline std::string format(string_view format_str, const Args &... args)
-{
-    // This should be just
-    // return vformat(format_str, make_format_args(args...));
-    // but gcc has trouble optimizing the latter, so break it down.
-    format_arg_store<format_context, Args...> as{args...};
-    return vformat(format_str, as);
+template <typename... Args>
+inline std::string format(string_view format_str, const Args & ... args) {
+  // This should be just
+  // return vformat(format_str, make_format_args(args...));
+  // but gcc has trouble optimizing the latter, so break it down.
+  format_arg_store<format_context, Args...> as{args...};
+  return vformat(format_str, as);
 }
-template<typename... Args>
-inline std::wstring format(wstring_view format_str, const Args &... args)
-{
-    format_arg_store<wformat_context, Args...> as{args...};
-    return vformat(format_str, as);
+template <typename... Args>
+inline std::wstring format(wstring_view format_str, const Args & ... args) {
+  format_arg_store<wformat_context, Args...> as{args...};
+  return vformat(format_str, as);
 }
 
 FMT_API void vprint(std::FILE *f, string_view format_str, format_args args);
@@ -1527,21 +1288,19 @@ FMT_API void vprint(std::FILE *f, wstring_view format_str, wformat_args args);
     fmt::print(stderr, "Don't {}!", "panic");
   \endrst
  */
-template<typename... Args>
-inline void print(std::FILE *f, string_view format_str, const Args &... args)
-{
-    format_arg_store<format_context, Args...> as(args...);
-    vprint(f, format_str, as);
+template <typename... Args>
+inline void print(std::FILE *f, string_view format_str, const Args & ... args) {
+  format_arg_store<format_context, Args...> as(args...);
+  vprint(f, format_str, as);
 }
 /**
   Prints formatted data to the file *f* which should be in wide-oriented mode set
   via ``fwide(f, 1)`` or ``_setmode(_fileno(f), _O_U8TEXT)`` on Windows.
  */
-template<typename... Args>
-inline void print(std::FILE *f, wstring_view format_str, const Args &... args)
-{
-    format_arg_store<wformat_context, Args...> as(args...);
-    vprint(f, format_str, as);
+template <typename... Args>
+inline void print(std::FILE *f, wstring_view format_str, const Args & ... args) {
+  format_arg_store<wformat_context, Args...> as(args...);
+  vprint(f, format_str, as);
 }
 
 FMT_API void vprint(string_view format_str, format_args args);
@@ -1556,19 +1315,17 @@ FMT_API void vprint(wstring_view format_str, wformat_args args);
     fmt::print("Elapsed time: {0:.2f} seconds", 1.23);
   \endrst
  */
-template<typename... Args>
-inline void print(string_view format_str, const Args &... args)
-{
-    format_arg_store<format_context, Args...> as{args...};
-    vprint(format_str, as);
+template <typename... Args>
+inline void print(string_view format_str, const Args & ... args) {
+  format_arg_store<format_context, Args...> as{args...};
+  vprint(format_str, as);
 }
 
-template<typename... Args>
-inline void print(wstring_view format_str, const Args &... args)
-{
-    format_arg_store<wformat_context, Args...> as(args...);
-    vprint(format_str, as);
+template <typename... Args>
+inline void print(wstring_view format_str, const Args & ... args) {
+  format_arg_store<wformat_context, Args...> as(args...);
+  vprint(format_str, as);
 }
 FMT_END_NAMESPACE
 
-#endif // FMT_CORE_H_
+#endif  // FMT_CORE_H_
diff --git a/include/spdlog/fmt/bundled/format-inl.h b/include/spdlog/fmt/bundled/format-inl.h
index 267d2449..e66bbb7a 100644
--- a/include/spdlog/fmt/bundled/format-inl.h
+++ b/include/spdlog/fmt/bundled/format-inl.h
@@ -17,52 +17,50 @@
 #include <climits>
 #include <cmath>
 #include <cstdarg>
-#include <cstddef> // for std::ptrdiff_t
+#include <cstddef>  // for std::ptrdiff_t
 #include <locale>
 
 #if defined(_WIN32) && defined(__MINGW32__)
-#include <cstring>
+# include <cstring>
 #endif
 
 #if FMT_USE_WINDOWS_H
-#if !defined(FMT_HEADER_ONLY) && !defined(WIN32_LEAN_AND_MEAN)
-#define WIN32_LEAN_AND_MEAN
-#endif
-#if defined(NOMINMAX) || defined(FMT_WIN_MINMAX)
-#include <windows.h>
-#else
-#define NOMINMAX
-#include <windows.h>
-#undef NOMINMAX
-#endif
+# if !defined(FMT_HEADER_ONLY) && !defined(WIN32_LEAN_AND_MEAN)
+#  define WIN32_LEAN_AND_MEAN
+# endif
+# if defined(NOMINMAX) || defined(FMT_WIN_MINMAX)
+#  include <windows.h>
+# else
+#  define NOMINMAX
+#  include <windows.h>
+#  undef NOMINMAX
+# endif
 #endif
 
 #if FMT_EXCEPTIONS
-#define FMT_TRY try
-#define FMT_CATCH(x) catch (x)
+# define FMT_TRY try
+# define FMT_CATCH(x) catch (x)
 #else
-#define FMT_TRY if (true)
-#define FMT_CATCH(x) if (false)
+# 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
+# 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)
+# pragma warning(disable: 4996)
 #endif
 
 // Dummy implementations of strerror_r and strerror_s called if corresponding
 // system functions are not available.
-inline fmt::internal::null<> strerror_r(int, char *, ...)
-{
-    return fmt::internal::null<>();
+inline fmt::internal::null<> strerror_r(int, char *, ...) {
+  return fmt::internal::null<>();
 }
-inline fmt::internal::null<> strerror_s(char *, std::size_t, ...)
-{
-    return fmt::internal::null<>();
+inline fmt::internal::null<> strerror_s(char *, std::size_t, ...) {
+  return fmt::internal::null<>();
 }
 
 FMT_BEGIN_NAMESPACE
@@ -70,28 +68,24 @@ FMT_BEGIN_NAMESPACE
 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 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
+# define FMT_SNPRINTF fmt_snprintf
+#endif  // _MSC_VER
 
 #if defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT)
-#define FMT_SWPRINTF snwprintf
+# define FMT_SWPRINTF snwprintf
 #else
-#define FMT_SWPRINTF swprintf
+# define FMT_SWPRINTF swprintf
 #endif // defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT)
 
-const char RESET_COLOR[] = "\x1b[0m";
-const wchar_t WRESET_COLOR[] = L"\x1b[0m";
-
 typedef void (*FormatFunc)(internal::buffer &, int, string_view);
 
 // Portable thread-safe version of strerror.
@@ -103,432 +97,468 @@ typedef void (*FormatFunc)(internal::buffer &, int, string_view);
 //   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 != FMT_NULL && buffer_size != 0, "invalid buffer");
+int safe_strerror(
+    int error_code, char *&buffer, std::size_t buffer_size) FMT_NOEXCEPT {
+  FMT_ASSERT(buffer != FMT_NULL && buffer_size != 0, "invalid buffer");
 
-    class dispatcher
-    {
-    private:
-        int error_code_;
-        char *&buffer_;
-        std::size_t buffer_size_;
+  class dispatcher {
+   private:
+    int error_code_;
+    char *&buffer_;
+    std::size_t buffer_size_;
 
-        // A noop assignment operator to avoid bogus warnings.
-        void operator=(const dispatcher &) {}
+    // A noop assignment operator to avoid bogus warnings.
+    void operator=(const dispatcher &) {}
 
-        // 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 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 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_));
-        }
+    // 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_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;
-        }
+    // 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:
-        dispatcher(int err_code, char *&buf, std::size_t buf_size)
-            : error_code_(err_code)
-            , buffer_(buf)
-            , buffer_size_(buf_size)
-        {
-        }
+   public:
+    dispatcher(int err_code, char *&buf, std::size_t buf_size)
+      : error_code_(err_code), buffer_(buf), buffer_size_(buf_size) {}
 
-        int run()
-        {
-            return handle(strerror_r(error_code_, buffer_, buffer_size_));
-        }
-    };
-    return dispatcher(error_code, buffer, buffer_size).run();
+    int run() {
+      return handle(strerror_r(error_code_, buffer_, buffer_size_));
+    }
+  };
+  return dispatcher(error_code, buffer, buffer_size).run();
 }
 
-void format_error_code(internal::buffer &out, int error_code, string_view 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.resize(0);
-    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::int_traits<int>::main_type main_type;
-    main_type abs_value = static_cast<main_type>(error_code);
-    if (internal::is_negative(error_code))
-    {
-        abs_value = 0 - abs_value;
-        ++error_code_size;
-    }
-    error_code_size += internal::count_digits(abs_value);
-    writer w(out);
-    if (message.size() <= inline_buffer_size - error_code_size)
-    {
-        w.write(message);
-        w.write(SEP);
-    }
-    w.write(ERROR_STR);
-    w.write(error_code);
-    assert(out.size() <= inline_buffer_size);
+void format_error_code(internal::buffer &out, int error_code,
+                       string_view 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.resize(0);
+  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::int_traits<int>::main_type main_type;
+  main_type abs_value = static_cast<main_type>(error_code);
+  if (internal::is_negative(error_code)) {
+    abs_value = 0 - abs_value;
+    ++error_code_size;
+  }
+  error_code_size += internal::count_digits(abs_value);
+  writer w(out);
+  if (message.size() <= inline_buffer_size - error_code_size) {
+    w.write(message);
+    w.write(SEP);
+  }
+  w.write(ERROR_STR);
+  w.write(error_code);
+  assert(out.size() <= inline_buffer_size);
 }
 
-void report_error(FormatFunc func, int error_code, string_view message) FMT_NOEXCEPT
-{
-    memory_buffer 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);
+void report_error(FormatFunc func, int error_code,
+                  string_view message) FMT_NOEXCEPT {
+  memory_buffer 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);
 }
-} // namespace
+}  // namespace
 
-class locale
-{
-private:
-    std::locale locale_;
+class locale {
+ private:
+  std::locale locale_;
 
-public:
-    explicit locale(std::locale loc = std::locale())
-        : locale_(loc)
-    {
-    }
-    std::locale get()
-    {
-        return locale_;
-    }
+ public:
+  explicit locale(std::locale loc = std::locale()) : locale_(loc) {}
+  std::locale get() { return locale_; }
 };
 
-template<typename Char>
-FMT_FUNC Char internal::thousands_sep(locale_provider *lp)
-{
-    std::locale loc = lp ? lp->locale().get() : std::locale();
-    return std::use_facet<std::numpunct<Char>>(loc).thousands_sep();
+template <typename Char>
+FMT_FUNC Char internal::thousands_sep(locale_provider *lp) {
+  std::locale loc = lp ? lp->locale().get() : std::locale();
+  return std::use_facet<std::numpunct<Char>>(loc).thousands_sep();
 }
 
-FMT_FUNC void system_error::init(int err_code, string_view format_str, format_args args)
-{
-    error_code_ = err_code;
-    memory_buffer buffer;
-    format_system_error(buffer, err_code, vformat(format_str, args));
-    std::runtime_error &base = *this;
-    base = std::runtime_error(to_string(buffer));
+FMT_FUNC void system_error::init(
+    int err_code, string_view format_str, format_args args) {
+  error_code_ = err_code;
+  memory_buffer buffer;
+  format_system_error(buffer, err_code, vformat(format_str, args));
+  std::runtime_error &base = *this;
+  base = std::runtime_error(to_string(buffer));
 }
 
 namespace internal {
-template<typename T>
-int char_traits<char>::format_float(char *buffer, std::size_t size, const char *format, int precision, T value)
-{
-    return precision < 0 ? FMT_SNPRINTF(buffer, size, format, value) : FMT_SNPRINTF(buffer, size, format, precision, value);
+template <typename T>
+int char_traits<char>::format_float(
+    char *buffer, std::size_t size, const char *format, int precision, T value) {
+  return precision < 0 ?
+      FMT_SNPRINTF(buffer, size, format, value) :
+      FMT_SNPRINTF(buffer, size, format, precision, value);
 }
 
-template<typename T>
-int char_traits<wchar_t>::format_float(wchar_t *buffer, std::size_t size, const wchar_t *format, int precision, T value)
-{
-    return precision < 0 ? FMT_SWPRINTF(buffer, size, format, value) : FMT_SWPRINTF(buffer, size, format, precision, value);
+template <typename T>
+int char_traits<wchar_t>::format_float(
+    wchar_t *buffer, std::size_t size, const wchar_t *format, int precision,
+    T value) {
+  return precision < 0 ?
+      FMT_SWPRINTF(buffer, size, format, value) :
+      FMT_SWPRINTF(buffer, size, format, precision, value);
 }
 
-template<typename T>
-const char basic_data<T>::DIGITS[] = "0001020304050607080910111213141516171819"
-                                     "2021222324252627282930313233343536373839"
-                                     "4041424344454647484950515253545556575859"
-                                     "6061626364656667686970717273747576777879"
-                                     "8081828384858687888990919293949596979899";
+template <typename T>
+const char basic_data<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
+#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 basic_data<T>::POWERS_OF_10_32[] = {0, FMT_POWERS_OF_10(1)};
+template <typename T>
+const uint32_t basic_data<T>::POWERS_OF_10_32[] = {
+  0, FMT_POWERS_OF_10(1)
+};
 
-template<typename T>
-const uint64_t basic_data<T>::POWERS_OF_10_64[] = {0, FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1000000000ull), 10000000000000000000ull};
+template <typename T>
+const uint64_t basic_data<T>::POWERS_OF_10_64[] = {
+  0,
+  FMT_POWERS_OF_10(1),
+  FMT_POWERS_OF_10(1000000000ull),
+  10000000000000000000ull
+};
 
 // Normalized 64-bit significands of pow(10, k), for k = -348, -340, ..., 340.
 // These are generated by support/compute-powers.py.
-template<typename T>
-const uint64_t basic_data<T>::POW10_SIGNIFICANDS[] = {0xfa8fd5a0081c0288, 0xbaaee17fa23ebf76, 0x8b16fb203055ac76, 0xcf42894a5dce35ea,
-    0x9a6bb0aa55653b2d, 0xe61acf033d1a45df, 0xab70fe17c79ac6ca, 0xff77b1fcbebcdc4f, 0xbe5691ef416bd60c, 0x8dd01fad907ffc3c,
-    0xd3515c2831559a83, 0x9d71ac8fada6c9b5, 0xea9c227723ee8bcb, 0xaecc49914078536d, 0x823c12795db6ce57, 0xc21094364dfb5637,
-    0x9096ea6f3848984f, 0xd77485cb25823ac7, 0xa086cfcd97bf97f4, 0xef340a98172aace5, 0xb23867fb2a35b28e, 0x84c8d4dfd2c63f3b,
-    0xc5dd44271ad3cdba, 0x936b9fcebb25c996, 0xdbac6c247d62a584, 0xa3ab66580d5fdaf6, 0xf3e2f893dec3f126, 0xb5b5ada8aaff80b8,
-    0x87625f056c7c4a8b, 0xc9bcff6034c13053, 0x964e858c91ba2655, 0xdff9772470297ebd, 0xa6dfbd9fb8e5b88f, 0xf8a95fcf88747d94,
-    0xb94470938fa89bcf, 0x8a08f0f8bf0f156b, 0xcdb02555653131b6, 0x993fe2c6d07b7fac, 0xe45c10c42a2b3b06, 0xaa242499697392d3,
-    0xfd87b5f28300ca0e, 0xbce5086492111aeb, 0x8cbccc096f5088cc, 0xd1b71758e219652c, 0x9c40000000000000, 0xe8d4a51000000000,
-    0xad78ebc5ac620000, 0x813f3978f8940984, 0xc097ce7bc90715b3, 0x8f7e32ce7bea5c70, 0xd5d238a4abe98068, 0x9f4f2726179a2245,
-    0xed63a231d4c4fb27, 0xb0de65388cc8ada8, 0x83c7088e1aab65db, 0xc45d1df942711d9a, 0x924d692ca61be758, 0xda01ee641a708dea,
-    0xa26da3999aef774a, 0xf209787bb47d6b85, 0xb454e4a179dd1877, 0x865b86925b9bc5c2, 0xc83553c5c8965d3d, 0x952ab45cfa97a0b3,
-    0xde469fbd99a05fe3, 0xa59bc234db398c25, 0xf6c69a72a3989f5c, 0xb7dcbf5354e9bece, 0x88fcf317f22241e2, 0xcc20ce9bd35c78a5,
-    0x98165af37b2153df, 0xe2a0b5dc971f303a, 0xa8d9d1535ce3b396, 0xfb9b7cd9a4a7443c, 0xbb764c4ca7a44410, 0x8bab8eefb6409c1a,
-    0xd01fef10a657842c, 0x9b10a4e5e9913129, 0xe7109bfba19c0c9d, 0xac2820d9623bf429, 0x80444b5e7aa7cf85, 0xbf21e44003acdd2d,
-    0x8e679c2f5e44ff8f, 0xd433179d9c8cb841, 0x9e19db92b4e31ba9, 0xeb96bf6ebadf77d9, 0xaf87023b9bf0ee6b};
+template <typename T>
+const uint64_t basic_data<T>::POW10_SIGNIFICANDS[] = {
+  0xfa8fd5a0081c0288, 0xbaaee17fa23ebf76, 0x8b16fb203055ac76, 0xcf42894a5dce35ea,
+  0x9a6bb0aa55653b2d, 0xe61acf033d1a45df, 0xab70fe17c79ac6ca, 0xff77b1fcbebcdc4f,
+  0xbe5691ef416bd60c, 0x8dd01fad907ffc3c, 0xd3515c2831559a83, 0x9d71ac8fada6c9b5,
+  0xea9c227723ee8bcb, 0xaecc49914078536d, 0x823c12795db6ce57, 0xc21094364dfb5637,
+  0x9096ea6f3848984f, 0xd77485cb25823ac7, 0xa086cfcd97bf97f4, 0xef340a98172aace5,
+  0xb23867fb2a35b28e, 0x84c8d4dfd2c63f3b, 0xc5dd44271ad3cdba, 0x936b9fcebb25c996,
+  0xdbac6c247d62a584, 0xa3ab66580d5fdaf6, 0xf3e2f893dec3f126, 0xb5b5ada8aaff80b8,
+  0x87625f056c7c4a8b, 0xc9bcff6034c13053, 0x964e858c91ba2655, 0xdff9772470297ebd,
+  0xa6dfbd9fb8e5b88f, 0xf8a95fcf88747d94, 0xb94470938fa89bcf, 0x8a08f0f8bf0f156b,
+  0xcdb02555653131b6, 0x993fe2c6d07b7fac, 0xe45c10c42a2b3b06, 0xaa242499697392d3,
+  0xfd87b5f28300ca0e, 0xbce5086492111aeb, 0x8cbccc096f5088cc, 0xd1b71758e219652c,
+  0x9c40000000000000, 0xe8d4a51000000000, 0xad78ebc5ac620000, 0x813f3978f8940984,
+  0xc097ce7bc90715b3, 0x8f7e32ce7bea5c70, 0xd5d238a4abe98068, 0x9f4f2726179a2245,
+  0xed63a231d4c4fb27, 0xb0de65388cc8ada8, 0x83c7088e1aab65db, 0xc45d1df942711d9a,
+  0x924d692ca61be758, 0xda01ee641a708dea, 0xa26da3999aef774a, 0xf209787bb47d6b85,
+  0xb454e4a179dd1877, 0x865b86925b9bc5c2, 0xc83553c5c8965d3d, 0x952ab45cfa97a0b3,
+  0xde469fbd99a05fe3, 0xa59bc234db398c25, 0xf6c69a72a3989f5c, 0xb7dcbf5354e9bece,
+  0x88fcf317f22241e2, 0xcc20ce9bd35c78a5, 0x98165af37b2153df, 0xe2a0b5dc971f303a,
+  0xa8d9d1535ce3b396, 0xfb9b7cd9a4a7443c, 0xbb764c4ca7a44410, 0x8bab8eefb6409c1a,
+  0xd01fef10a657842c, 0x9b10a4e5e9913129, 0xe7109bfba19c0c9d, 0xac2820d9623bf429,
+  0x80444b5e7aa7cf85, 0xbf21e44003acdd2d, 0x8e679c2f5e44ff8f, 0xd433179d9c8cb841,
+  0x9e19db92b4e31ba9, 0xeb96bf6ebadf77d9, 0xaf87023b9bf0ee6b
+};
 
 // Binary exponents of pow(10, k), for k = -348, -340, ..., 340, corresponding
 // to significands above.
-template<typename T>
-const int16_t basic_data<T>::POW10_EXPONENTS[] = {-1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980, -954, -927, -901,
-    -874, -847, -821, -794, -768, -741, -715, -688, -661, -635, -608, -582, -555, -529, -502, -475, -449, -422, -396, -369, -343, -316,
-    -289, -263, -236, -210, -183, -157, -130, -103, -77, -50, -24, 3, 30, 56, 83, 109, 136, 162, 189, 216, 242, 269, 295, 322, 348, 375,
-    402, 428, 455, 481, 508, 534, 561, 588, 614, 641, 667, 694, 720, 747, 774, 800, 827, 853, 880, 907, 933, 960, 986, 1013, 1039, 1066};
+template <typename T>
+const int16_t basic_data<T>::POW10_EXPONENTS[] = {
+  -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007,  -980,  -954,
+   -927,  -901,  -874,  -847,  -821,  -794,  -768,  -741,  -715,  -688,  -661,
+   -635,  -608,  -582,  -555,  -529,  -502,  -475,  -449,  -422,  -396,  -369,
+   -343,  -316,  -289,  -263,  -236,  -210,  -183,  -157,  -130,  -103,   -77,
+    -50,   -24,     3,    30,    56,    83,   109,   136,   162,   189,   216,
+    242,   269,   295,   322,   348,   375,   402,   428,   455,   481,   508,
+    534,   561,   588,   614,   641,   667,   694,   720,   747,   774,   800,
+    827,   853,   880,   907,   933,   960,   986,  1013,  1039,  1066
+};
 
-FMT_FUNC fp operator*(fp x, fp y)
-{
-    // Multiply 32-bit parts of significands.
-    uint64_t mask = (1ULL << 32) - 1;
-    uint64_t a = x.f >> 32, b = x.f & mask;
-    uint64_t c = y.f >> 32, d = y.f & mask;
-    uint64_t ac = a * c, bc = b * c, ad = a * d, bd = b * d;
-    // Compute mid 64-bit of result and round.
-    uint64_t mid = (bd >> 32) + (ad & mask) + (bc & mask) + (1U << 31);
-    return fp(ac + (ad >> 32) + (bc >> 32) + (mid >> 32), x.e + y.e + 64);
+template <typename T> const char basic_data<T>::RESET_COLOR[] = "\x1b[0m";
+template <typename T> const wchar_t basic_data<T>::WRESET_COLOR[] = L"\x1b[0m";
+
+FMT_FUNC fp operator*(fp x, fp y) {
+  // Multiply 32-bit parts of significands.
+  uint64_t mask = (1ULL << 32) - 1;
+  uint64_t a = x.f >> 32, b = x.f & mask;
+  uint64_t c = y.f >> 32, d = y.f & mask;
+  uint64_t ac = a * c, bc = b * c, ad = a * d, bd = b * d;
+  // Compute mid 64-bit of result and round.
+  uint64_t mid = (bd >> 32) + (ad & mask) + (bc & mask) + (1U << 31);
+  return fp(ac + (ad >> 32) + (bc >> 32) + (mid >> 32), x.e + y.e + 64);
 }
 
-FMT_FUNC fp get_cached_power(int min_exponent, int &pow10_exponent)
-{
-    const double one_over_log2_10 = 0.30102999566398114; // 1 / log2(10)
-    int index = static_cast<int>(std::ceil((min_exponent + fp::significand_size - 1) * one_over_log2_10));
-    // Decimal exponent of the first (smallest) cached power of 10.
-    const int first_dec_exp = -348;
-    // Difference between two consecutive decimal exponents in cached powers of 10.
-    const int dec_exp_step = 8;
-    index = (index - first_dec_exp - 1) / dec_exp_step + 1;
-    pow10_exponent = first_dec_exp + index * dec_exp_step;
-    return fp(data::POW10_SIGNIFICANDS[index], data::POW10_EXPONENTS[index]);
+FMT_FUNC fp get_cached_power(int min_exponent, int &pow10_exponent) {
+  const double one_over_log2_10 = 0.30102999566398114;  // 1 / log2(10)
+  int index = static_cast<int>(std::ceil(
+        (min_exponent + fp::significand_size - 1) * one_over_log2_10));
+  // Decimal exponent of the first (smallest) cached power of 10.
+  const int first_dec_exp = -348;
+  // Difference between two consecutive decimal exponents in cached powers of 10.
+  const int dec_exp_step = 8;
+  index = (index - first_dec_exp - 1) / dec_exp_step + 1;
+  pow10_exponent = first_dec_exp + index * dec_exp_step;
+  return fp(data::POW10_SIGNIFICANDS[index], data::POW10_EXPONENTS[index]);
 }
-} // namespace internal
+}  // namespace internal
 
 #if FMT_USE_WINDOWS_H
 
-FMT_FUNC internal::utf8_to_utf16::utf8_to_utf16(string_view s)
-{
-    static const char ERROR_MSG[] = "cannot convert string from UTF-8 to UTF-16";
-    if (s.size() > INT_MAX)
-        FMT_THROW(windows_error(ERROR_INVALID_PARAMETER, ERROR_MSG));
-    int s_size = static_cast<int>(s.size());
-    if (s_size == 0)
-    {
-        // MultiByteToWideChar does not support zero length, handle separately.
-        buffer_.resize(1);
-        buffer_[0] = 0;
-        return;
-    }
+FMT_FUNC internal::utf8_to_utf16::utf8_to_utf16(string_view s) {
+  static const char ERROR_MSG[] = "cannot convert string from UTF-8 to UTF-16";
+  if (s.size() > INT_MAX)
+    FMT_THROW(windows_error(ERROR_INVALID_PARAMETER, ERROR_MSG));
+  int s_size = static_cast<int>(s.size());
+  if (s_size == 0) {
+    // MultiByteToWideChar does not support zero length, handle separately.
+    buffer_.resize(1);
+    buffer_[0] = 0;
+    return;
+  }
 
-    int length = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, FMT_NULL, 0);
-    if (length == 0)
-        FMT_THROW(windows_error(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(windows_error(GetLastError(), ERROR_MSG));
-    buffer_[length] = 0;
+  int length = MultiByteToWideChar(
+      CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, FMT_NULL, 0);
+  if (length == 0)
+    FMT_THROW(windows_error(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(windows_error(GetLastError(), ERROR_MSG));
+  buffer_[length] = 0;
 }
 
-FMT_FUNC internal::utf16_to_utf8::utf16_to_utf8(wstring_view s)
-{
-    if (int error_code = convert(s))
-    {
-        FMT_THROW(windows_error(error_code, "cannot convert string from UTF-16 to UTF-8"));
-    }
+FMT_FUNC internal::utf16_to_utf8::utf16_to_utf8(wstring_view s) {
+  if (int error_code = convert(s)) {
+    FMT_THROW(windows_error(error_code,
+        "cannot convert string from UTF-16 to UTF-8"));
+  }
 }
 
-FMT_FUNC int internal::utf16_to_utf8::convert(wstring_view s)
-{
-    if (s.size() > INT_MAX)
-        return ERROR_INVALID_PARAMETER;
-    int s_size = static_cast<int>(s.size());
-    if (s_size == 0)
-    {
-        // WideCharToMultiByte does not support zero length, handle separately.
-        buffer_.resize(1);
-        buffer_[0] = 0;
-        return 0;
-    }
-
-    int length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, FMT_NULL, 0, FMT_NULL, FMT_NULL);
-    if (length == 0)
-        return GetLastError();
-    buffer_.resize(length + 1);
-    length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, &buffer_[0], length, FMT_NULL, FMT_NULL);
-    if (length == 0)
-        return GetLastError();
-    buffer_[length] = 0;
+FMT_FUNC int internal::utf16_to_utf8::convert(wstring_view s) {
+  if (s.size() > INT_MAX)
+    return ERROR_INVALID_PARAMETER;
+  int s_size = static_cast<int>(s.size());
+  if (s_size == 0) {
+    // WideCharToMultiByte does not support zero length, handle separately.
+    buffer_.resize(1);
+    buffer_[0] = 0;
     return 0;
+  }
+
+  int length = WideCharToMultiByte(
+        CP_UTF8, 0, s.data(), s_size, FMT_NULL, 0, FMT_NULL, FMT_NULL);
+  if (length == 0)
+    return GetLastError();
+  buffer_.resize(length + 1);
+  length = WideCharToMultiByte(
+    CP_UTF8, 0, s.data(), s_size, &buffer_[0], length, FMT_NULL, FMT_NULL);
+  if (length == 0)
+    return GetLastError();
+  buffer_[length] = 0;
+  return 0;
 }
 
-FMT_FUNC void windows_error::init(int err_code, string_view format_str, format_args args)
-{
-    error_code_ = err_code;
-    memory_buffer buffer;
-    internal::format_windows_error(buffer, err_code, vformat(format_str, args));
-    std::runtime_error &base = *this;
-    base = std::runtime_error(to_string(buffer));
+FMT_FUNC void windows_error::init(
+    int err_code, string_view format_str, format_args args) {
+  error_code_ = err_code;
+  memory_buffer buffer;
+  internal::format_windows_error(buffer, err_code, vformat(format_str, args));
+  std::runtime_error &base = *this;
+  base = std::runtime_error(to_string(buffer));
 }
 
-FMT_FUNC void internal::format_windows_error(internal::buffer &out, int error_code, string_view message) FMT_NOEXCEPT
-{
-    FMT_TRY
-    {
-        wmemory_buffer buf;
-        buf.resize(inline_buffer_size);
-        for (;;)
-        {
-            wchar_t *system_message = &buf[0];
-            int result = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, FMT_NULL, error_code,
-                MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), system_message, static_cast<uint32_t>(buf.size()), FMT_NULL);
-            if (result != 0)
-            {
-                utf16_to_utf8 utf8_message;
-                if (utf8_message.convert(system_message) == ERROR_SUCCESS)
-                {
-                    writer w(out);
-                    w.write(message);
-                    w.write(": ");
-                    w.write(utf8_message);
-                    return;
-                }
-                break;
-            }
-            if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
-                break; // Can't get error message, report error code instead.
-            buf.resize(buf.size() * 2);
+FMT_FUNC void internal::format_windows_error(
+    internal::buffer &out, int error_code, string_view message) FMT_NOEXCEPT {
+  FMT_TRY {
+    wmemory_buffer buf;
+    buf.resize(inline_buffer_size);
+    for (;;) {
+      wchar_t *system_message = &buf[0];
+      int result = FormatMessageW(
+          FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+          FMT_NULL, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+          system_message, static_cast<uint32_t>(buf.size()), FMT_NULL);
+      if (result != 0) {
+        utf16_to_utf8 utf8_message;
+        if (utf8_message.convert(system_message) == ERROR_SUCCESS) {
+          writer w(out);
+          w.write(message);
+          w.write(": ");
+          w.write(utf8_message);
+          return;
         }
+        break;
+      }
+      if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
+        break;  // Can't get error message, report error code instead.
+      buf.resize(buf.size() * 2);
     }
-    FMT_CATCH(...) {}
-    format_error_code(out, error_code, message);
+  } FMT_CATCH(...) {}
+  format_error_code(out, error_code, message);
 }
 
-#endif // FMT_USE_WINDOWS_H
+#endif  // FMT_USE_WINDOWS_H
 
-FMT_FUNC void format_system_error(internal::buffer &out, int error_code, string_view message) FMT_NOEXCEPT
-{
-    FMT_TRY
-    {
-        memory_buffer buf;
-        buf.resize(inline_buffer_size);
-        for (;;)
-        {
-            char *system_message = &buf[0];
-            int result = safe_strerror(error_code, system_message, buf.size());
-            if (result == 0)
-            {
-                writer w(out);
-                w.write(message);
-                w.write(": ");
-                w.write(system_message);
-                return;
-            }
-            if (result != ERANGE)
-                break; // Can't get error message, report error code instead.
-            buf.resize(buf.size() * 2);
-        }
+FMT_FUNC void format_system_error(
+    internal::buffer &out, int error_code, string_view message) FMT_NOEXCEPT {
+  FMT_TRY {
+    memory_buffer buf;
+    buf.resize(inline_buffer_size);
+    for (;;) {
+      char *system_message = &buf[0];
+      int result = safe_strerror(error_code, system_message, buf.size());
+      if (result == 0) {
+        writer w(out);
+        w.write(message);
+        w.write(": ");
+        w.write(system_message);
+        return;
+      }
+      if (result != ERANGE)
+        break;  // Can't get error message, report error code instead.
+      buf.resize(buf.size() * 2);
     }
-    FMT_CATCH(...) {}
-    format_error_code(out, error_code, message);
+  } FMT_CATCH(...) {}
+  format_error_code(out, error_code, message);
 }
 
-template<typename Char>
-void basic_fixed_buffer<Char>::grow(std::size_t)
-{
-    FMT_THROW(std::runtime_error("buffer overflow"));
+template <typename Char>
+void basic_fixed_buffer<Char>::grow(std::size_t) {
+  FMT_THROW(std::runtime_error("buffer overflow"));
 }
 
-FMT_FUNC void internal::error_handler::on_error(const char *message)
-{
-    FMT_THROW(format_error(message));
+FMT_FUNC void internal::error_handler::on_error(const char *message) {
+  FMT_THROW(format_error(message));
 }
 
-FMT_FUNC void report_system_error(int error_code, fmt::string_view message) FMT_NOEXCEPT
-{
-    report_error(format_system_error, error_code, message);
+FMT_FUNC void report_system_error(
+    int error_code, fmt::string_view message) FMT_NOEXCEPT {
+  report_error(format_system_error, error_code, message);
 }
 
 #if FMT_USE_WINDOWS_H
-FMT_FUNC void report_windows_error(int error_code, fmt::string_view message) FMT_NOEXCEPT
-{
-    report_error(internal::format_windows_error, error_code, message);
+FMT_FUNC void report_windows_error(
+    int error_code, fmt::string_view message) FMT_NOEXCEPT {
+  report_error(internal::format_windows_error, error_code, message);
 }
 #endif
 
-FMT_FUNC void vprint(std::FILE *f, string_view format_str, format_args args)
-{
-    memory_buffer buffer;
-    vformat_to(buffer, format_str, args);
-    std::fwrite(buffer.data(), 1, buffer.size(), f);
+FMT_FUNC void vprint(std::FILE *f, string_view format_str, format_args args) {
+  memory_buffer buffer;
+  vformat_to(buffer, format_str, args);
+  std::fwrite(buffer.data(), 1, buffer.size(), f);
 }
 
-FMT_FUNC void vprint(std::FILE *f, wstring_view format_str, wformat_args args)
-{
-    wmemory_buffer buffer;
-    vformat_to(buffer, format_str, args);
-    std::fwrite(buffer.data(), sizeof(wchar_t), buffer.size(), f);
+FMT_FUNC void vprint(std::FILE *f, wstring_view format_str, wformat_args args) {
+  wmemory_buffer buffer;
+  vformat_to(buffer, format_str, args);
+  std::fwrite(buffer.data(), sizeof(wchar_t), buffer.size(), f);
 }
 
-FMT_FUNC void vprint(string_view format_str, format_args args)
-{
-    vprint(stdout, format_str, args);
+FMT_FUNC void vprint(string_view format_str, format_args args) {
+  vprint(stdout, format_str, args);
 }
 
-FMT_FUNC void vprint(wstring_view format_str, wformat_args args)
-{
-    vprint(stdout, format_str, args);
+FMT_FUNC void vprint(wstring_view format_str, wformat_args args) {
+  vprint(stdout, format_str, args);
 }
 
-FMT_FUNC void vprint_colored(color c, string_view format, format_args args)
-{
-    char escape[] = "\x1b[30m";
-    escape[3] = static_cast<char>('0' + c);
-    std::fputs(escape, stdout);
-    vprint(format, args);
-    std::fputs(RESET_COLOR, stdout);
+#ifndef FMT_EXTENDED_COLORS
+FMT_FUNC void vprint_colored(color c, string_view format, format_args args) {
+  char escape[] = "\x1b[30m";
+  escape[3] = static_cast<char>('0' + c);
+  std::fputs(escape, stdout);
+  vprint(format, args);
+  std::fputs(internal::data::RESET_COLOR, stdout);
 }
 
-FMT_FUNC void vprint_colored(color c, wstring_view format, wformat_args args)
-{
-    wchar_t escape[] = L"\x1b[30m";
-    escape[3] = static_cast<wchar_t>('0' + c);
-    std::fputws(escape, stdout);
-    vprint(format, args);
-    std::fputws(WRESET_COLOR, stdout);
+FMT_FUNC void vprint_colored(color c, wstring_view format, wformat_args args) {
+  wchar_t escape[] = L"\x1b[30m";
+  escape[3] = static_cast<wchar_t>('0' + c);
+  std::fputws(escape, stdout);
+  vprint(format, args);
+  std::fputws(internal::data::WRESET_COLOR, stdout);
+}
+#else
+namespace internal {
+FMT_CONSTEXPR void to_esc(uint8_t c, char out[], int offset) {
+  out[offset + 0] = static_cast<char>('0' + c / 100);
+  out[offset + 1] = static_cast<char>('0' + c / 10 % 10);
+  out[offset + 2] = static_cast<char>('0' + c % 10);
+}
+} // namespace internal
+
+FMT_FUNC void vprint_rgb(rgb fd, string_view format, format_args args) {
+  char escape_fd[] = "\x1b[38;2;000;000;000m";
+  internal::to_esc(fd.r, escape_fd, 7);
+  internal::to_esc(fd.g, escape_fd, 11);
+  internal::to_esc(fd.b, escape_fd, 15);
+
+  std::fputs(escape_fd, stdout);
+  vprint(format, args);
+  std::fputs(internal::data::RESET_COLOR, stdout);
 }
 
-FMT_FUNC locale locale_provider::locale()
-{
-    return fmt::locale();
+FMT_FUNC void vprint_rgb(rgb fd, rgb bg, string_view format, format_args args) {
+  char escape_fd[] = "\x1b[38;2;000;000;000m"; // foreground color
+  char escape_bg[] = "\x1b[48;2;000;000;000m"; // background color
+  internal::to_esc(fd.r, escape_fd, 7);
+  internal::to_esc(fd.g, escape_fd, 11);
+  internal::to_esc(fd.b, escape_fd, 15);
+
+  internal::to_esc(bg.r, escape_bg, 7);
+  internal::to_esc(bg.g, escape_bg, 11);
+  internal::to_esc(bg.b, escape_bg, 15);
+
+  std::fputs(escape_fd, stdout);
+  std::fputs(escape_bg, stdout);
+  vprint(format, args);
+  std::fputs(internal::data::RESET_COLOR, stdout);
 }
+#endif
+
+FMT_FUNC locale locale_provider::locale() { return fmt::locale(); }
 
 FMT_END_NAMESPACE
 
 #ifdef _MSC_VER
-#pragma warning(pop)
+# pragma warning(pop)
 #endif
 
-#endif // FMT_FORMAT_INL_H_
+#endif  // FMT_FORMAT_INL_H_
diff --git a/include/spdlog/fmt/bundled/format.cc b/include/spdlog/fmt/bundled/format.cc
deleted file mode 100644
index 41746612..00000000
--- a/include/spdlog/fmt/bundled/format.cc
+++ /dev/null
@@ -1,46 +0,0 @@
-// Formatting library for C++
-//
-// Copyright (c) 2012 - 2016, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#include "fmt/format-inl.h"
-
-namespace fmt {
-
-template struct internal::basic_data<void>;
-
-// Explicit instantiations for char.
-
-template FMT_API char internal::thousands_sep(locale_provider *lp);
-
-template void basic_fixed_buffer<char>::grow(std::size_t);
-
-template void internal::arg_map<format_context>::init(
-    const basic_format_args<format_context> &args);
-
-template FMT_API int internal::char_traits<char>::format_float(
-    char *buffer, std::size_t size, const char *format,
-    unsigned width, int precision, double value);
-
-template FMT_API int internal::char_traits<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 FMT_API wchar_t internal::thousands_sep(locale_provider *lp);
-
-template void basic_fixed_buffer<wchar_t>::grow(std::size_t);
-
-template void internal::arg_map<wformat_context>::init(const wformat_args &args);
-
-template FMT_API int internal::char_traits<wchar_t>::format_float(
-    wchar_t *buffer, std::size_t size, const wchar_t *format,
-    unsigned width, int precision, double value);
-
-template FMT_API int internal::char_traits<wchar_t>::format_float(
-    wchar_t *buffer, std::size_t size, const wchar_t *format,
-    unsigned width, int precision, long double value);
-}  // namespace fmt
diff --git a/include/spdlog/fmt/bundled/format.h b/include/spdlog/fmt/bundled/format.h
index 05a0430f..8b6fadd3 100644
--- a/include/spdlog/fmt/bundled/format.h
+++ b/include/spdlog/fmt/bundled/format.h
@@ -38,195 +38,195 @@
 #include <stdint.h>
 
 #ifdef __clang__
-#define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__)
+# define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__)
 #else
-#define FMT_CLANG_VERSION 0
+# define FMT_CLANG_VERSION 0
 #endif
 
 #ifdef __INTEL_COMPILER
-#define FMT_ICC_VERSION __INTEL_COMPILER
+# define FMT_ICC_VERSION __INTEL_COMPILER
 #elif defined(__ICL)
-#define FMT_ICC_VERSION __ICL
+# define FMT_ICC_VERSION __ICL
 #else
-#define FMT_ICC_VERSION 0
+# define FMT_ICC_VERSION 0
 #endif
 
 #include "core.h"
 
 #if FMT_GCC_VERSION >= 406 || FMT_CLANG_VERSION
-#pragma GCC diagnostic push
+# pragma GCC diagnostic push
 
 // Disable the warning about declaration shadowing because it affects too
 // many valid cases.
-#pragma GCC diagnostic ignored "-Wshadow"
+# 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"
+# pragma GCC diagnostic ignored "-Wsign-conversion"
 #endif
 
 #ifdef _SECURE_SCL
-#define FMT_SECURE_SCL _SECURE_SCL
+# define FMT_SECURE_SCL _SECURE_SCL
 #else
-#define FMT_SECURE_SCL 0
+# define FMT_SECURE_SCL 0
 #endif
 
 #if FMT_SECURE_SCL
-#include <iterator>
+# include <iterator>
 #endif
 
 #ifdef __has_builtin
-#define FMT_HAS_BUILTIN(x) __has_builtin(x)
+# define FMT_HAS_BUILTIN(x) __has_builtin(x)
 #else
-#define FMT_HAS_BUILTIN(x) 0
+# define FMT_HAS_BUILTIN(x) 0
 #endif
 
 #ifdef __GNUC_LIBSTD__
-#define FMT_GNUC_LIBSTD_VERSION (__GNUC_LIBSTD__ * 100 + __GNUC_LIBSTD_MINOR__)
+# define FMT_GNUC_LIBSTD_VERSION (__GNUC_LIBSTD__ * 100 + __GNUC_LIBSTD_MINOR__)
 #endif
 
 #ifndef FMT_THROW
-#if FMT_EXCEPTIONS
-#if FMT_MSC_VER
+# if FMT_EXCEPTIONS
+#  if FMT_MSC_VER
 FMT_BEGIN_NAMESPACE
 namespace internal {
-template<typename Exception>
-inline void do_throw(const Exception &x)
-{
-    // Silence unreachable code warnings in MSVC because these are nearly
-    // impossible to fix in a generic code.
-    volatile bool b = true;
-    if (b)
-        throw x;
+template <typename Exception>
+inline void do_throw(const Exception &x) {
+  // Silence unreachable code warnings in MSVC because these are nearly
+  // impossible to fix in a generic code.
+  volatile bool b = true;
+  if (b)
+    throw x;
+}
 }
-} // namespace internal
 FMT_END_NAMESPACE
-#define FMT_THROW(x) fmt::internal::do_throw(x)
-#else
-#define FMT_THROW(x) throw x
-#endif
-#else
-#define FMT_THROW(x)                                                                                                                       \
-    do                                                                                                                                     \
-    {                                                                                                                                      \
-        static_cast<void>(sizeof(x));                                                                                                      \
-        assert(false);                                                                                                                     \
-    } while (false);
-#endif
+#   define FMT_THROW(x) fmt::internal::do_throw(x)
+#  else
+#   define FMT_THROW(x) throw x
+#  endif
+# else
+#  define FMT_THROW(x) do { static_cast<void>(sizeof(x)); assert(false); } while(false);
+# endif
 #endif
 
 #ifndef FMT_USE_USER_DEFINED_LITERALS
 // For Intel's compiler both it and the system gcc/msc must support UDLs.
-#if (FMT_HAS_FEATURE(cxx_user_literals) || FMT_GCC_VERSION >= 407 || FMT_MSC_VER >= 1900) && (!FMT_ICC_VERSION || FMT_ICC_VERSION >= 1500)
-#define FMT_USE_USER_DEFINED_LITERALS 1
-#else
-#define FMT_USE_USER_DEFINED_LITERALS 0
-#endif
+# if (FMT_HAS_FEATURE(cxx_user_literals) || \
+      FMT_GCC_VERSION >= 407 || FMT_MSC_VER >= 1900) && \
+      (!FMT_ICC_VERSION || FMT_ICC_VERSION >= 1500)
+#  define FMT_USE_USER_DEFINED_LITERALS 1
+# else
+#  define FMT_USE_USER_DEFINED_LITERALS 0
+# endif
 #endif
 
-#if FMT_USE_USER_DEFINED_LITERALS && !defined(FMT_ICC_VERSION) &&                                                                          \
-    ((FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L) || (defined(FMT_CLANG_VERSION) && FMT_CLANG_VERSION >= 304))
-#define FMT_UDL_TEMPLATE 1
+#if FMT_USE_USER_DEFINED_LITERALS && !defined(FMT_ICC_VERSION) && \
+    ((FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L) || \
+    (defined(FMT_CLANG_VERSION) && FMT_CLANG_VERSION >= 304))
+# define FMT_UDL_TEMPLATE 1
 #else
-#define FMT_UDL_TEMPLATE 0
+# define FMT_UDL_TEMPLATE 0
 #endif
 
 #ifndef FMT_USE_EXTERN_TEMPLATES
-#ifndef FMT_HEADER_ONLY
-#define FMT_USE_EXTERN_TEMPLATES ((FMT_CLANG_VERSION >= 209 && __cplusplus >= 201103L) || (FMT_GCC_VERSION >= 303 && FMT_HAS_GXX_CXX11))
-#else
-#define FMT_USE_EXTERN_TEMPLATES 0
-#endif
+# ifndef FMT_HEADER_ONLY
+#  define FMT_USE_EXTERN_TEMPLATES \
+     ((FMT_CLANG_VERSION >= 209 && __cplusplus >= 201103L) || \
+      (FMT_GCC_VERSION >= 303 && FMT_HAS_GXX_CXX11))
+# else
+#  define FMT_USE_EXTERN_TEMPLATES 0
+# endif
 #endif
 
-#if FMT_HAS_GXX_CXX11 || FMT_HAS_FEATURE(cxx_trailing_return) || FMT_MSC_VER >= 1600
-#define FMT_USE_TRAILING_RETURN 1
+#if FMT_HAS_GXX_CXX11 || FMT_HAS_FEATURE(cxx_trailing_return) || \
+    FMT_MSC_VER >= 1600
+# define FMT_USE_TRAILING_RETURN 1
 #else
-#define FMT_USE_TRAILING_RETURN 0
+# define FMT_USE_TRAILING_RETURN 0
 #endif
 
-#if FMT_HAS_GXX_CXX11 || FMT_HAS_FEATURE(cxx_rvalue_references) || FMT_MSC_VER >= 1600
-#define FMT_USE_RVALUE_REFERENCES 1
+#if FMT_HAS_GXX_CXX11 || FMT_HAS_FEATURE(cxx_rvalue_references) || \
+    FMT_MSC_VER >= 1600
+# define FMT_USE_RVALUE_REFERENCES 1
 #else
-#define FMT_USE_RVALUE_REFERENCES 0
+# define FMT_USE_RVALUE_REFERENCES 0
 #endif
 
 #ifndef FMT_USE_GRISU
-#define FMT_USE_GRISU 0
+# define FMT_USE_GRISU 0
 #endif
 
 // __builtin_clz is broken in clang with Microsoft CodeGen:
 // https://github.com/fmtlib/fmt/issues/519
 #ifndef _MSC_VER
-#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_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
+# if FMT_GCC_VERSION >= 400 || FMT_HAS_BUILTIN(__builtin_clzll)
+#  define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n)
+# endif
 #endif
 
 // A workaround for gcc 4.4 that doesn't support union members with ctors.
-#if FMT_GCC_VERSION && FMT_GCC_VERSION <= 404
-#define FMT_UNION struct
+#if (FMT_GCC_VERSION && FMT_GCC_VERSION <= 404) || \
+    (FMT_MSC_VER && FMT_MSC_VER <= 1800)
+# define FMT_UNION struct
 #else
-#define FMT_UNION union
+# define FMT_UNION union
 #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) && !defined(_MANAGED)
-#include <intrin.h> // _BitScanReverse, _BitScanReverse64
+# include <intrin.h>  // _BitScanReverse, _BitScanReverse64
 
 FMT_BEGIN_NAMESPACE
 namespace internal {
 // Avoid Clang with Microsoft CodeGen's -Wunknown-pragmas warning.
-#ifndef __clang__
-#pragma intrinsic(_BitScanReverse)
-#endif
-inline uint32_t clz(uint32_t x)
-{
-    unsigned long r = 0;
-    _BitScanReverse(&r, x);
+# ifndef __clang__
+#  pragma intrinsic(_BitScanReverse)
+# endif
+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;
+  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)
+# define FMT_BUILTIN_CLZ(n) fmt::internal::clz(n)
 
-#if defined(_WIN64) && !defined(__clang__)
-#pragma intrinsic(_BitScanReverse64)
-#endif
+# if defined(_WIN64) && !defined(__clang__)
+#  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);
+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
+  // 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;
+  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)
 }
-#define FMT_BUILTIN_CLZLL(n) fmt::internal::clzll(n)
-} // namespace internal
 FMT_END_NAMESPACE
 #endif
 
@@ -236,155 +236,114 @@ namespace internal {
 // An equivalent of `*reinterpret_cast<Dest*>(&source)` that doesn't produce
 // undefined behavior (e.g. due to type aliasing).
 // Example: uint64_t d = bit_cast<uint64_t>(2.718);
-template<typename Dest, typename Source>
-inline Dest bit_cast(const Source &source)
-{
-    static_assert(sizeof(Dest) == sizeof(Source), "size mismatch");
-    Dest dest;
-    std::memcpy(&dest, &source, sizeof(dest));
-    return dest;
+template <typename Dest, typename Source>
+inline Dest bit_cast(const Source& source) {
+  static_assert(sizeof(Dest) == sizeof(Source), "size mismatch");
+  Dest dest;
+  std::memcpy(&dest, &source, sizeof(dest));
+  return dest;
 }
 
 // An implementation of begin and end for pre-C++11 compilers such as gcc 4.
-template<typename C>
-FMT_CONSTEXPR auto begin(const C &c) -> decltype(c.begin())
-{
-    return c.begin();
-}
-template<typename T, std::size_t N>
-FMT_CONSTEXPR T *begin(T (&array)[N]) FMT_NOEXCEPT
-{
-    return array;
-}
-template<typename C>
-FMT_CONSTEXPR auto end(const C &c) -> decltype(c.end())
-{
-    return c.end();
-}
-template<typename T, std::size_t N>
-FMT_CONSTEXPR T *end(T (&array)[N]) FMT_NOEXCEPT
-{
-    return array + N;
+template <typename C>
+FMT_CONSTEXPR auto begin(const C &c) -> decltype(c.begin()) {
+  return c.begin();
 }
+template <typename T, std::size_t N>
+FMT_CONSTEXPR T *begin(T (&array)[N]) FMT_NOEXCEPT { return array; }
+template <typename C>
+FMT_CONSTEXPR auto end(const C &c) -> decltype(c.end()) { return c.end(); }
+template <typename T, std::size_t N>
+FMT_CONSTEXPR T *end(T (&array)[N]) FMT_NOEXCEPT { return array + N; }
 
 // For std::result_of in gcc 4.4.
-template<typename Result>
-struct function
-{
-    template<typename T>
-    struct result
-    {
-        typedef Result type;
-    };
+template <typename Result>
+struct function {
+  template <typename T>
+  struct result { typedef Result type; };
 };
 
-struct dummy_int
-{
-    int data[2];
-    operator int() const
-    {
-        return 0;
-    }
+struct dummy_int {
+  int data[2];
+  operator int() const { return 0; }
 };
 typedef std::numeric_limits<internal::dummy_int> fputil;
 
 // Dummy implementations of system functions such as signbit and ecvt called
 // if the latter are not available.
-inline dummy_int signbit(...)
-{
-    return dummy_int();
-}
-inline dummy_int _ecvt_s(...)
-{
-    return dummy_int();
-}
-inline dummy_int isinf(...)
-{
-    return dummy_int();
-}
-inline dummy_int _finite(...)
-{
-    return dummy_int();
-}
-inline dummy_int isnan(...)
-{
-    return dummy_int();
-}
-inline dummy_int _isnan(...)
-{
-    return dummy_int();
-}
+inline dummy_int signbit(...) { return dummy_int(); }
+inline dummy_int _ecvt_s(...) { return dummy_int(); }
+inline dummy_int isinf(...) { return dummy_int(); }
+inline dummy_int _finite(...) { return dummy_int(); }
+inline dummy_int isnan(...) { return dummy_int(); }
+inline dummy_int _isnan(...) { return dummy_int(); }
 
 // A handmade floating-point number f * pow(2, e).
-class fp
-{
-private:
-    typedef uint64_t significand_type;
+class fp {
+ private:
+  typedef uint64_t significand_type;
 
-    // All sizes are in bits.
-    static FMT_CONSTEXPR_DECL const int char_size = std::numeric_limits<unsigned char>::digits;
-    // Subtract 1 to account for an implicit most significant bit in the
-    // normalized form.
-    static FMT_CONSTEXPR_DECL const int double_significand_size = std::numeric_limits<double>::digits - 1;
-    static FMT_CONSTEXPR_DECL const uint64_t implicit_bit = 1ull << double_significand_size;
+  // All sizes are in bits.
+  static FMT_CONSTEXPR_DECL const int char_size =
+    std::numeric_limits<unsigned char>::digits;
+  // Subtract 1 to account for an implicit most significant bit in the
+  // normalized form.
+  static FMT_CONSTEXPR_DECL const int double_significand_size =
+    std::numeric_limits<double>::digits - 1;
+  static FMT_CONSTEXPR_DECL const uint64_t implicit_bit =
+    1ull << double_significand_size;
 
-public:
-    significand_type f;
-    int e;
+ public:
+  significand_type f;
+  int e;
 
-    static FMT_CONSTEXPR_DECL const int significand_size = sizeof(significand_type) * char_size;
+  static FMT_CONSTEXPR_DECL const int significand_size =
+    sizeof(significand_type) * char_size;
 
-    fp(uint64_t f, int e)
-        : f(f)
-        , e(e)
-    {
-    }
-
-    // Constructs fp from an IEEE754 double. It is a template to prevent compile
-    // errors on platforms where double is not IEEE754.
-    template<typename Double>
-    explicit fp(Double d)
-    {
-        // Assume double is in the format [sign][exponent][significand].
-        typedef std::numeric_limits<Double> limits;
-        const int double_size = sizeof(Double) * char_size;
-        const int exponent_size = double_size - double_significand_size - 1; // -1 for sign
-        const uint64_t significand_mask = implicit_bit - 1;
-        const uint64_t exponent_mask = (~0ull >> 1) & ~significand_mask;
-        const int exponent_bias = (1 << exponent_size) - limits::max_exponent - 1;
-        auto u = bit_cast<uint64_t>(d);
-        auto biased_e = (u & exponent_mask) >> double_significand_size;
-        f = u & significand_mask;
-        if (biased_e != 0)
-            f += implicit_bit;
-        else
-            biased_e = 1; // Subnormals use biased exponent 1 (min exponent).
-        e = static_cast<int>(biased_e - exponent_bias - double_significand_size);
-    }
-
-    // Normalizes the value converted from double and multiplied by (1 << SHIFT).
-    template<int SHIFT = 0>
-    void normalize()
-    {
-        // Handle subnormals.
-        auto shifted_implicit_bit = implicit_bit << SHIFT;
-        while ((f & shifted_implicit_bit) == 0)
-        {
-            f <<= 1;
-            --e;
-        }
-        // Subtract 1 to account for hidden bit.
-        auto offset = significand_size - double_significand_size - SHIFT - 1;
-        f <<= offset;
-        e -= offset;
+  fp(uint64_t f, int e): f(f), e(e) {}
+
+  // Constructs fp from an IEEE754 double. It is a template to prevent compile
+  // errors on platforms where double is not IEEE754.
+  template <typename Double>
+  explicit fp(Double d) {
+    // Assume double is in the format [sign][exponent][significand].
+    typedef std::numeric_limits<Double> limits;
+    const int double_size = sizeof(Double) * char_size;
+    const int exponent_size =
+      double_size - double_significand_size - 1;  // -1 for sign
+    const uint64_t significand_mask = implicit_bit - 1;
+    const uint64_t exponent_mask = (~0ull >> 1) & ~significand_mask;
+    const int exponent_bias = (1 << exponent_size) - limits::max_exponent - 1;
+    auto u = bit_cast<uint64_t>(d);
+    auto biased_e = (u & exponent_mask) >> double_significand_size;
+    f = u & significand_mask;
+    if (biased_e != 0)
+      f += implicit_bit;
+    else
+      biased_e = 1;  // Subnormals use biased exponent 1 (min exponent).
+    e = static_cast<int>(biased_e - exponent_bias - double_significand_size);
+  }
+
+  // Normalizes the value converted from double and multiplied by (1 << SHIFT).
+  template <int SHIFT = 0>
+  void normalize() {
+    // Handle subnormals.
+    auto shifted_implicit_bit = implicit_bit << SHIFT;
+    while ((f & shifted_implicit_bit) == 0) {
+      f <<= 1;
+      --e;
     }
+    // Subtract 1 to account for hidden bit.
+    auto offset = significand_size - double_significand_size - SHIFT - 1;
+    f <<= offset;
+    e -= offset;
+  }
 };
 
 // Returns an fp number representing x - y. Result may not be normalized.
-inline fp operator-(fp x, fp y)
-{
-    FMT_ASSERT(x.f >= y.f && x.e == y.e, "invalid operands");
-    return fp(x.f - y.f, x.e);
+inline fp operator-(fp x, fp y) {
+  FMT_ASSERT(x.f >= y.f && x.e == y.e, "invalid operands");
+  return fp(x.f - y.f, x.e);
 }
 
 // Computes an fp number r with r.f = x.f * y.f / pow(2, 64) rounded to nearest
@@ -395,24 +354,20 @@ fp operator*(fp x, fp y);
 // (binary) exponent satisfies min_exponent <= c_k.e <= min_exponent + 3.
 fp get_cached_power(int min_exponent, int &pow10_exponent);
 
-template<typename Allocator>
-typename Allocator::value_type *allocate(Allocator &alloc, std::size_t n)
-{
+template <typename Allocator>
+typename Allocator::value_type *allocate(Allocator& alloc, std::size_t n) {
 #if __cplusplus >= 201103L || FMT_MSC_VER >= 1700
-    return std::allocator_traits<Allocator>::allocate(alloc, n);
+  return std::allocator_traits<Allocator>::allocate(alloc, n);
 #else
-    return alloc.allocate(n);
+  return alloc.allocate(n);
 #endif
 }
 
 // A helper function to suppress bogus "conditional expression is constant"
 // warnings.
-template<typename T>
-inline T const_check(T value)
-{
-    return value;
-}
-} // namespace internal
+template <typename T>
+inline T const_check(T value) { return value; }
+}  // namespace internal
 FMT_END_NAMESPACE
 
 namespace std {
@@ -420,179 +375,133 @@ namespace std {
 // 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::dummy_int> : 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(dummy_int)))
-            return isinf(x) != 0;
-        return !_finite(static_cast<double>(x));
-    }
+template <>
+class numeric_limits<fmt::internal::dummy_int> :
+    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(dummy_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(fmt::internal::dummy_int)))
-            return isnan(x) != 0;
-        return _isnan(static_cast<double>(x)) != 0;
-    }
+  // Portable version of isnan.
+  template <typename T>
+  static bool isnotanumber(T x) {
+    using namespace fmt::internal;
+    if (const_check(sizeof(isnan(x)) != sizeof(fmt::internal::dummy_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(fmt::internal::dummy_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;
-    }
+  // Portable version of signbit.
+  static bool isnegative(double x) {
+    using namespace fmt::internal;
+    if (const_check(sizeof(signbit(x)) != sizeof(fmt::internal::dummy_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 std
 
 FMT_BEGIN_NAMESPACE
-template<typename Range>
+template <typename Range>
 class basic_writer;
 
-template<typename OutputIt, typename T = typename OutputIt::value_type>
-class output_range
-{
-private:
-    OutputIt it_;
+template <typename OutputIt, typename T = typename OutputIt::value_type>
+class output_range {
+ private:
+  OutputIt it_;
 
-    // Unused yet.
-    typedef void sentinel;
-    sentinel end() const;
+  // Unused yet.
+  typedef void sentinel;
+  sentinel end() const;
 
-public:
-    typedef OutputIt iterator;
-    typedef T value_type;
+ public:
+  typedef OutputIt iterator;
+  typedef T value_type;
 
-    explicit output_range(OutputIt it)
-        : it_(it)
-    {
-    }
-    OutputIt begin() const
-    {
-        return it_;
-    }
+  explicit output_range(OutputIt it): it_(it) {}
+  OutputIt begin() const { return it_; }
 };
 
 // A range where begin() returns back_insert_iterator.
-template<typename Container>
-class back_insert_range : public output_range<std::back_insert_iterator<Container>>
-{
-    typedef output_range<std::back_insert_iterator<Container>> base;
+template <typename Container>
+class back_insert_range:
+    public output_range<std::back_insert_iterator<Container>> {
+  typedef output_range<std::back_insert_iterator<Container>> base;
+ public:
+  typedef typename Container::value_type value_type;
 
-public:
-    typedef typename Container::value_type value_type;
-
-    back_insert_range(Container &c)
-        : base(std::back_inserter(c))
-    {
-    }
-    back_insert_range(typename base::iterator it)
-        : base(it)
-    {
-    }
+  back_insert_range(Container &c): base(std::back_inserter(c)) {}
+  back_insert_range(typename base::iterator it): base(it) {}
 };
 
 typedef basic_writer<back_insert_range<internal::buffer>> writer;
 typedef basic_writer<back_insert_range<internal::wbuffer>> wwriter;
 
 /** A formatting error such as invalid format string. */
-class format_error : public std::runtime_error
-{
-public:
-    explicit format_error(const char *message)
-        : std::runtime_error(message)
-    {
-    }
+class format_error : public std::runtime_error {
+ public:
+  explicit format_error(const char *message)
+  : std::runtime_error(message) {}
 
-    explicit format_error(const std::string &message)
-        : std::runtime_error(message)
-    {
-    }
+  explicit format_error(const std::string &message)
+  : std::runtime_error(message) {}
 };
 
 namespace internal {
 
-// Casts nonnegative integer to unsigned.
-template<typename Int>
-FMT_CONSTEXPR typename std::make_unsigned<Int>::type to_unsigned(Int value)
-{
-    FMT_ASSERT(value >= 0, "negative value");
-    return static_cast<typename std::make_unsigned<Int>::type>(value);
-}
-
 #if FMT_SECURE_SCL
-template<typename T>
-struct checked
-{
-    typedef stdext::checked_array_iterator<T *> type;
-};
+template <typename T>
+struct checked { typedef stdext::checked_array_iterator<T*> type; };
 
 // Make a checked iterator to avoid warnings on MSVC.
-template<typename T>
-inline stdext::checked_array_iterator<T *> make_checked(T *p, std::size_t size)
-{
-    return {p, size};
+template <typename T>
+inline stdext::checked_array_iterator<T*> make_checked(T *p, std::size_t size) {
+  return {p, size};
 }
 #else
-template<typename T>
-struct checked
-{
-    typedef T *type;
-};
-template<typename T>
-inline T *make_checked(T *p, std::size_t)
-{
-    return p;
-}
+template <typename T>
+struct checked { typedef T *type; };
+template <typename T>
+inline T *make_checked(T *p, std::size_t) { return p; }
 #endif
 
-template<typename T>
-template<typename U>
-void basic_buffer<T>::append(const U *begin, const U *end)
-{
-    std::size_t new_size = size_ + internal::to_unsigned(end - begin);
-    reserve(new_size);
-    std::uninitialized_copy(begin, end, internal::make_checked(ptr_, capacity_) + size_);
-    size_ = new_size;
+template <typename T>
+template <typename U>
+void basic_buffer<T>::append(const U *begin, const U *end) {
+  std::size_t new_size = size_ + internal::to_unsigned(end - begin);
+  reserve(new_size);
+  std::uninitialized_copy(begin, end,
+                          internal::make_checked(ptr_, capacity_) + size_);
+  size_ = new_size;
 }
-} // namespace internal
+}  // namespace internal
 
 // A wrapper around std::locale used to reduce compile times since <locale>
 // is very heavy.
 class locale;
 
-class locale_provider
-{
-public:
-    virtual ~locale_provider() {}
-    virtual fmt::locale locale();
+class locale_provider {
+ public:
+  virtual ~locale_provider() {}
+  virtual fmt::locale locale();
 };
 
 // The number of characters to store in the basic_memory_buffer object itself
 // to avoid dynamic memory allocation.
-enum
-{
-    inline_buffer_size = 500
-};
+enum { inline_buffer_size = 500 };
 
 /**
   \rst
@@ -623,106 +532,92 @@ enum
   The output can be converted to an ``std::string`` with ``to_string(out)``.
   \endrst
  */
-template<typename T, std::size_t SIZE = inline_buffer_size, typename Allocator = std::allocator<T>>
-class basic_memory_buffer : private Allocator, public internal::basic_buffer<T>
-{
-private:
-    T store_[SIZE];
+template <typename T, std::size_t SIZE = inline_buffer_size,
+          typename Allocator = std::allocator<T> >
+class basic_memory_buffer: private Allocator, public internal::basic_buffer<T> {
+ private:
+  T store_[SIZE];
 
-    // Deallocate memory allocated by the buffer.
-    void deallocate()
-    {
-        T *data = this->data();
-        if (data != store_)
-            Allocator::deallocate(data, this->capacity());
-    }
+  // Deallocate memory allocated by the buffer.
+  void deallocate() {
+    T* data = this->data();
+    if (data != store_) Allocator::deallocate(data, this->capacity());
+  }
 
-protected:
-    void grow(std::size_t size) FMT_OVERRIDE;
+ protected:
+  void grow(std::size_t size) FMT_OVERRIDE;
 
-public:
-    explicit basic_memory_buffer(const Allocator &alloc = Allocator())
-        : Allocator(alloc)
-    {
-        this->set(store_, SIZE);
-    }
-    ~basic_memory_buffer()
-    {
-        deallocate();
-    }
+ public:
+  explicit basic_memory_buffer(const Allocator &alloc = Allocator())
+      : Allocator(alloc) {
+    this->set(store_, SIZE);
+  }
+  ~basic_memory_buffer() { deallocate(); }
 
-private:
-    // Move data from other to this buffer.
-    void move(basic_memory_buffer &other)
-    {
-        Allocator &this_alloc = *this, &other_alloc = other;
-        this_alloc = std::move(other_alloc);
-        T *data = other.data();
-        std::size_t size = other.size(), capacity = other.capacity();
-        if (data == other.store_)
-        {
-            this->set(store_, capacity);
-            std::uninitialized_copy(other.store_, other.store_ + size, internal::make_checked(store_, capacity));
-        }
-        else
-        {
-            this->set(data, capacity);
-            // Set pointer to the inline array so that delete is not called
-            // when deallocating.
-            other.set(other.store_, 0);
-        }
-        this->resize(size);
+ private:
+  // Move data from other to this buffer.
+  void move(basic_memory_buffer &other) {
+    Allocator &this_alloc = *this, &other_alloc = other;
+    this_alloc = std::move(other_alloc);
+    T* data = other.data();
+    std::size_t size = other.size(), capacity = other.capacity();
+    if (data == other.store_) {
+      this->set(store_, capacity);
+      std::uninitialized_copy(other.store_, other.store_ + size,
+                              internal::make_checked(store_, capacity));
+    } else {
+      this->set(data, capacity);
+      // Set pointer to the inline array so that delete is not called
+      // when deallocating.
+      other.set(other.store_, 0);
     }
+    this->resize(size);
+  }
 
-public:
-    /**
-      \rst
-      Constructs a :class:`fmt::basic_memory_buffer` object moving the content
-      of the other object to it.
-      \endrst
-     */
-    basic_memory_buffer(basic_memory_buffer &&other)
-    {
-        move(other);
-    }
+ public:
+  /**
+    \rst
+    Constructs a :class:`fmt::basic_memory_buffer` object moving the content
+    of the other object to it.
+    \endrst
+   */
+  basic_memory_buffer(basic_memory_buffer &&other) {
+    move(other);
+  }
 
-    /**
-      \rst
-      Moves the content of the other ``basic_memory_buffer`` object to this one.
-      \endrst
-     */
-    basic_memory_buffer &operator=(basic_memory_buffer &&other)
-    {
-        assert(this != &other);
-        deallocate();
-        move(other);
-        return *this;
-    }
+  /**
+    \rst
+    Moves the content of the other ``basic_memory_buffer`` object to this one.
+    \endrst
+   */
+  basic_memory_buffer &operator=(basic_memory_buffer &&other) {
+    assert(this != &other);
+    deallocate();
+    move(other);
+    return *this;
+  }
 
-    // Returns a copy of the allocator associated with this buffer.
-    Allocator get_allocator() const
-    {
-        return *this;
-    }
+  // 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 basic_memory_buffer<T, SIZE, Allocator>::grow(std::size_t size)
-{
-    std::size_t old_capacity = this->capacity();
-    std::size_t new_capacity = old_capacity + old_capacity / 2;
-    if (size > new_capacity)
-        new_capacity = size;
-    T *old_data = this->data();
-    T *new_data = internal::allocate<Allocator>(*this, new_capacity);
-    // The following code doesn't throw, so the raw pointer above doesn't leak.
-    std::uninitialized_copy(old_data, old_data + this->size(), internal::make_checked(new_data, new_capacity));
-    this->set(new_data, new_capacity);
-    // deallocate must not throw according to the standard, but even if it does,
-    // the buffer already uses the new storage and will deallocate it in
-    // destructor.
-    if (old_data != store_)
-        Allocator::deallocate(old_data, old_capacity);
+template <typename T, std::size_t SIZE, typename Allocator>
+void basic_memory_buffer<T, SIZE, Allocator>::grow(std::size_t size) {
+  std::size_t old_capacity = this->capacity();
+  std::size_t new_capacity = old_capacity + old_capacity / 2;
+  if (size > new_capacity)
+      new_capacity = size;
+  T *old_data = this->data();
+  T *new_data = internal::allocate<Allocator>(*this, new_capacity);
+  // The following code doesn't throw, so the raw pointer above doesn't leak.
+  std::uninitialized_copy(old_data, old_data + this->size(),
+                          internal::make_checked(new_data, new_capacity));
+  this->set(new_data, new_capacity);
+  // deallocate must not throw according to the standard, but even if it does,
+  // the buffer already uses the new storage and will deallocate it in
+  // destructor.
+  if (old_data != store_)
+    Allocator::deallocate(old_data, old_capacity);
 }
 
 typedef basic_memory_buffer<char> memory_buffer;
@@ -737,341 +632,289 @@ typedef basic_memory_buffer<wchar_t> wmemory_buffer;
   ``std::runtime_error``.
   \endrst
  */
-template<typename Char>
-class basic_fixed_buffer : public internal::basic_buffer<Char>
-{
-public:
-    /**
-     \rst
-     Constructs a :class:`fmt::basic_fixed_buffer` object for *array* of the
-     given size.
-     \endrst
-     */
-    basic_fixed_buffer(Char *array, std::size_t size)
-    {
-        this->set(array, size);
-    }
+template <typename Char>
+class basic_fixed_buffer : public internal::basic_buffer<Char> {
+ public:
+  /**
+   \rst
+   Constructs a :class:`fmt::basic_fixed_buffer` object for *array* of the
+   given size.
+   \endrst
+   */
+  basic_fixed_buffer(Char *array, std::size_t size) {
+    this->set(array, size);
+  }
 
-    /**
-     \rst
-     Constructs a :class:`fmt::basic_fixed_buffer` object for *array* of the
-     size known at compile time.
-     \endrst
-     */
-    template<std::size_t SIZE>
-    explicit basic_fixed_buffer(Char (&array)[SIZE])
-    {
-        this->set(array, SIZE);
-    }
+  /**
+   \rst
+   Constructs a :class:`fmt::basic_fixed_buffer` object for *array* of the
+   size known at compile time.
+   \endrst
+   */
+  template <std::size_t SIZE>
+  explicit basic_fixed_buffer(Char (&array)[SIZE]) {
+    this->set(array, SIZE);
+  }
 
-protected:
-    FMT_API void grow(std::size_t size) FMT_OVERRIDE;
+ protected:
+  FMT_API void grow(std::size_t size) FMT_OVERRIDE;
 };
 
 namespace internal {
 
-template<typename Char>
+template <typename Char>
 struct char_traits;
 
-template<>
-struct char_traits<char>
-{
-    // Formats a floating-point number.
-    template<typename T>
-    FMT_API static int format_float(char *buffer, std::size_t size, const char *format, int precision, T value);
+template <>
+struct char_traits<char> {
+  // Formats a floating-point number.
+  template <typename T>
+  FMT_API static int format_float(char *buffer, std::size_t size,
+      const char *format, int precision, T value);
 };
 
-template<>
-struct char_traits<wchar_t>
-{
-    template<typename T>
-    FMT_API static int format_float(wchar_t *buffer, std::size_t size, const wchar_t *format, int precision, T value);
+template <>
+struct char_traits<wchar_t> {
+  template <typename T>
+  FMT_API static int format_float(wchar_t *buffer, std::size_t size,
+      const wchar_t *format, int precision, T value);
 };
 
 #if FMT_USE_EXTERN_TEMPLATES
 extern template int char_traits<char>::format_float<double>(
-    char *buffer, std::size_t size, const char *format, int precision, double value);
+    char *buffer, std::size_t size, const char* format, int precision,
+    double value);
 extern template int char_traits<char>::format_float<long double>(
-    char *buffer, std::size_t size, const char *format, int precision, long double value);
+    char *buffer, std::size_t size, const char* format, int precision,
+    long double value);
 
 extern template int char_traits<wchar_t>::format_float<double>(
-    wchar_t *buffer, std::size_t size, const wchar_t *format, int precision, double value);
+    wchar_t *buffer, std::size_t size, const wchar_t* format, int precision,
+    double value);
 extern template int char_traits<wchar_t>::format_float<long double>(
-    wchar_t *buffer, std::size_t size, const wchar_t *format, int precision, long double value);
+    wchar_t *buffer, std::size_t size, const wchar_t* format, int precision,
+    long double value);
 #endif
 
-template<typename Container>
-inline typename std::enable_if<is_contiguous<Container>::value, typename checked<typename Container::value_type>::type>::type reserve(
-    std::back_insert_iterator<Container> &it, std::size_t n)
-{
-    Container &c = internal::get_container(it);
-    std::size_t size = c.size();
-    c.resize(size + n);
-    return make_checked(&c[size], n);
+template <typename Container>
+inline typename std::enable_if<
+  is_contiguous<Container>::value,
+  typename checked<typename Container::value_type>::type>::type
+    reserve(std::back_insert_iterator<Container> &it, std::size_t n) {
+  Container &c = internal::get_container(it);
+  std::size_t size = c.size();
+  c.resize(size + n);
+  return make_checked(&c[size], n);
 }
 
-template<typename Iterator>
-inline Iterator &reserve(Iterator &it, std::size_t)
-{
-    return it;
-}
+template <typename Iterator>
+inline Iterator &reserve(Iterator &it, std::size_t) { return it; }
 
-template<typename Char>
+template <typename Char>
 class null_terminating_iterator;
 
-template<typename Char>
+template <typename Char>
 FMT_CONSTEXPR_DECL const Char *pointer_from(null_terminating_iterator<Char> it);
 
 // An iterator that produces a null terminator on *end. This simplifies parsing
 // and allows comparing the performance of processing a null-terminated string
 // vs string_view.
-template<typename Char>
-class null_terminating_iterator
-{
-public:
-    typedef std::ptrdiff_t difference_type;
-    typedef Char value_type;
-    typedef const Char *pointer;
-    typedef const Char &reference;
-    typedef std::random_access_iterator_tag iterator_category;
+template <typename Char>
+class null_terminating_iterator {
+ public:
+  typedef std::ptrdiff_t difference_type;
+  typedef Char value_type;
+  typedef const Char* pointer;
+  typedef const Char& reference;
+  typedef std::random_access_iterator_tag iterator_category;
 
-    null_terminating_iterator()
-        : ptr_(0)
-        , end_(0)
-    {
-    }
+  null_terminating_iterator() : ptr_(0), end_(0) {}
 
-    FMT_CONSTEXPR null_terminating_iterator(const Char *ptr, const Char *end)
-        : ptr_(ptr)
-        , end_(end)
-    {
-    }
+  FMT_CONSTEXPR null_terminating_iterator(const Char *ptr, const Char *end)
+    : ptr_(ptr), end_(end) {}
 
-    template<typename Range>
-    FMT_CONSTEXPR explicit null_terminating_iterator(const Range &r)
-        : ptr_(r.begin())
-        , end_(r.end())
-    {
-    }
+  template <typename Range>
+  FMT_CONSTEXPR explicit null_terminating_iterator(const Range &r)
+    : ptr_(r.begin()), end_(r.end()) {}
 
-    null_terminating_iterator &operator=(const Char *ptr)
-    {
-        assert(ptr <= end_);
-        ptr_ = ptr;
-        return *this;
-    }
+  null_terminating_iterator &operator=(const Char *ptr) {
+    assert(ptr <= end_);
+    ptr_ = ptr;
+    return *this;
+  }
 
-    FMT_CONSTEXPR Char operator*() const
-    {
-        return ptr_ != end_ ? *ptr_ : 0;
-    }
+  FMT_CONSTEXPR Char operator*() const {
+    return ptr_ != end_ ? *ptr_ : 0;
+  }
 
-    FMT_CONSTEXPR null_terminating_iterator operator++()
-    {
-        ++ptr_;
-        return *this;
-    }
+  FMT_CONSTEXPR null_terminating_iterator operator++() {
+    ++ptr_;
+    return *this;
+  }
 
-    FMT_CONSTEXPR null_terminating_iterator operator++(int)
-    {
-        null_terminating_iterator result(*this);
-        ++ptr_;
-        return result;
-    }
+  FMT_CONSTEXPR null_terminating_iterator operator++(int) {
+    null_terminating_iterator result(*this);
+    ++ptr_;
+    return result;
+  }
 
-    FMT_CONSTEXPR null_terminating_iterator operator--()
-    {
-        --ptr_;
-        return *this;
-    }
+  FMT_CONSTEXPR null_terminating_iterator operator--() {
+    --ptr_;
+    return *this;
+  }
 
-    FMT_CONSTEXPR null_terminating_iterator operator+(difference_type n)
-    {
-        return null_terminating_iterator(ptr_ + n, end_);
-    }
+  FMT_CONSTEXPR null_terminating_iterator operator+(difference_type n) {
+    return null_terminating_iterator(ptr_ + n, end_);
+  }
 
-    FMT_CONSTEXPR null_terminating_iterator operator-(difference_type n)
-    {
-        return null_terminating_iterator(ptr_ - n, end_);
-    }
+  FMT_CONSTEXPR null_terminating_iterator operator-(difference_type n) {
+    return null_terminating_iterator(ptr_ - n, end_);
+  }
 
-    FMT_CONSTEXPR null_terminating_iterator operator+=(difference_type n)
-    {
-        ptr_ += n;
-        return *this;
-    }
+  FMT_CONSTEXPR null_terminating_iterator operator+=(difference_type n) {
+    ptr_ += n;
+    return *this;
+  }
 
-    FMT_CONSTEXPR difference_type operator-(null_terminating_iterator other) const
-    {
-        return ptr_ - other.ptr_;
-    }
+  FMT_CONSTEXPR difference_type operator-(
+      null_terminating_iterator other) const {
+    return ptr_ - other.ptr_;
+  }
 
-    FMT_CONSTEXPR bool operator!=(null_terminating_iterator other) const
-    {
-        return ptr_ != other.ptr_;
-    }
+  FMT_CONSTEXPR bool operator!=(null_terminating_iterator other) const {
+    return ptr_ != other.ptr_;
+  }
 
-    bool operator>=(null_terminating_iterator other) const
-    {
-        return ptr_ >= other.ptr_;
-    }
+  bool operator>=(null_terminating_iterator other) const {
+    return ptr_ >= other.ptr_;
+  }
 
-    // This should be a friend specialization pointer_from<Char> but the latter
-    // doesn't compile by gcc 5.1 due to a compiler bug.
-    template<typename CharT>
-    friend FMT_CONSTEXPR_DECL const CharT *pointer_from(null_terminating_iterator<CharT> it);
+  // This should be a friend specialization pointer_from<Char> but the latter
+  // doesn't compile by gcc 5.1 due to a compiler bug.
+  template <typename CharT>
+  friend FMT_CONSTEXPR_DECL const CharT *pointer_from(
+      null_terminating_iterator<CharT> it);
 
-private:
-    const Char *ptr_;
-    const Char *end_;
+ private:
+  const Char *ptr_;
+  const Char *end_;
 };
 
-template<typename T>
-FMT_CONSTEXPR const T *pointer_from(const T *p)
-{
-    return p;
-}
+template <typename T>
+FMT_CONSTEXPR const T *pointer_from(const T *p) { return p; }
 
-template<typename Char>
-FMT_CONSTEXPR const Char *pointer_from(null_terminating_iterator<Char> it)
-{
-    return it.ptr_;
+template <typename Char>
+FMT_CONSTEXPR const Char *pointer_from(null_terminating_iterator<Char> it) {
+  return it.ptr_;
 }
 
 // An output iterator that counts the number of objects written to it and
 // discards them.
-template<typename T>
-class counting_iterator
-{
-private:
-    std::size_t count_;
-    mutable T blackhole_;
+template <typename T>
+class counting_iterator {
+ private:
+  std::size_t count_;
+  mutable T blackhole_;
 
-public:
-    typedef std::output_iterator_tag iterator_category;
-    typedef T value_type;
-    typedef std::ptrdiff_t difference_type;
-    typedef T *pointer;
-    typedef T &reference;
-    typedef counting_iterator _Unchecked_type; // Mark iterator as checked.
+ public:
+  typedef std::output_iterator_tag iterator_category;
+  typedef T value_type;
+  typedef std::ptrdiff_t difference_type;
+  typedef T* pointer;
+  typedef T& reference;
+  typedef counting_iterator _Unchecked_type;  // Mark iterator as checked.
 
-    counting_iterator()
-        : count_(0)
-    {
-    }
+  counting_iterator(): count_(0) {}
 
-    std::size_t count() const
-    {
-        return count_;
-    }
+  std::size_t count() const { return count_; }
 
-    counting_iterator &operator++()
-    {
-        ++count_;
-        return *this;
-    }
+  counting_iterator& operator++() {
+    ++count_;
+    return *this;
+  }
 
-    counting_iterator operator++(int)
-    {
-        auto it = *this;
-        ++*this;
-        return it;
-    }
+  counting_iterator operator++(int) {
+    auto it = *this;
+    ++*this;
+    return it;
+  }
 
-    T &operator*() const
-    {
-        return blackhole_;
-    }
+  T &operator*() const { return blackhole_; }
 };
 
 // An output iterator that truncates the output and counts the number of objects
 // written to it.
-template<typename OutputIt>
-class truncating_iterator
-{
-private:
-    typedef std::iterator_traits<OutputIt> traits;
+template <typename OutputIt>
+class truncating_iterator {
+ private:
+  typedef std::iterator_traits<OutputIt> traits;
 
-    OutputIt out_;
-    std::size_t limit_;
-    std::size_t count_;
-    mutable typename traits::value_type blackhole_;
+  OutputIt out_;
+  std::size_t limit_;
+  std::size_t count_;
+  mutable typename traits::value_type blackhole_;
 
-public:
-    typedef std::output_iterator_tag iterator_category;
-    typedef typename traits::value_type value_type;
-    typedef typename traits::difference_type difference_type;
-    typedef typename traits::pointer pointer;
-    typedef typename traits::reference reference;
-    typedef truncating_iterator _Unchecked_type; // Mark iterator as checked.
+ public:
+  typedef std::output_iterator_tag iterator_category;
+  typedef typename traits::value_type value_type;
+  typedef typename traits::difference_type difference_type;
+  typedef typename traits::pointer pointer;
+  typedef typename traits::reference reference;
+  typedef truncating_iterator _Unchecked_type;  // Mark iterator as checked.
 
-    truncating_iterator(OutputIt out, std::size_t limit)
-        : out_(out)
-        , limit_(limit)
-        , count_(0)
-    {
-    }
+  truncating_iterator(OutputIt out, std::size_t limit)
+    : out_(out), limit_(limit), count_(0) {}
 
-    OutputIt base() const
-    {
-        return out_;
-    }
-    std::size_t count() const
-    {
-        return count_;
-    }
+  OutputIt base() const { return out_; }
+  std::size_t count() const { return count_; }
 
-    truncating_iterator &operator++()
-    {
-        if (count_++ < limit_)
-            ++out_;
-        return *this;
-    }
+  truncating_iterator& operator++() {
+    if (count_++ < limit_)
+      ++out_;
+    return *this;
+  }
 
-    truncating_iterator operator++(int)
-    {
-        auto it = *this;
-        ++*this;
-        return it;
-    }
+  truncating_iterator operator++(int) {
+    auto it = *this;
+    ++*this;
+    return it;
+  }
 
-    reference operator*() const
-    {
-        return count_ < limit_ ? *out_ : blackhole_;
-    }
+  reference operator*() const { return count_ < limit_ ? *out_ : blackhole_; }
 };
 
 // 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>
-FMT_CONSTEXPR typename std::enable_if<std::numeric_limits<T>::is_signed, bool>::type is_negative(T value)
-{
-    return value < 0;
+template <typename T>
+FMT_CONSTEXPR typename std::enable_if<
+    std::numeric_limits<T>::is_signed, bool>::type is_negative(T value) {
+  return value < 0;
 }
-template<typename T>
-FMT_CONSTEXPR typename std::enable_if<!std::numeric_limits<T>::is_signed, bool>::type is_negative(T)
-{
-    return false;
+template <typename T>
+FMT_CONSTEXPR typename std::enable_if<
+    !std::numeric_limits<T>::is_signed, bool>::type is_negative(T) {
+  return false;
 }
 
-template<typename T>
-struct int_traits
-{
-    // Smallest of uint32_t and uint64_t that is large enough to represent
-    // all values of T.
-    typedef typename std::conditional<std::numeric_limits<T>::digits <= 32, uint32_t, uint64_t>::type main_type;
+template <typename T>
+struct int_traits {
+  // Smallest of uint32_t and uint64_t that is large enough to represent
+  // all values of T.
+  typedef typename std::conditional<
+    std::numeric_limits<T>::digits <= 32, uint32_t, uint64_t>::type main_type;
 };
 
 // Static data is placed in this class template to allow header-only
 // configuration.
-template<typename T = void>
-struct FMT_API basic_data
-{
-    static const uint32_t POWERS_OF_10_32[];
-    static const uint64_t POWERS_OF_10_64[];
-    static const uint64_t POW10_SIGNIFICANDS[];
-    static const int16_t POW10_EXPONENTS[];
-    static const char DIGITS[];
+template <typename T = void>
+struct FMT_API basic_data {
+  static const uint32_t POWERS_OF_10_32[];
+  static const uint64_t POWERS_OF_10_64[];
+  static const uint64_t POW10_SIGNIFICANDS[];
+  static const int16_t POW10_EXPONENTS[];
+  static const char DIGITS[];
+  static const char RESET_COLOR[];
+  static const wchar_t WRESET_COLOR[];
 };
 
 #if FMT_USE_EXTERN_TEMPLATES
@@ -1083,254 +926,220 @@ typedef basic_data<> 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;
+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;
-    }
+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
 
 #if FMT_HAS_CPP_ATTRIBUTE(always_inline)
-#define FMT_ALWAYS_INLINE __attribute__((always_inline))
+# define FMT_ALWAYS_INLINE __attribute__((always_inline))
 #else
-#define FMT_ALWAYS_INLINE
+# define FMT_ALWAYS_INLINE
 #endif
 
-template<typename Handler>
+template <typename Handler>
 inline char *lg(uint32_t n, Handler h) FMT_ALWAYS_INLINE;
 
 // Computes g = floor(log10(n)) and calls h.on<g>(n);
-template<typename Handler>
-inline char *lg(uint32_t n, Handler h)
-{
-    return n < 100 ? n < 10 ? h.template on<0>(n) : h.template on<1>(n)
-                   : n < 1000000 ? n < 10000 ? n < 1000 ? h.template on<2>(n) : h.template on<3>(n)
-                                             : n < 100000 ? h.template on<4>(n) : h.template on<5>(n)
-                                 : n < 100000000 ? n < 10000000 ? h.template on<6>(n) : h.template on<7>(n)
-                                                 : n < 1000000000 ? h.template on<8>(n) : h.template on<9>(n);
+template <typename Handler>
+inline char *lg(uint32_t n, Handler h) {
+  return n < 100 ? n < 10 ? h.template on<0>(n) : h.template on<1>(n)
+                 : n < 1000000
+                       ? n < 10000 ? n < 1000 ? h.template on<2>(n)
+                                              : h.template on<3>(n)
+                                   : n < 100000 ? h.template on<4>(n)
+                                                : h.template on<5>(n)
+                       : n < 100000000 ? n < 10000000 ? h.template on<6>(n)
+                                                      : h.template on<7>(n)
+                                       : n < 1000000000 ? h.template on<8>(n)
+                                                        : h.template on<9>(n);
 }
 
 // An lg handler that formats a decimal number.
 // Usage: lg(n, decimal_formatter(buffer));
-class decimal_formatter
-{
-private:
-    char *buffer_;
+class decimal_formatter {
+ private:
+  char *buffer_;
 
-    void write_pair(unsigned N, uint32_t index)
-    {
-        std::memcpy(buffer_ + N, data::DIGITS + index * 2, 2);
-    }
+  void write_pair(unsigned N, uint32_t index) {
+    std::memcpy(buffer_ + N, data::DIGITS + index * 2, 2);
+  }
 
-public:
-    explicit decimal_formatter(char *buf)
-        : buffer_(buf)
-    {
-    }
+ public:
+  explicit decimal_formatter(char *buf) : buffer_(buf) {}
 
-    template<unsigned N>
-    char *on(uint32_t u)
-    {
-        if (N == 0)
-        {
-            *buffer_ = static_cast<char>(u) + '0';
-        }
-        else if (N == 1)
-        {
-            write_pair(0, u);
-        }
-        else
-        {
-            // The idea of using 4.32 fixed-point numbers is based on
-            // https://github.com/jeaiii/itoa
-            unsigned n = N - 1;
-            unsigned a = n / 5 * n * 53 / 16;
-            uint64_t t = ((1ULL << (32 + a)) / data::POWERS_OF_10_32[n] + 1 - n / 9);
-            t = ((t * u) >> a) + n / 5 * 4;
-            write_pair(0, t >> 32);
-            for (int i = 2; i < N; i += 2)
-            {
-                t = 100ULL * static_cast<uint32_t>(t);
-                write_pair(i, t >> 32);
-            }
-            if (N % 2 == 0)
-            {
-                buffer_[N] = static_cast<char>((10ULL * static_cast<uint32_t>(t)) >> 32) + '0';
-            }
-        }
-        return buffer_ += N + 1;
+  template <unsigned N> char *on(uint32_t u) {
+    if (N == 0) {
+      *buffer_ = static_cast<char>(u) + '0';
+    } else if (N == 1) {
+      write_pair(0, u);
+    } else {
+      // The idea of using 4.32 fixed-point numbers is based on
+      // https://github.com/jeaiii/itoa
+      unsigned n = N - 1;
+      unsigned a = n / 5 * n * 53 / 16;
+      uint64_t t = ((1ULL << (32 + a)) / data::POWERS_OF_10_32[n] + 1 - n / 9);
+      t = ((t * u) >> a) + n / 5 * 4;
+      write_pair(0, t >> 32);
+      for (unsigned i = 2; i < N; i += 2) {
+        t = 100ULL * static_cast<uint32_t>(t);
+        write_pair(i, t >> 32);
+      }
+      if (N % 2 == 0) {
+        buffer_[N] = static_cast<char>(
+          (10ULL * static_cast<uint32_t>(t)) >> 32) + '0';
+      }
     }
+    return buffer_ += N + 1;
+  }
 };
 
 // An lg handler that formats a decimal number with a terminating null.
-class decimal_formatter_null : public decimal_formatter
-{
-public:
-    explicit decimal_formatter_null(char *buf)
-        : decimal_formatter(buf)
-    {
-    }
+class decimal_formatter_null : public decimal_formatter {
+ public:
+  explicit decimal_formatter_null(char *buf) : decimal_formatter(buf) {}
 
-    template<unsigned N>
-    char *on(uint32_t u)
-    {
-        char *buf = decimal_formatter::on<N>(u);
-        *buf = '\0';
-        return buf;
-    }
+  template <unsigned N> char *on(uint32_t u) {
+    char *buf = decimal_formatter::on<N>(u);
+    *buf = '\0';
+    return buf;
+  }
 };
 
 #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;
+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 no_thousands_sep
-{
-    typedef char char_type;
+struct no_thousands_sep {
+  typedef char char_type;
 
-    template<typename Char>
-    void operator()(Char *)
-    {
-    }
+  template <typename Char>
+  void operator()(Char *) {}
 };
 
 // A functor that adds a thousands separator.
-template<typename Char>
-class add_thousands_sep
-{
-private:
-    basic_string_view<Char> sep_;
+template <typename Char>
+class add_thousands_sep {
+ private:
+  basic_string_view<Char> sep_;
 
-    // Index of a decimal digit with the least significant digit having index 0.
-    unsigned digit_index_;
+  // Index of a decimal digit with the least significant digit having index 0.
+  unsigned digit_index_;
 
-public:
-    typedef Char char_type;
+ public:
+  typedef Char char_type;
 
-    explicit add_thousands_sep(basic_string_view<Char> sep)
-        : sep_(sep)
-        , digit_index_(0)
-    {
-    }
+  explicit add_thousands_sep(basic_string_view<Char> sep)
+    : sep_(sep), digit_index_(0) {}
 
-    void operator()(Char *&buffer)
-    {
-        if (++digit_index_ % 3 != 0)
-            return;
-        buffer -= sep_.size();
-        std::uninitialized_copy(sep_.data(), sep_.data() + sep_.size(), internal::make_checked(buffer, sep_.size()));
-    }
+  void operator()(Char *&buffer) {
+    if (++digit_index_ % 3 != 0)
+      return;
+    buffer -= sep_.size();
+    std::uninitialized_copy(sep_.data(), sep_.data() + sep_.size(),
+                            internal::make_checked(buffer, sep_.size()));
+  }
 };
 
-template<typename Char>
+template <typename Char>
 FMT_API Char thousands_sep(locale_provider *lp);
 
 // 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 Char *format_decimal(Char *buffer, UInt value, unsigned num_digits, ThousandsSep thousands_sep)
-{
-    buffer += num_digits;
-    Char *end = buffer;
-    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 end;
-    }
-    unsigned index = static_cast<unsigned>(value * 2);
+template <typename UInt, typename Char, typename ThousandsSep>
+inline Char *format_decimal(Char *buffer, UInt value, unsigned num_digits,
+                            ThousandsSep thousands_sep) {
+  buffer += num_digits;
+  Char *end = buffer;
+  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 end;
+  }
+  unsigned index = static_cast<unsigned>(value * 2);
+  *--buffer = data::DIGITS[index + 1];
+  thousands_sep(buffer);
+  *--buffer = data::DIGITS[index];
+  return end;
 }
 
-template<typename UInt, typename Iterator, typename ThousandsSep>
-inline Iterator format_decimal(Iterator out, UInt value, unsigned num_digits, ThousandsSep sep)
-{
-    typedef typename ThousandsSep::char_type char_type;
-    // Buffer should be large enough to hold all digits (digits10 + 1) and null.
-    char_type buffer[std::numeric_limits<UInt>::digits10 + 2];
-    format_decimal(buffer, value, num_digits, sep);
-    return std::copy_n(buffer, num_digits, out);
+template <typename UInt, typename Iterator, typename ThousandsSep>
+inline Iterator format_decimal(
+    Iterator out, UInt value, unsigned num_digits, ThousandsSep sep) {
+  typedef typename ThousandsSep::char_type char_type;
+  // Buffer should be large enough to hold all digits (digits10 + 1) and null.
+  char_type buffer[std::numeric_limits<UInt>::digits10 + 2];
+  format_decimal(buffer, value, num_digits, sep);
+  return std::copy_n(buffer, num_digits, out);
 }
 
-template<typename It, typename UInt>
-inline It format_decimal(It out, UInt value, unsigned num_digits)
-{
-    return format_decimal(out, value, num_digits, no_thousands_sep());
+template <typename It, typename UInt>
+inline It format_decimal(It out, UInt value, unsigned num_digits) {
+  return format_decimal(out, value, num_digits, no_thousands_sep());
 }
 
-template<unsigned BASE_BITS, typename Char, typename UInt>
-inline Char *format_uint(Char *buffer, UInt value, unsigned num_digits, bool upper = false)
-{
-    buffer += num_digits;
-    Char *end = buffer;
-    do
-    {
-        const char *digits = upper ? "0123456789ABCDEF" : "0123456789abcdef";
-        unsigned digit = (value & ((1 << BASE_BITS) - 1));
-        *--buffer = BASE_BITS < 4 ? static_cast<char>('0' + digit) : digits[digit];
-    } while ((value >>= BASE_BITS) != 0);
-    return end;
+template <unsigned BASE_BITS, typename Char, typename UInt>
+inline Char *format_uint(Char *buffer, UInt value, unsigned num_digits,
+                         bool upper = false) {
+  buffer += num_digits;
+  Char *end = buffer;
+  do {
+    const char *digits = upper ? "0123456789ABCDEF" : "0123456789abcdef";
+    unsigned digit = (value & ((1 << BASE_BITS) - 1));
+    *--buffer = BASE_BITS < 4 ? static_cast<char>('0' + digit) : digits[digit];
+  } while ((value >>= BASE_BITS) != 0);
+  return end;
 }
 
-template<unsigned BASE_BITS, typename It, typename UInt>
-inline It format_uint(It out, UInt value, unsigned num_digits, bool upper = false)
-{
-    // Buffer should be large enough to hold all digits (digits / BASE_BITS + 1)
-    // and null.
-    char buffer[std::numeric_limits<UInt>::digits / BASE_BITS + 2];
-    format_uint<BASE_BITS>(buffer, value, num_digits, upper);
-    return std::copy_n(buffer, num_digits, out);
+template <unsigned BASE_BITS, typename It, typename UInt>
+inline It format_uint(It out, UInt value, unsigned num_digits,
+                      bool upper = false) {
+  // Buffer should be large enough to hold all digits (digits / BASE_BITS + 1)
+  // and null.
+  char buffer[std::numeric_limits<UInt>::digits / BASE_BITS + 2];
+  format_uint<BASE_BITS>(buffer, value, num_digits, upper);
+  return std::copy_n(buffer, num_digits, out);
 }
 
 #ifndef _WIN32
-#define FMT_USE_WINDOWS_H 0
+# define FMT_USE_WINDOWS_H 0
 #elif !defined(FMT_USE_WINDOWS_H)
-#define FMT_USE_WINDOWS_H 1
+# define FMT_USE_WINDOWS_H 1
 #endif
 
 // Define FMT_USE_WINDOWS_H to 0 to disable use of windows.h.
@@ -1338,76 +1147,47 @@ inline It format_uint(It out, UInt value, unsigned num_digits, bool upper = fals
 #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 utf8_to_utf16
-{
-private:
-    wmemory_buffer buffer_;
+class utf8_to_utf16 {
+ private:
+  wmemory_buffer buffer_;
 
-public:
-    FMT_API explicit utf8_to_utf16(string_view s);
-    operator wstring_view() const
-    {
-        return wstring_view(&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());
-    }
+ public:
+  FMT_API explicit utf8_to_utf16(string_view s);
+  operator wstring_view() const { return wstring_view(&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 utf16_to_utf8
-{
-private:
-    memory_buffer buffer_;
+class utf16_to_utf8 {
+ private:
+  memory_buffer buffer_;
 
-public:
-    utf16_to_utf8() {}
-    FMT_API explicit utf16_to_utf8(wstring_view s);
-    operator string_view() const
-    {
-        return string_view(&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());
-    }
+ public:
+  utf16_to_utf8() {}
+  FMT_API explicit utf16_to_utf8(wstring_view s);
+  operator string_view() const { return string_view(&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(wstring_view s);
+  // 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(wstring_view s);
 };
 
-FMT_API void format_windows_error(fmt::internal::buffer &out, int error_code, fmt::string_view message) FMT_NOEXCEPT;
+FMT_API void format_windows_error(fmt::internal::buffer &out, int error_code,
+                                  fmt::string_view message) FMT_NOEXCEPT;
 #endif
 
-template<typename T = void>
-struct null
-{
-};
-} // namespace internal
+template <typename T = void>
+struct null {};
+}  // namespace internal
 
-struct monostate
-{
-};
+struct monostate {};
 
 /**
   \rst
@@ -1416,1146 +1196,821 @@ struct monostate
   ``vis(value)`` will be called with the value of type ``double``.
   \endrst
  */
-template<typename Visitor, typename Context>
-FMT_CONSTEXPR typename internal::result_of<Visitor(int)>::type visit(Visitor &&vis, basic_format_arg<Context> arg)
-{
-    typedef typename Context::char_type char_type;
-    switch (arg.type_)
-    {
-    case internal::none_type:
-        break;
-    case internal::named_arg_type:
-        FMT_ASSERT(false, "invalid argument type");
-        break;
-    case internal::int_type:
-        return vis(arg.value_.int_value);
-    case internal::uint_type:
-        return vis(arg.value_.uint_value);
-    case internal::long_long_type:
-        return vis(arg.value_.long_long_value);
-    case internal::ulong_long_type:
-        return vis(arg.value_.ulong_long_value);
-    case internal::bool_type:
-        return vis(arg.value_.int_value != 0);
-    case internal::char_type:
-        return vis(static_cast<char_type>(arg.value_.int_value));
-    case internal::double_type:
-        return vis(arg.value_.double_value);
-    case internal::long_double_type:
-        return vis(arg.value_.long_double_value);
-    case internal::cstring_type:
-        return vis(arg.value_.string.value);
-    case internal::string_type:
-        return vis(basic_string_view<char_type>(arg.value_.string.value, arg.value_.string.size));
-    case internal::pointer_type:
-        return vis(arg.value_.pointer);
-    case internal::custom_type:
-        return vis(typename basic_format_arg<Context>::handle(arg.value_.custom));
-    }
-    return vis(monostate());
+template <typename Visitor, typename Context>
+FMT_CONSTEXPR typename internal::result_of<Visitor(int)>::type
+    visit(Visitor &&vis, basic_format_arg<Context> arg) {
+  typedef typename Context::char_type char_type;
+  switch (arg.type_) {
+  case internal::none_type:
+    break;
+  case internal::named_arg_type:
+    FMT_ASSERT(false, "invalid argument type");
+    break;
+  case internal::int_type:
+    return vis(arg.value_.int_value);
+  case internal::uint_type:
+    return vis(arg.value_.uint_value);
+  case internal::long_long_type:
+    return vis(arg.value_.long_long_value);
+  case internal::ulong_long_type:
+    return vis(arg.value_.ulong_long_value);
+  case internal::bool_type:
+    return vis(arg.value_.int_value != 0);
+  case internal::char_type:
+    return vis(static_cast<char_type>(arg.value_.int_value));
+  case internal::double_type:
+    return vis(arg.value_.double_value);
+  case internal::long_double_type:
+    return vis(arg.value_.long_double_value);
+  case internal::cstring_type:
+    return vis(arg.value_.string.value);
+  case internal::string_type:
+    return vis(basic_string_view<char_type>(
+                 arg.value_.string.value, arg.value_.string.size));
+  case internal::pointer_type:
+    return vis(arg.value_.pointer);
+  case internal::custom_type:
+    return vis(typename basic_format_arg<Context>::handle(arg.value_.custom));
+  }
+  return vis(monostate());
 }
 
-enum alignment
-{
-    ALIGN_DEFAULT,
-    ALIGN_LEFT,
-    ALIGN_RIGHT,
-    ALIGN_CENTER,
-    ALIGN_NUMERIC
+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
-};
+enum {SIGN_FLAG = 1, PLUS_FLAG = 2, MINUS_FLAG = 4, HASH_FLAG = 8};
 
-enum format_spec_tag
-{
-    fill_tag,
-    align_tag,
-    width_tag,
-    type_tag
-};
+enum format_spec_tag {fill_tag, align_tag, width_tag, type_tag};
 
 // Format specifier.
-template<typename T, format_spec_tag>
-class format_spec
-{
-private:
-    T value_;
+template <typename T, format_spec_tag>
+class format_spec {
+ private:
+  T value_;
 
-public:
-    typedef T value_type;
+ public:
+  typedef T value_type;
 
-    explicit format_spec(T value)
-        : value_(value)
-    {
-    }
+  explicit format_spec(T value) : value_(value) {}
 
-    T value() const
-    {
-        return value_;
-    }
+  T value() const { return value_; }
 };
 
 // template <typename Char>
 // typedef format_spec<Char, fill_tag> fill_spec;
-template<typename Char>
-class fill_spec : public format_spec<Char, fill_tag>
-{
-public:
-    explicit fill_spec(Char value)
-        : format_spec<Char, fill_tag>(value)
-    {
-    }
+template <typename Char>
+class fill_spec : public format_spec<Char, fill_tag> {
+ public:
+  explicit fill_spec(Char value) : format_spec<Char, fill_tag>(value) {}
 };
 
 typedef format_spec<unsigned, width_tag> width_spec;
 typedef format_spec<char, type_tag> type_spec;
 
 // An empty format specifier.
-struct empty_spec
-{
-};
+struct empty_spec {};
 
 // An alignment specifier.
-struct align_spec : empty_spec
-{
-    unsigned width_;
-    // Fill is always wchar_t and cast to char if necessary to avoid having
-    // two specialization of AlignSpec and its subclasses.
-    wchar_t fill_;
-    alignment align_;
+struct align_spec : empty_spec {
+  unsigned width_;
+  // Fill is always wchar_t and cast to char if necessary to avoid having
+  // two specialization of AlignSpec and its subclasses.
+  wchar_t fill_;
+  alignment align_;
 
-    FMT_CONSTEXPR align_spec(unsigned width, wchar_t fill, alignment align = ALIGN_DEFAULT)
-        : width_(width)
-        , fill_(fill)
-        , align_(align)
-    {
-    }
+  FMT_CONSTEXPR align_spec(
+      unsigned width, wchar_t fill, alignment align = ALIGN_DEFAULT)
+  : width_(width), fill_(fill), align_(align) {}
 
-    FMT_CONSTEXPR unsigned width() const
-    {
-        return width_;
-    }
-    FMT_CONSTEXPR wchar_t fill() const
-    {
-        return fill_;
-    }
-    FMT_CONSTEXPR alignment align() const
-    {
-        return align_;
-    }
+  FMT_CONSTEXPR unsigned width() const { return width_; }
+  FMT_CONSTEXPR wchar_t fill() const { return fill_; }
+  FMT_CONSTEXPR alignment align() const { return align_; }
 
-    int precision() const
-    {
-        return -1;
-    }
+  int precision() const { return -1; }
 };
 
 // Format specifiers.
-template<typename Char>
-class basic_format_specs : public align_spec
-{
-private:
-    template<typename FillChar>
-    typename std::enable_if<std::is_same<FillChar, Char>::value || std::is_same<FillChar, char>::value, void>::type set(
-        fill_spec<FillChar> fill)
-    {
-        fill_ = fill.value();
-    }
+template <typename Char>
+class basic_format_specs : public align_spec {
+ public:
+  unsigned flags_;
+  int precision_;
+  Char type_;
 
-    void set(width_spec width)
-    {
-        width_ = width.value();
-    }
+  FMT_CONSTEXPR basic_format_specs(
+      unsigned width = 0, char type = 0, wchar_t fill = ' ')
+  : align_spec(width, fill), flags_(0), precision_(-1), type_(type) {}
 
-    void set(type_spec type)
-    {
-        type_ = type.value();
-    }
-
-    template<typename Spec, typename... Specs>
-    void set(Spec spec, Specs... tail)
-    {
-        set(spec);
-        set(tail...);
-    }
-
-public:
-    unsigned flags_;
-    int precision_;
-    Char type_;
-
-    FMT_CONSTEXPR basic_format_specs(unsigned width = 0, char type = 0, wchar_t fill = ' ')
-        : align_spec(width, fill)
-        , flags_(0)
-        , precision_(-1)
-        , type_(type)
-    {
-    }
-
-    template<typename... FormatSpecs>
-    explicit basic_format_specs(FormatSpecs... specs)
-        : align_spec(0, ' ')
-        , flags_(0)
-        , precision_(-1)
-        , type_(0)
-    {
-        set(specs...);
-    }
-
-    FMT_CONSTEXPR bool flag(unsigned f) const
-    {
-        return (flags_ & f) != 0;
-    }
-    FMT_CONSTEXPR int precision() const
-    {
-        return precision_;
-    }
-    FMT_CONSTEXPR Char type() const
-    {
-        return type_;
-    }
+  FMT_CONSTEXPR bool flag(unsigned f) const { return (flags_ & f) != 0; }
+  FMT_CONSTEXPR int precision() const { return precision_; }
+  FMT_CONSTEXPR Char type() const { return type_; }
 };
 
 typedef basic_format_specs<char> format_specs;
 
-template<typename Char, typename ErrorHandler>
-FMT_CONSTEXPR unsigned basic_parse_context<Char, ErrorHandler>::next_arg_id()
-{
-    if (next_arg_id_ >= 0)
-        return internal::to_unsigned(next_arg_id_++);
-    on_error("cannot switch from manual to automatic argument indexing");
-    return 0;
+template <typename Char, typename ErrorHandler>
+FMT_CONSTEXPR unsigned basic_parse_context<Char, ErrorHandler>::next_arg_id() {
+  if (next_arg_id_ >= 0)
+    return internal::to_unsigned(next_arg_id_++);
+  on_error("cannot switch from manual to automatic argument indexing");
+  return 0;
 }
 
-struct format_string
-{
-};
+struct format_string {};
 
 namespace internal {
 
-template<typename Char, typename Handler>
-FMT_CONSTEXPR void handle_int_type_spec(Char spec, Handler &&handler)
-{
-    switch (spec)
-    {
-    case 0:
-    case 'd':
-        handler.on_dec();
-        break;
-    case 'x':
-    case 'X':
-        handler.on_hex();
-        break;
-    case 'b':
-    case 'B':
-        handler.on_bin();
-        break;
-    case 'o':
-        handler.on_oct();
-        break;
-    case 'n':
-        handler.on_num();
-        break;
-    default:
-        handler.on_error();
-    }
+template <typename Char, typename Handler>
+FMT_CONSTEXPR void handle_int_type_spec(Char spec, Handler &&handler) {
+  switch (spec) {
+  case 0: case 'd':
+    handler.on_dec();
+    break;
+  case 'x': case 'X':
+    handler.on_hex();
+    break;
+  case 'b': case 'B':
+    handler.on_bin();
+    break;
+  case 'o':
+    handler.on_oct();
+    break;
+  case 'n':
+    handler.on_num();
+    break;
+  default:
+    handler.on_error();
+  }
 }
 
-template<typename Char, typename Handler>
-FMT_CONSTEXPR void handle_float_type_spec(Char spec, Handler &&handler)
-{
-    switch (spec)
-    {
-    case 0:
-    case 'g':
-    case 'G':
-        handler.on_general();
-        break;
-    case 'e':
-    case 'E':
-        handler.on_exp();
-        break;
-    case 'f':
-    case 'F':
-        handler.on_fixed();
-        break;
-    case 'a':
-    case 'A':
-        handler.on_hex();
-        break;
-    default:
-        handler.on_error();
-        break;
-    }
+template <typename Char, typename Handler>
+FMT_CONSTEXPR void handle_float_type_spec(Char spec, Handler &&handler) {
+  switch (spec) {
+  case 0: case 'g': case 'G':
+    handler.on_general();
+    break;
+  case 'e': case 'E':
+    handler.on_exp();
+    break;
+  case 'f': case 'F':
+    handler.on_fixed();
+    break;
+   case 'a': case 'A':
+    handler.on_hex();
+    break;
+  default:
+    handler.on_error();
+    break;
+  }
 }
 
-template<typename Char, typename Handler>
-FMT_CONSTEXPR void handle_char_specs(const basic_format_specs<Char> &specs, Handler &&handler)
-{
-    if (specs.type() && specs.type() != 'c')
-    {
-        handler.on_int();
-        return;
-    }
-    if (specs.align() == ALIGN_NUMERIC || specs.flag(~0u) != 0)
-        handler.on_error("invalid format specifier for char");
-    handler.on_char();
+template <typename Char, typename Handler>
+FMT_CONSTEXPR void handle_char_specs(
+    const basic_format_specs<Char> &specs, Handler &&handler) {
+  if (specs.type() && specs.type() != 'c') {
+    handler.on_int();
+    return;
+  }
+  if (specs.align() == ALIGN_NUMERIC || specs.flag(~0u) != 0)
+    handler.on_error("invalid format specifier for char");
+  handler.on_char();
 }
 
-template<typename Char, typename Handler>
-FMT_CONSTEXPR void handle_cstring_type_spec(Char spec, Handler &&handler)
-{
-    if (spec == 0 || spec == 's')
-        handler.on_string();
-    else if (spec == 'p')
-        handler.on_pointer();
-    else
-        handler.on_error("invalid type specifier");
+template <typename Char, typename Handler>
+FMT_CONSTEXPR void handle_cstring_type_spec(Char spec, Handler &&handler) {
+  if (spec == 0 || spec == 's')
+    handler.on_string();
+  else if (spec == 'p')
+    handler.on_pointer();
+  else
+    handler.on_error("invalid type specifier");
 }
 
-template<typename Char, typename ErrorHandler>
-FMT_CONSTEXPR void check_string_type_spec(Char spec, ErrorHandler &&eh)
-{
-    if (spec != 0 && spec != 's')
-        eh.on_error("invalid type specifier");
+template <typename Char, typename ErrorHandler>
+FMT_CONSTEXPR void check_string_type_spec(Char spec, ErrorHandler &&eh) {
+  if (spec != 0 && spec != 's')
+    eh.on_error("invalid type specifier");
 }
 
-template<typename Char, typename ErrorHandler>
-FMT_CONSTEXPR void check_pointer_type_spec(Char spec, ErrorHandler &&eh)
-{
-    if (spec != 0 && spec != 'p')
-        eh.on_error("invalid type specifier");
+template <typename Char, typename ErrorHandler>
+FMT_CONSTEXPR void check_pointer_type_spec(Char spec, ErrorHandler &&eh) {
+  if (spec != 0 && spec != 'p')
+    eh.on_error("invalid type specifier");
 }
 
-template<typename ErrorHandler>
-class int_type_checker : private ErrorHandler
-{
-public:
-    FMT_CONSTEXPR explicit int_type_checker(ErrorHandler eh)
-        : ErrorHandler(eh)
-    {
-    }
+template <typename ErrorHandler>
+class int_type_checker : private ErrorHandler {
+ public:
+  FMT_CONSTEXPR explicit int_type_checker(ErrorHandler eh) : ErrorHandler(eh) {}
 
-    FMT_CONSTEXPR void on_dec() {}
-    FMT_CONSTEXPR void on_hex() {}
-    FMT_CONSTEXPR void on_bin() {}
-    FMT_CONSTEXPR void on_oct() {}
-    FMT_CONSTEXPR void on_num() {}
+  FMT_CONSTEXPR void on_dec() {}
+  FMT_CONSTEXPR void on_hex() {}
+  FMT_CONSTEXPR void on_bin() {}
+  FMT_CONSTEXPR void on_oct() {}
+  FMT_CONSTEXPR void on_num() {}
 
-    FMT_CONSTEXPR void on_error()
-    {
-        ErrorHandler::on_error("invalid type specifier");
-    }
+  FMT_CONSTEXPR void on_error() {
+    ErrorHandler::on_error("invalid type specifier");
+  }
 };
 
-template<typename ErrorHandler>
-class float_type_checker : private ErrorHandler
-{
-public:
-    FMT_CONSTEXPR explicit float_type_checker(ErrorHandler eh)
-        : ErrorHandler(eh)
-    {
-    }
+template <typename ErrorHandler>
+class float_type_checker : private ErrorHandler {
+ public:
+  FMT_CONSTEXPR explicit float_type_checker(ErrorHandler eh)
+    : ErrorHandler(eh) {}
 
-    FMT_CONSTEXPR void on_general() {}
-    FMT_CONSTEXPR void on_exp() {}
-    FMT_CONSTEXPR void on_fixed() {}
-    FMT_CONSTEXPR void on_hex() {}
+  FMT_CONSTEXPR void on_general() {}
+  FMT_CONSTEXPR void on_exp() {}
+  FMT_CONSTEXPR void on_fixed() {}
+  FMT_CONSTEXPR void on_hex() {}
 
-    FMT_CONSTEXPR void on_error()
-    {
-        ErrorHandler::on_error("invalid type specifier");
-    }
+  FMT_CONSTEXPR void on_error() {
+    ErrorHandler::on_error("invalid type specifier");
+  }
 };
 
-template<typename ErrorHandler, typename CharType>
-class char_specs_checker : public ErrorHandler
-{
-private:
-    CharType type_;
+template <typename ErrorHandler, typename CharType>
+class char_specs_checker : public ErrorHandler {
+ private:
+  CharType type_;
 
-public:
-    FMT_CONSTEXPR char_specs_checker(CharType type, ErrorHandler eh)
-        : ErrorHandler(eh)
-        , type_(type)
-    {
-    }
+ public:
+  FMT_CONSTEXPR char_specs_checker(CharType type, ErrorHandler eh)
+    : ErrorHandler(eh), type_(type) {}
 
-    FMT_CONSTEXPR void on_int()
-    {
-        handle_int_type_spec(type_, int_type_checker<ErrorHandler>(*this));
-    }
-    FMT_CONSTEXPR void on_char() {}
+  FMT_CONSTEXPR void on_int() {
+    handle_int_type_spec(type_, int_type_checker<ErrorHandler>(*this));
+  }
+  FMT_CONSTEXPR void on_char() {}
 };
 
-template<typename ErrorHandler>
-class cstring_type_checker : public ErrorHandler
-{
-public:
-    FMT_CONSTEXPR explicit cstring_type_checker(ErrorHandler eh)
-        : ErrorHandler(eh)
-    {
-    }
+template <typename ErrorHandler>
+class cstring_type_checker : public ErrorHandler {
+ public:
+  FMT_CONSTEXPR explicit cstring_type_checker(ErrorHandler eh)
+    : ErrorHandler(eh) {}
 
-    FMT_CONSTEXPR void on_string() {}
-    FMT_CONSTEXPR void on_pointer() {}
+  FMT_CONSTEXPR void on_string() {}
+  FMT_CONSTEXPR void on_pointer() {}
 };
 
-template<typename Context>
-void arg_map<Context>::init(const basic_format_args<Context> &args)
-{
-    if (map_)
-        return;
-    map_ = new entry[args.max_size()];
-    bool use_values = args.type(max_packed_args - 1) == internal::none_type;
-    if (use_values)
-    {
-        for (unsigned i = 0; /*nothing*/; ++i)
-        {
-            internal::type arg_type = args.type(i);
-            switch (arg_type)
-            {
-            case internal::none_type:
-                return;
-            case internal::named_arg_type:
-                push_back(args.values_[i]);
-                break;
-            default:
-                break; // Do nothing.
-            }
-        }
-        return;
-    }
-    for (unsigned i = 0;; ++i)
-    {
-        switch (args.args_[i].type_)
-        {
+template <typename Context>
+void arg_map<Context>::init(const basic_format_args<Context> &args) {
+  if (map_)
+    return;
+  map_ = new entry[args.max_size()];
+  bool use_values = args.type(max_packed_args - 1) == internal::none_type;
+  if (use_values) {
+    for (unsigned i = 0;/*nothing*/; ++i) {
+      internal::type arg_type = args.type(i);
+      switch (arg_type) {
         case internal::none_type:
-            return;
+          return;
         case internal::named_arg_type:
-            push_back(args.args_[i].value_);
-            break;
+          push_back(args.values_[i]);
+          break;
         default:
-            break; // Do nothing.
-        }
+          break; // Do nothing.
+      }
     }
+    return;
+  }
+  for (unsigned i = 0; ; ++i) {
+    switch (args.args_[i].type_) {
+      case internal::none_type:
+        return;
+      case internal::named_arg_type:
+        push_back(args.args_[i].value_);
+        break;
+      default:
+        break; // Do nothing.
+    }
+  }
 }
 
-template<typename Range>
-class arg_formatter_base
-{
-public:
-    typedef typename Range::value_type char_type;
-    typedef decltype(internal::declval<Range>().begin()) iterator;
-    typedef basic_format_specs<char_type> format_specs;
+template <typename Range>
+class arg_formatter_base {
+ public:
+  typedef typename Range::value_type char_type;
+  typedef decltype(internal::declval<Range>().begin()) iterator;
+  typedef basic_format_specs<char_type> format_specs;
 
-private:
-    typedef basic_writer<Range> writer_type;
-    writer_type writer_;
-    format_specs &specs_;
+ private:
+  typedef basic_writer<Range> writer_type;
+  writer_type writer_;
+  format_specs &specs_;
 
-    FMT_DISALLOW_COPY_AND_ASSIGN(arg_formatter_base);
+  FMT_DISALLOW_COPY_AND_ASSIGN(arg_formatter_base);
 
-    struct char_writer
-    {
-        char_type value;
-        template<typename It>
-        void operator()(It &&it) const
-        {
-            *it++ = value;
-        }
-    };
+  struct char_writer {
+    char_type value;
+    template <typename It>
+    void operator()(It &&it) const { *it++ = value; }
+  };
 
-    void write_char(char_type value)
-    {
-        writer_.write_padded(1, specs_, char_writer{value});
+  void write_char(char_type value) {
+    writer_.write_padded(1, specs_, char_writer{value});
+  }
+
+  void write_pointer(const void *p) {
+    format_specs specs = specs_;
+    specs.flags_ = HASH_FLAG;
+    specs.type_ = 'x';
+    writer_.write_int(reinterpret_cast<uintptr_t>(p), specs);
+  }
+
+ protected:
+  writer_type &writer() { return writer_; }
+  format_specs &spec() { return specs_; }
+  iterator out() { return writer_.out(); }
+
+  void write(bool value) {
+    writer_.write_str(string_view(value ? "true" : "false"), specs_);
+  }
+
+  void write(const char_type *value) {
+    if (!value)
+      FMT_THROW(format_error("string pointer is null"));
+    auto length = std::char_traits<char_type>::length(value);
+    writer_.write_str(basic_string_view<char_type>(value, length), specs_);
+  }
+
+ public:
+  arg_formatter_base(Range r, format_specs &s): writer_(r), specs_(s) {}
+
+  iterator operator()(monostate) {
+    FMT_ASSERT(false, "invalid argument type");
+    return out();
+  }
+
+  template <typename T>
+  typename std::enable_if<std::is_integral<T>::value, iterator>::type
+      operator()(T value) {
+    // MSVC2013 fails to compile separate overloads for bool and char_type so
+    // use std::is_same instead.
+    if (std::is_same<T, bool>::value) {
+      if (specs_.type_)
+        return (*this)(value ? 1 : 0);
+      write(value != 0);
+    } else if (std::is_same<T, char_type>::value) {
+      internal::handle_char_specs(
+        specs_, char_spec_handler(*this, static_cast<char_type>(value)));
+    } else {
+      writer_.write_int(value, specs_);
     }
+    return out();
+  }
 
-    void write_pointer(const void *p)
-    {
-        format_specs specs = specs_;
-        specs.flags_ = HASH_FLAG;
-        specs.type_ = 'x';
-        writer_.write_int(reinterpret_cast<uintptr_t>(p), specs);
-    }
+  template <typename T>
+  typename std::enable_if<std::is_floating_point<T>::value, iterator>::type
+      operator()(T value) {
+    writer_.write_double(value, specs_);
+    return out();
+  }
 
-protected:
-    writer_type &writer()
-    {
-        return writer_;
-    }
-    format_specs &spec()
-    {
-        return specs_;
-    }
-    iterator out()
-    {
-        return writer_.out();
-    }
+  struct char_spec_handler : internal::error_handler {
+    arg_formatter_base &formatter;
+    char_type value;
 
-    void write(bool value)
-    {
-        writer_.write_str(string_view(value ? "true" : "false"), specs_);
-    }
+    char_spec_handler(arg_formatter_base& f, char_type val)
+      : formatter(f), value(val) {}
 
-    void write(const char_type *value)
-    {
-        if (!value)
-            FMT_THROW(format_error("string pointer is null"));
-        auto length = std::char_traits<char_type>::length(value);
-        writer_.write_str(basic_string_view<char_type>(value, length), specs_);
-    }
+    void on_int() { formatter.writer_.write_int(value, formatter.specs_); }
+    void on_char() { formatter.write_char(value); }
+  };
 
-public:
-    arg_formatter_base(Range r, format_specs &s)
-        : writer_(r)
-        , specs_(s)
-    {
-    }
+  struct cstring_spec_handler : internal::error_handler {
+    arg_formatter_base &formatter;
+    const char_type *value;
 
-    iterator operator()(monostate)
-    {
-        FMT_ASSERT(false, "invalid argument type");
-        return out();
-    }
+    cstring_spec_handler(arg_formatter_base &f, const char_type *val)
+      : formatter(f), value(val) {}
 
-    template<typename T>
-    typename std::enable_if<std::is_integral<T>::value, iterator>::type operator()(T value)
-    {
-        writer_.write_int(value, specs_);
-        return out();
-    }
+    void on_string() { formatter.write(value); }
+    void on_pointer() { formatter.write_pointer(value); }
+  };
 
-    template<typename T>
-    typename std::enable_if<std::is_floating_point<T>::value, iterator>::type operator()(T value)
-    {
-        writer_.write_double(value, specs_);
-        return out();
-    }
+  iterator operator()(const char_type *value) {
+    internal::handle_cstring_type_spec(
+          specs_.type_, cstring_spec_handler(*this, value));
+    return out();
+  }
 
-    iterator operator()(bool value)
-    {
-        if (specs_.type_)
-            return (*this)(value ? 1 : 0);
-        write(value);
-        return out();
-    }
+  iterator operator()(basic_string_view<char_type> value) {
+    internal::check_string_type_spec(specs_.type_, internal::error_handler());
+    writer_.write_str(value, specs_);
+    return out();
+  }
 
-    struct char_spec_handler : internal::error_handler
-    {
-        arg_formatter_base &formatter;
-        char_type value;
-
-        char_spec_handler(arg_formatter_base &f, char_type val)
-            : formatter(f)
-            , value(val)
-        {
-        }
-
-        void on_int()
-        {
-            formatter.writer_.write_int(value, formatter.specs_);
-        }
-        void on_char()
-        {
-            formatter.write_char(value);
-        }
-    };
-
-    iterator operator()(char_type value)
-    {
-        internal::handle_char_specs(specs_, char_spec_handler(*this, value));
-        return out();
-    }
-
-    struct cstring_spec_handler : internal::error_handler
-    {
-        arg_formatter_base &formatter;
-        const char_type *value;
-
-        cstring_spec_handler(arg_formatter_base &f, const char_type *val)
-            : formatter(f)
-            , value(val)
-        {
-        }
-
-        void on_string()
-        {
-            formatter.write(value);
-        }
-        void on_pointer()
-        {
-            formatter.write_pointer(value);
-        }
-    };
-
-    iterator operator()(const char_type *value)
-    {
-        internal::handle_cstring_type_spec(specs_.type_, cstring_spec_handler(*this, value));
-        return out();
-    }
-
-    iterator operator()(basic_string_view<char_type> value)
-    {
-        internal::check_string_type_spec(specs_.type_, internal::error_handler());
-        writer_.write_str(value, specs_);
-        return out();
-    }
-
-    iterator operator()(const void *value)
-    {
-        check_pointer_type_spec(specs_.type_, internal::error_handler());
-        write_pointer(value);
-        return out();
-    }
+  iterator operator()(const void *value) {
+    check_pointer_type_spec(specs_.type_, internal::error_handler());
+    write_pointer(value);
+    return out();
+  }
 };
 
-template<typename S>
-struct is_format_string : std::integral_constant<bool, std::is_base_of<format_string, S>::value>
-{
-};
+template <typename S>
+struct is_format_string:
+  std::integral_constant<bool, std::is_base_of<format_string, S>::value> {};
 
-template<typename Char>
-FMT_CONSTEXPR bool is_name_start(Char c)
-{
-    return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c;
+template <typename Char>
+FMT_CONSTEXPR bool is_name_start(Char c) {
+  return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c;
 }
 
 // Parses the input as an unsigned integer. This function assumes that the
 // first character is a digit and presence of a non-digit character at the end.
 // it: an iterator pointing to the beginning of the input range.
-template<typename Iterator, typename ErrorHandler>
-FMT_CONSTEXPR unsigned parse_nonnegative_int(Iterator &it, ErrorHandler &&eh)
-{
-    assert('0' <= *it && *it <= '9');
-    unsigned value = 0;
-    // Convert to unsigned to prevent a warning.
-    unsigned max_int = (std::numeric_limits<int>::max)();
-    unsigned big = max_int / 10;
-    do
-    {
-        // Check for overflow.
-        if (value > big)
-        {
-            value = max_int + 1;
-            break;
-        }
-        value = value * 10 + (*it - '0');
-        // Workaround for MSVC "setup_exception stack overflow" error:
-        auto next = it;
-        ++next;
-        it = next;
-    } while ('0' <= *it && *it <= '9');
-    if (value > max_int)
-        eh.on_error("number is too big");
-    return value;
+template <typename Iterator, typename ErrorHandler>
+FMT_CONSTEXPR unsigned parse_nonnegative_int(Iterator &it, ErrorHandler &&eh) {
+  assert('0' <= *it && *it <= '9');
+  unsigned value = 0;
+  // Convert to unsigned to prevent a warning.
+  unsigned max_int = (std::numeric_limits<int>::max)();
+  unsigned big = max_int / 10;
+  do {
+    // Check for overflow.
+    if (value > big) {
+      value = max_int + 1;
+      break;
+    }
+    value = value * 10 + unsigned(*it - '0');
+    // Workaround for MSVC "setup_exception stack overflow" error:
+    auto next = it;
+    ++next;
+    it = next;
+  } while ('0' <= *it && *it <= '9');
+  if (value > max_int)
+    eh.on_error("number is too big");
+  return value;
 }
 
-template<typename Char, typename Context>
-class custom_formatter : public function<bool>
-{
-private:
-    Context &ctx_;
+template <typename Char, typename Context>
+class custom_formatter: public function<bool> {
+ private:
+  Context &ctx_;
 
-public:
-    explicit custom_formatter(Context &ctx)
-        : ctx_(ctx)
-    {
-    }
+ public:
+  explicit custom_formatter(Context &ctx): ctx_(ctx) {}
 
-    bool operator()(typename basic_format_arg<Context>::handle h) const
-    {
-        h.format(ctx_);
-        return true;
-    }
+  bool operator()(typename basic_format_arg<Context>::handle h) const {
+    h.format(ctx_);
+    return true;
+  }
 
-    template<typename T>
-    bool operator()(T) const
-    {
-        return false;
-    }
+  template <typename T>
+  bool operator()(T) const { return false; }
 };
 
-template<typename T>
-struct is_integer
-{
-    enum
-    {
-        value =
-            std::is_integral<T>::value && !std::is_same<T, bool>::value && !std::is_same<T, char>::value && !std::is_same<T, wchar_t>::value
-    };
+template <typename T>
+struct is_integer {
+  enum {
+    value = std::is_integral<T>::value && !std::is_same<T, bool>::value &&
+            !std::is_same<T, char>::value && !std::is_same<T, wchar_t>::value
+  };
 };
 
-template<typename ErrorHandler>
-class width_checker : public function<unsigned long long>
-{
-public:
-    explicit FMT_CONSTEXPR width_checker(ErrorHandler &eh)
-        : handler_(eh)
-    {
-    }
+template <typename ErrorHandler>
+class width_checker: public function<unsigned long long> {
+ public:
+  explicit FMT_CONSTEXPR width_checker(ErrorHandler &eh) : handler_(eh) {}
 
-    template<typename T>
-    FMT_CONSTEXPR typename std::enable_if<is_integer<T>::value, unsigned long long>::type operator()(T value)
-    {
-        if (is_negative(value))
-            handler_.on_error("negative width");
-        return value;
-    }
+  template <typename T>
+  FMT_CONSTEXPR
+  typename std::enable_if<
+      is_integer<T>::value, unsigned long long>::type operator()(T value) {
+    if (is_negative(value))
+      handler_.on_error("negative width");
+    return static_cast<unsigned long long>(value);
+  }
 
-    template<typename T>
-    FMT_CONSTEXPR typename std::enable_if<!is_integer<T>::value, unsigned long long>::type operator()(T)
-    {
-        handler_.on_error("width is not integer");
-        return 0;
-    }
+  template <typename T>
+  FMT_CONSTEXPR typename std::enable_if<
+      !is_integer<T>::value, unsigned long long>::type operator()(T) {
+    handler_.on_error("width is not integer");
+    return 0;
+  }
 
-private:
-    ErrorHandler &handler_;
+ private:
+  ErrorHandler &handler_;
 };
 
-template<typename ErrorHandler>
-class precision_checker : public function<unsigned long long>
-{
-public:
-    explicit FMT_CONSTEXPR precision_checker(ErrorHandler &eh)
-        : handler_(eh)
-    {
-    }
+template <typename ErrorHandler>
+class precision_checker: public function<unsigned long long> {
+ public:
+  explicit FMT_CONSTEXPR precision_checker(ErrorHandler &eh) : handler_(eh) {}
 
-    template<typename T>
-    FMT_CONSTEXPR typename std::enable_if<is_integer<T>::value, unsigned long long>::type operator()(T value)
-    {
-        if (is_negative(value))
-            handler_.on_error("negative precision");
-        return value;
-    }
+  template <typename T>
+  FMT_CONSTEXPR typename std::enable_if<
+      is_integer<T>::value, unsigned long long>::type operator()(T value) {
+    if (is_negative(value))
+      handler_.on_error("negative precision");
+    return static_cast<unsigned long long>(value);
+  }
 
-    template<typename T>
-    FMT_CONSTEXPR typename std::enable_if<!is_integer<T>::value, unsigned long long>::type operator()(T)
-    {
-        handler_.on_error("precision is not integer");
-        return 0;
-    }
+  template <typename T>
+  FMT_CONSTEXPR typename std::enable_if<
+      !is_integer<T>::value, unsigned long long>::type operator()(T) {
+    handler_.on_error("precision is not integer");
+    return 0;
+  }
 
-private:
-    ErrorHandler &handler_;
+ private:
+  ErrorHandler &handler_;
 };
 
 // A format specifier handler that sets fields in basic_format_specs.
-template<typename Char>
-class specs_setter
-{
-public:
-    explicit FMT_CONSTEXPR specs_setter(basic_format_specs<Char> &specs)
-        : specs_(specs)
-    {
-    }
+template <typename Char>
+class specs_setter {
+ public:
+  explicit FMT_CONSTEXPR specs_setter(basic_format_specs<Char> &specs):
+    specs_(specs) {}
 
-    FMT_CONSTEXPR specs_setter(const specs_setter &other)
-        : specs_(other.specs_)
-    {
-    }
+  FMT_CONSTEXPR specs_setter(const specs_setter &other) : specs_(other.specs_) {}
 
-    FMT_CONSTEXPR void on_align(alignment align)
-    {
-        specs_.align_ = align;
-    }
-    FMT_CONSTEXPR void on_fill(Char fill)
-    {
-        specs_.fill_ = fill;
-    }
-    FMT_CONSTEXPR void on_plus()
-    {
-        specs_.flags_ |= SIGN_FLAG | PLUS_FLAG;
-    }
-    FMT_CONSTEXPR void on_minus()
-    {
-        specs_.flags_ |= MINUS_FLAG;
-    }
-    FMT_CONSTEXPR void on_space()
-    {
-        specs_.flags_ |= SIGN_FLAG;
-    }
-    FMT_CONSTEXPR void on_hash()
-    {
-        specs_.flags_ |= HASH_FLAG;
-    }
+  FMT_CONSTEXPR void on_align(alignment align) { specs_.align_ = align; }
+  FMT_CONSTEXPR void on_fill(Char fill) { specs_.fill_ = fill; }
+  FMT_CONSTEXPR void on_plus() { specs_.flags_ |= SIGN_FLAG | PLUS_FLAG; }
+  FMT_CONSTEXPR void on_minus() { specs_.flags_ |= MINUS_FLAG; }
+  FMT_CONSTEXPR void on_space() { specs_.flags_ |= SIGN_FLAG; }
+  FMT_CONSTEXPR void on_hash() { specs_.flags_ |= HASH_FLAG; }
 
-    FMT_CONSTEXPR void on_zero()
-    {
-        specs_.align_ = ALIGN_NUMERIC;
-        specs_.fill_ = '0';
-    }
+  FMT_CONSTEXPR void on_zero() {
+    specs_.align_ = ALIGN_NUMERIC;
+    specs_.fill_ = '0';
+  }
 
-    FMT_CONSTEXPR void on_width(unsigned width)
-    {
-        specs_.width_ = width;
-    }
-    FMT_CONSTEXPR void on_precision(unsigned precision)
-    {
-        specs_.precision_ = precision;
-    }
-    FMT_CONSTEXPR void end_precision() {}
+  FMT_CONSTEXPR void on_width(unsigned width) { specs_.width_ = width; }
+  FMT_CONSTEXPR void on_precision(unsigned precision) {
+    specs_.precision_ = static_cast<int>(precision);
+  }
+  FMT_CONSTEXPR void end_precision() {}
 
-    FMT_CONSTEXPR void on_type(Char type)
-    {
-        specs_.type_ = type;
-    }
+  FMT_CONSTEXPR void on_type(Char type) { specs_.type_ = type; }
 
-protected:
-    basic_format_specs<Char> &specs_;
+ protected:
+  basic_format_specs<Char> &specs_;
 };
 
 // A format specifier handler that checks if specifiers are consistent with the
 // argument type.
-template<typename Handler>
-class specs_checker : public Handler
-{
-public:
-    FMT_CONSTEXPR specs_checker(const Handler &handler, internal::type arg_type)
-        : Handler(handler)
-        , arg_type_(arg_type)
-    {
-    }
+template <typename Handler>
+class specs_checker : public Handler {
+ public:
+  FMT_CONSTEXPR specs_checker(const Handler& handler, internal::type arg_type)
+    : Handler(handler), arg_type_(arg_type) {}
 
-    FMT_CONSTEXPR specs_checker(const specs_checker &other)
-        : Handler(other)
-        , arg_type_(other.arg_type_)
-    {
-    }
+  FMT_CONSTEXPR specs_checker(const specs_checker &other)
+    : Handler(other), arg_type_(other.arg_type_) {}
 
-    FMT_CONSTEXPR void on_align(alignment align)
-    {
-        if (align == ALIGN_NUMERIC)
-            require_numeric_argument();
-        Handler::on_align(align);
-    }
+  FMT_CONSTEXPR void on_align(alignment align) {
+    if (align == ALIGN_NUMERIC)
+      require_numeric_argument();
+    Handler::on_align(align);
+  }
 
-    FMT_CONSTEXPR void on_plus()
-    {
-        check_sign();
-        Handler::on_plus();
-    }
+  FMT_CONSTEXPR void on_plus() {
+    check_sign();
+    Handler::on_plus();
+  }
 
-    FMT_CONSTEXPR void on_minus()
-    {
-        check_sign();
-        Handler::on_minus();
-    }
+  FMT_CONSTEXPR void on_minus() {
+    check_sign();
+    Handler::on_minus();
+  }
 
-    FMT_CONSTEXPR void on_space()
-    {
-        check_sign();
-        Handler::on_space();
-    }
+  FMT_CONSTEXPR void on_space() {
+    check_sign();
+    Handler::on_space();
+  }
 
-    FMT_CONSTEXPR void on_hash()
-    {
-        require_numeric_argument();
-        Handler::on_hash();
-    }
+  FMT_CONSTEXPR void on_hash() {
+    require_numeric_argument();
+    Handler::on_hash();
+  }
 
-    FMT_CONSTEXPR void on_zero()
-    {
-        require_numeric_argument();
-        Handler::on_zero();
-    }
+  FMT_CONSTEXPR void on_zero() {
+    require_numeric_argument();
+    Handler::on_zero();
+  }
 
-    FMT_CONSTEXPR void end_precision()
-    {
-        if (is_integral(arg_type_) || arg_type_ == pointer_type)
-            this->on_error("precision not allowed for this argument type");
-    }
+  FMT_CONSTEXPR void end_precision() {
+    if (is_integral(arg_type_) || arg_type_ == pointer_type)
+      this->on_error("precision not allowed for this argument type");
+  }
 
-private:
-    FMT_CONSTEXPR void require_numeric_argument()
-    {
-        if (!is_arithmetic(arg_type_))
-            this->on_error("format specifier requires numeric argument");
-    }
+ private:
+  FMT_CONSTEXPR void require_numeric_argument() {
+    if (!is_arithmetic(arg_type_))
+      this->on_error("format specifier requires numeric argument");
+  }
 
-    FMT_CONSTEXPR void check_sign()
-    {
-        require_numeric_argument();
-        if (is_integral(arg_type_) && arg_type_ != int_type && arg_type_ != long_long_type && arg_type_ != internal::char_type)
-        {
-            this->on_error("format specifier requires signed argument");
-        }
+  FMT_CONSTEXPR void check_sign() {
+    require_numeric_argument();
+    if (is_integral(arg_type_) && arg_type_ != int_type &&
+        arg_type_ != long_long_type && arg_type_ != internal::char_type) {
+      this->on_error("format specifier requires signed argument");
     }
+  }
 
-    internal::type arg_type_;
+  internal::type arg_type_;
 };
 
-template<template<typename> class Handler, typename T, typename Context, typename ErrorHandler>
-FMT_CONSTEXPR void set_dynamic_spec(T &value, basic_format_arg<Context> arg, ErrorHandler eh)
-{
-    unsigned long long big_value = visit(Handler<ErrorHandler>(eh), arg);
-    if (big_value > (std::numeric_limits<int>::max)())
-        eh.on_error("number is too big");
-    value = static_cast<int>(big_value);
+template <template <typename> class Handler, typename T,
+          typename Context, typename ErrorHandler>
+FMT_CONSTEXPR void set_dynamic_spec(
+    T &value, basic_format_arg<Context> arg, ErrorHandler eh) {
+  unsigned long long big_value = visit(Handler<ErrorHandler>(eh), arg);
+  if (big_value > (std::numeric_limits<int>::max)())
+    eh.on_error("number is too big");
+  value = static_cast<T>(big_value);
 }
 
-struct auto_id
-{
-};
+struct auto_id {};
 
 // The standard format specifier handler with checking.
-template<typename Context>
-class specs_handler : public specs_setter<typename Context::char_type>
-{
-public:
-    typedef typename Context::char_type char_type;
+template <typename Context>
+class specs_handler: public specs_setter<typename Context::char_type> {
+ public:
+  typedef typename Context::char_type char_type;
 
-    FMT_CONSTEXPR specs_handler(basic_format_specs<char_type> &specs, Context &ctx)
-        : specs_setter<char_type>(specs)
-        , context_(ctx)
-    {
-    }
+  FMT_CONSTEXPR specs_handler(basic_format_specs<char_type> &specs, Context &ctx)
+    : specs_setter<char_type>(specs), context_(ctx) {}
 
-    template<typename Id>
-    FMT_CONSTEXPR void on_dynamic_width(Id arg_id)
-    {
-        set_dynamic_spec<width_checker>(this->specs_.width_, get_arg(arg_id), context_.error_handler());
-    }
+  template <typename Id>
+  FMT_CONSTEXPR void on_dynamic_width(Id arg_id) {
+    set_dynamic_spec<width_checker>(
+          this->specs_.width_, get_arg(arg_id), context_.error_handler());
+  }
 
-    template<typename Id>
-    FMT_CONSTEXPR void on_dynamic_precision(Id arg_id)
-    {
-        set_dynamic_spec<precision_checker>(this->specs_.precision_, get_arg(arg_id), context_.error_handler());
-    }
+  template <typename Id>
+  FMT_CONSTEXPR void on_dynamic_precision(Id arg_id) {
+    set_dynamic_spec<precision_checker>(
+          this->specs_.precision_, get_arg(arg_id), context_.error_handler());
+  }
 
-    void on_error(const char *message)
-    {
-        context_.on_error(message);
-    }
+  void on_error(const char *message) {
+    context_.on_error(message);
+  }
 
-private:
-    FMT_CONSTEXPR basic_format_arg<Context> get_arg(auto_id)
-    {
-        return context_.next_arg();
-    }
+ private:
+  FMT_CONSTEXPR basic_format_arg<Context> get_arg(auto_id) {
+    return context_.next_arg();
+  }
 
-    template<typename Id>
-    FMT_CONSTEXPR basic_format_arg<Context> get_arg(Id arg_id)
-    {
-        context_.parse_context().check_arg_id(arg_id);
-        return context_.get_arg(arg_id);
-    }
+  template <typename Id>
+  FMT_CONSTEXPR basic_format_arg<Context> get_arg(Id arg_id) {
+    context_.parse_context().check_arg_id(arg_id);
+    return context_.get_arg(arg_id);
+  }
 
-    Context &context_;
+  Context &context_;
 };
 
 // An argument reference.
-template<typename Char>
-struct arg_ref
-{
-    enum Kind
-    {
-        NONE,
-        INDEX,
-        NAME
-    };
+template <typename Char>
+struct arg_ref {
+  enum Kind { NONE, INDEX, NAME };
 
-    FMT_CONSTEXPR arg_ref()
-        : kind(NONE)
-        , index(0)
-    {
-    }
-    FMT_CONSTEXPR explicit arg_ref(unsigned index)
-        : kind(INDEX)
-        , index(index)
-    {
-    }
-    explicit arg_ref(basic_string_view<Char> name)
-        : kind(NAME)
-        , name(name)
-    {
-    }
+  FMT_CONSTEXPR arg_ref() : kind(NONE), index(0) {}
+  FMT_CONSTEXPR explicit arg_ref(unsigned index) : kind(INDEX), index(index) {}
+  explicit arg_ref(basic_string_view<Char> name) : kind(NAME), name(name) {}
 
-    FMT_CONSTEXPR arg_ref &operator=(unsigned idx)
-    {
-        kind = INDEX;
-        index = idx;
-        return *this;
-    }
+  FMT_CONSTEXPR arg_ref &operator=(unsigned idx) {
+    kind = INDEX;
+    index = idx;
+    return *this;
+  }
 
-    Kind kind;
-    FMT_UNION
-    {
-        unsigned index;
-        basic_string_view<Char> name;
-    };
+  Kind kind;
+  FMT_UNION {
+    unsigned index;
+    basic_string_view<Char> name;
+  };
 };
 
 // Format specifiers with width and precision resolved at formatting rather
 // than parsing time to allow re-using the same parsed specifiers with
 // differents sets of arguments (precompilation of format strings).
-template<typename Char>
-struct dynamic_format_specs : basic_format_specs<Char>
-{
-    arg_ref<Char> width_ref;
-    arg_ref<Char> precision_ref;
+template <typename Char>
+struct dynamic_format_specs : basic_format_specs<Char> {
+  arg_ref<Char> width_ref;
+  arg_ref<Char> precision_ref;
 };
 
 // Format spec handler that saves references to arguments representing dynamic
 // width and precision to be resolved at formatting time.
-template<typename ParseContext>
-class dynamic_specs_handler : public specs_setter<typename ParseContext::char_type>
-{
-public:
-    typedef typename ParseContext::char_type char_type;
+template <typename ParseContext>
+class dynamic_specs_handler :
+    public specs_setter<typename ParseContext::char_type> {
+ public:
+  typedef typename ParseContext::char_type char_type;
 
-    FMT_CONSTEXPR dynamic_specs_handler(dynamic_format_specs<char_type> &specs, ParseContext &ctx)
-        : specs_setter<char_type>(specs)
-        , specs_(specs)
-        , context_(ctx)
-    {
-    }
+  FMT_CONSTEXPR dynamic_specs_handler(
+      dynamic_format_specs<char_type> &specs, ParseContext &ctx)
+    : specs_setter<char_type>(specs), specs_(specs), context_(ctx) {}
 
-    FMT_CONSTEXPR dynamic_specs_handler(const dynamic_specs_handler &other)
-        : specs_setter<char_type>(other)
-        , specs_(other.specs_)
-        , context_(other.context_)
-    {
-    }
+  FMT_CONSTEXPR dynamic_specs_handler(const dynamic_specs_handler &other)
+    : specs_setter<char_type>(other),
+      specs_(other.specs_), context_(other.context_) {}
 
-    template<typename Id>
-    FMT_CONSTEXPR void on_dynamic_width(Id arg_id)
-    {
-        specs_.width_ref = make_arg_ref(arg_id);
-    }
+  template <typename Id>
+  FMT_CONSTEXPR void on_dynamic_width(Id arg_id) {
+    specs_.width_ref = make_arg_ref(arg_id);
+  }
 
-    template<typename Id>
-    FMT_CONSTEXPR void on_dynamic_precision(Id arg_id)
-    {
-        specs_.precision_ref = make_arg_ref(arg_id);
-    }
+  template <typename Id>
+  FMT_CONSTEXPR void on_dynamic_precision(Id arg_id) {
+    specs_.precision_ref = make_arg_ref(arg_id);
+  }
 
-    FMT_CONSTEXPR void on_error(const char *message)
-    {
-        context_.on_error(message);
-    }
+  FMT_CONSTEXPR void on_error(const char *message) {
+    context_.on_error(message);
+  }
 
-private:
-    typedef arg_ref<char_type> arg_ref_type;
+ private:
+  typedef arg_ref<char_type> arg_ref_type;
 
-    template<typename Id>
-    FMT_CONSTEXPR arg_ref_type make_arg_ref(Id arg_id)
-    {
-        context_.check_arg_id(arg_id);
-        return arg_ref_type(arg_id);
-    }
+  template <typename Id>
+  FMT_CONSTEXPR arg_ref_type make_arg_ref(Id arg_id) {
+    context_.check_arg_id(arg_id);
+    return arg_ref_type(arg_id);
+  }
 
-    FMT_CONSTEXPR arg_ref_type make_arg_ref(auto_id)
-    {
-        return arg_ref_type(context_.next_arg_id());
-    }
+  FMT_CONSTEXPR arg_ref_type make_arg_ref(auto_id) {
+    return arg_ref_type(context_.next_arg_id());
+  }
 
-    dynamic_format_specs<char_type> &specs_;
-    ParseContext &context_;
+  dynamic_format_specs<char_type> &specs_;
+  ParseContext &context_;
 };
 
-template<typename Iterator, typename IDHandler>
-FMT_CONSTEXPR Iterator parse_arg_id(Iterator it, IDHandler &&handler)
-{
-    typedef typename std::iterator_traits<Iterator>::value_type char_type;
-    char_type c = *it;
-    if (c == '}' || c == ':')
-    {
-        handler();
-        return it;
-    }
-    if (c >= '0' && c <= '9')
-    {
-        unsigned index = parse_nonnegative_int(it, handler);
-        if (*it != '}' && *it != ':')
-        {
-            handler.on_error("invalid format string");
-            return it;
-        }
-        handler(index);
-        return it;
-    }
-    if (!is_name_start(c))
-    {
-        handler.on_error("invalid format string");
-        return it;
-    }
-    auto start = it;
-    do
-    {
-        c = *++it;
-    } while (is_name_start(c) || ('0' <= c && c <= '9'));
-    handler(basic_string_view<char_type>(pointer_from(start), it - start));
+template <typename Iterator, typename IDHandler>
+FMT_CONSTEXPR Iterator parse_arg_id(Iterator it, IDHandler &&handler) {
+  typedef typename std::iterator_traits<Iterator>::value_type char_type;
+  char_type c = *it;
+  if (c == '}' || c == ':') {
+    handler();
     return it;
+  }
+  if (c >= '0' && c <= '9') {
+    unsigned index = parse_nonnegative_int(it, handler);
+    if (*it != '}' && *it != ':') {
+      handler.on_error("invalid format string");
+      return it;
+    }
+    handler(index);
+    return it;
+  }
+  if (!is_name_start(c)) {
+    handler.on_error("invalid format string");
+    return it;
+  }
+  auto start = it;
+  do {
+    c = *++it;
+  } while (is_name_start(c) || ('0' <= c && c <= '9'));
+  handler(basic_string_view<char_type>(pointer_from(start), to_unsigned(it - start)));
+  return it;
 }
 
 // Adapts SpecHandler to IDHandler API for dynamic width.
-template<typename SpecHandler, typename Char>
-struct width_adapter
-{
-    explicit FMT_CONSTEXPR width_adapter(SpecHandler &h)
-        : handler(h)
-    {
-    }
+template <typename SpecHandler, typename Char>
+struct width_adapter {
+  explicit FMT_CONSTEXPR width_adapter(SpecHandler &h) : handler(h) {}
 
-    FMT_CONSTEXPR void operator()()
-    {
-        handler.on_dynamic_width(auto_id());
-    }
-    FMT_CONSTEXPR void operator()(unsigned id)
-    {
-        handler.on_dynamic_width(id);
-    }
-    FMT_CONSTEXPR void operator()(basic_string_view<Char> id)
-    {
-        handler.on_dynamic_width(id);
-    }
+  FMT_CONSTEXPR void operator()() { handler.on_dynamic_width(auto_id()); }
+  FMT_CONSTEXPR void operator()(unsigned id) { handler.on_dynamic_width(id); }
+  FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
+    handler.on_dynamic_width(id);
+  }
 
-    FMT_CONSTEXPR void on_error(const char *message)
-    {
-        handler.on_error(message);
-    }
+  FMT_CONSTEXPR void on_error(const char *message) {
+    handler.on_error(message);
+  }
 
-    SpecHandler &handler;
+  SpecHandler &handler;
 };
 
 // Adapts SpecHandler to IDHandler API for dynamic precision.
-template<typename SpecHandler, typename Char>
-struct precision_adapter
-{
-    explicit FMT_CONSTEXPR precision_adapter(SpecHandler &h)
-        : handler(h)
-    {
-    }
+template <typename SpecHandler, typename Char>
+struct precision_adapter {
+  explicit FMT_CONSTEXPR precision_adapter(SpecHandler &h) : handler(h) {}
 
-    FMT_CONSTEXPR void operator()()
-    {
-        handler.on_dynamic_precision(auto_id());
-    }
-    FMT_CONSTEXPR void operator()(unsigned id)
-    {
-        handler.on_dynamic_precision(id);
-    }
-    FMT_CONSTEXPR void operator()(basic_string_view<Char> id)
-    {
-        handler.on_dynamic_precision(id);
-    }
+  FMT_CONSTEXPR void operator()() { handler.on_dynamic_precision(auto_id()); }
+  FMT_CONSTEXPR void operator()(unsigned id) {
+    handler.on_dynamic_precision(id);
+  }
+  FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
+    handler.on_dynamic_precision(id);
+  }
 
-    FMT_CONSTEXPR void on_error(const char *message)
-    {
-        handler.on_error(message);
-    }
+  FMT_CONSTEXPR void on_error(const char *message) { handler.on_error(message); }
 
-    SpecHandler &handler;
+  SpecHandler &handler;
 };
 
 // Parses standard format specifiers and sends notifications about parsed
@@ -2563,411 +2018,344 @@ struct precision_adapter
 // it: an iterator pointing to the beginning of a null-terminated range of
 //     characters, possibly emulated via null_terminating_iterator, representing
 //     format specifiers.
-template<typename Iterator, typename SpecHandler>
-FMT_CONSTEXPR Iterator parse_format_specs(Iterator it, SpecHandler &&handler)
-{
-    typedef typename std::iterator_traits<Iterator>::value_type char_type;
-    char_type c = *it;
-    if (c == '}' || !c)
-        return it;
-
-    // Parse fill and alignment.
-    alignment align = ALIGN_DEFAULT;
-    int i = 1;
-    do
-    {
-        auto p = it + i;
-        switch (*p)
-        {
-        case '<':
-            align = ALIGN_LEFT;
-            break;
-        case '>':
-            align = ALIGN_RIGHT;
-            break;
-        case '=':
-            align = ALIGN_NUMERIC;
-            break;
-        case '^':
-            align = ALIGN_CENTER;
-            break;
-        }
-        if (align != ALIGN_DEFAULT)
-        {
-            if (p != it)
-            {
-                if (c == '{')
-                {
-                    handler.on_error("invalid fill character '{'");
-                    return it;
-                }
-                it += 2;
-                handler.on_fill(c);
-            }
-            else
-                ++it;
-            handler.on_align(align);
-            break;
-        }
-    } while (--i >= 0);
-
-    // Parse sign.
-    switch (*it)
-    {
-    case '+':
-        handler.on_plus();
-        ++it;
-        break;
-    case '-':
-        handler.on_minus();
-        ++it;
-        break;
-    case ' ':
-        handler.on_space();
-        ++it;
-        break;
-    }
-
-    if (*it == '#')
-    {
-        handler.on_hash();
-        ++it;
-    }
-
-    // Parse zero flag.
-    if (*it == '0')
-    {
-        handler.on_zero();
-        ++it;
-    }
-
-    // Parse width.
-    if ('0' <= *it && *it <= '9')
-    {
-        handler.on_width(parse_nonnegative_int(it, handler));
-    }
-    else if (*it == '{')
-    {
-        it = parse_arg_id(it + 1, width_adapter<SpecHandler, char_type>(handler));
-        if (*it++ != '}')
-        {
-            handler.on_error("invalid format string");
-            return it;
-        }
-    }
-
-    // Parse precision.
-    if (*it == '.')
-    {
-        ++it;
-        if ('0' <= *it && *it <= '9')
-        {
-            handler.on_precision(parse_nonnegative_int(it, handler));
-        }
-        else if (*it == '{')
-        {
-            it = parse_arg_id(it + 1, precision_adapter<SpecHandler, char_type>(handler));
-            if (*it++ != '}')
-            {
-                handler.on_error("invalid format string");
-                return it;
-            }
-        }
-        else
-        {
-            handler.on_error("missing precision specifier");
-            return it;
-        }
-        handler.end_precision();
-    }
-
-    // Parse type.
-    if (*it != '}' && *it)
-        handler.on_type(*it++);
+template <typename Iterator, typename SpecHandler>
+FMT_CONSTEXPR Iterator parse_format_specs(Iterator it, SpecHandler &&handler) {
+  typedef typename std::iterator_traits<Iterator>::value_type char_type;
+  char_type c = *it;
+  if (c == '}' || !c)
     return it;
+
+  // Parse fill and alignment.
+  alignment align = ALIGN_DEFAULT;
+  int i = 1;
+  do {
+    auto p = it + i;
+    switch (*p) {
+      case '<':
+        align = ALIGN_LEFT;
+        break;
+      case '>':
+        align = ALIGN_RIGHT;
+        break;
+      case '=':
+        align = ALIGN_NUMERIC;
+        break;
+      case '^':
+        align = ALIGN_CENTER;
+        break;
+    }
+    if (align != ALIGN_DEFAULT) {
+      if (p != it) {
+        if (c == '{') {
+          handler.on_error("invalid fill character '{'");
+          return it;
+        }
+        it += 2;
+        handler.on_fill(c);
+      } else ++it;
+      handler.on_align(align);
+      break;
+    }
+  } while (--i >= 0);
+
+  // Parse sign.
+  switch (*it) {
+    case '+':
+      handler.on_plus();
+      ++it;
+      break;
+    case '-':
+      handler.on_minus();
+      ++it;
+      break;
+    case ' ':
+      handler.on_space();
+      ++it;
+      break;
+  }
+
+  if (*it == '#') {
+    handler.on_hash();
+    ++it;
+  }
+
+  // Parse zero flag.
+  if (*it == '0') {
+    handler.on_zero();
+    ++it;
+  }
+
+  // Parse width.
+  if ('0' <= *it && *it <= '9') {
+    handler.on_width(parse_nonnegative_int(it, handler));
+  } else if (*it == '{') {
+    it = parse_arg_id(it + 1, width_adapter<SpecHandler, char_type>(handler));
+    if (*it++ != '}') {
+      handler.on_error("invalid format string");
+      return it;
+    }
+  }
+
+  // Parse precision.
+  if (*it == '.') {
+    ++it;
+    if ('0' <= *it && *it <= '9') {
+      handler.on_precision(parse_nonnegative_int(it, handler));
+    } else if (*it == '{') {
+      it = parse_arg_id(
+            it + 1, precision_adapter<SpecHandler, char_type>(handler));
+      if (*it++ != '}') {
+        handler.on_error("invalid format string");
+        return it;
+      }
+    } else {
+      handler.on_error("missing precision specifier");
+      return it;
+    }
+    handler.end_precision();
+  }
+
+  // Parse type.
+  if (*it != '}' && *it)
+    handler.on_type(*it++);
+  return it;
 }
 
-template<typename Handler, typename Char>
-struct id_adapter
-{
-    FMT_CONSTEXPR explicit id_adapter(Handler &h)
-        : handler(h)
-    {
-    }
+template <typename Handler, typename Char>
+struct id_adapter {
+  FMT_CONSTEXPR explicit id_adapter(Handler &h): handler(h) {}
 
-    FMT_CONSTEXPR void operator()()
-    {
-        handler.on_arg_id();
-    }
-    FMT_CONSTEXPR void operator()(unsigned id)
-    {
-        handler.on_arg_id(id);
-    }
-    FMT_CONSTEXPR void operator()(basic_string_view<Char> id)
-    {
-        handler.on_arg_id(id);
-    }
+  FMT_CONSTEXPR void operator()() { handler.on_arg_id(); }
+  FMT_CONSTEXPR void operator()(unsigned id) { handler.on_arg_id(id); }
+  FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
+    handler.on_arg_id(id);
+  }
 
-    FMT_CONSTEXPR void on_error(const char *message)
-    {
-        handler.on_error(message);
-    }
+  FMT_CONSTEXPR void on_error(const char *message) {
+    handler.on_error(message);
+  }
 
-    Handler &handler;
+  Handler &handler;
 };
 
-template<typename Iterator, typename Handler>
-FMT_CONSTEXPR void parse_format_string(Iterator it, Handler &&handler)
-{
-    typedef typename std::iterator_traits<Iterator>::value_type char_type;
-    auto start = it;
-    while (*it)
-    {
-        char_type ch = *it++;
-        if (ch != '{' && ch != '}')
-            continue;
-        if (*it == ch)
-        {
-            handler.on_text(start, it);
-            start = ++it;
-            continue;
-        }
-        if (ch == '}')
-        {
-            handler.on_error("unmatched '}' in format string");
-            return;
-        }
-        handler.on_text(start, it - 1);
-
-        it = parse_arg_id(it, id_adapter<Handler, char_type>(handler));
-        if (*it == '}')
-        {
-            handler.on_replacement_field(it);
-        }
-        else if (*it == ':')
-        {
-            ++it;
-            it = handler.on_format_specs(it);
-            if (*it != '}')
-            {
-                handler.on_error("unknown format specifier");
-                return;
-            }
-        }
-        else
-        {
-            handler.on_error("missing '}' in format string");
-            return;
-        }
-
-        start = ++it;
+template <typename Iterator, typename Handler>
+FMT_CONSTEXPR void parse_format_string(Iterator it, Handler &&handler) {
+  typedef typename std::iterator_traits<Iterator>::value_type char_type;
+  auto start = it;
+  while (*it) {
+    char_type ch = *it++;
+    if (ch != '{' && ch != '}') continue;
+    if (*it == ch) {
+      handler.on_text(start, it);
+      start = ++it;
+      continue;
     }
-    handler.on_text(start, it);
+    if (ch == '}') {
+      handler.on_error("unmatched '}' in format string");
+      return;
+    }
+    handler.on_text(start, it - 1);
+
+    it = parse_arg_id(it, id_adapter<Handler, char_type>(handler));
+    if (*it == '}') {
+      handler.on_replacement_field(it);
+    } else if (*it == ':') {
+      ++it;
+      it = handler.on_format_specs(it);
+      if (*it != '}') {
+        handler.on_error("unknown format specifier");
+        return;
+      }
+    } else {
+      handler.on_error("missing '}' in format string");
+      return;
+    }
+
+    start = ++it;
+  }
+  handler.on_text(start, it);
 }
 
-template<typename T, typename ParseContext>
-FMT_CONSTEXPR const typename ParseContext::char_type *parse_format_specs(ParseContext &ctx)
-{
-    // GCC 7.2 requires initializer.
-    formatter<T, typename ParseContext::char_type> f{};
-    return f.parse(ctx);
+template <typename T, typename ParseContext>
+FMT_CONSTEXPR const typename ParseContext::char_type *
+    parse_format_specs(ParseContext &ctx) {
+  // GCC 7.2 requires initializer.
+  formatter<T, typename ParseContext::char_type> f{};
+  return f.parse(ctx);
 }
 
-template<typename Char, typename ErrorHandler, typename... Args>
-class format_string_checker
-{
-public:
-    explicit FMT_CONSTEXPR format_string_checker(basic_string_view<Char> format_str, ErrorHandler eh)
-        : arg_id_(-1)
-        , context_(format_str, eh)
-        , parse_funcs_{&parse_format_specs<Args, parse_context_type>...}
-    {
-    }
+template <typename Char, typename ErrorHandler, typename... Args>
+class format_string_checker {
+ public:
+  explicit FMT_CONSTEXPR format_string_checker(
+      basic_string_view<Char> format_str, ErrorHandler eh)
+    : arg_id_(-1), context_(format_str, eh),
+      parse_funcs_{&parse_format_specs<Args, parse_context_type>...} {}
 
-    FMT_CONSTEXPR void on_text(const Char *, const Char *) {}
+  FMT_CONSTEXPR void on_text(const Char *, const Char *) {}
 
-    FMT_CONSTEXPR void on_arg_id()
-    {
-        arg_id_ = context_.next_arg_id();
-        check_arg_id();
-    }
-    FMT_CONSTEXPR void on_arg_id(unsigned id)
-    {
-        arg_id_ = id;
-        context_.check_arg_id(id);
-        check_arg_id();
-    }
-    FMT_CONSTEXPR void on_arg_id(basic_string_view<Char>) {}
+  FMT_CONSTEXPR void on_arg_id() {
+    arg_id_ = context_.next_arg_id();
+    check_arg_id();
+  }
+  FMT_CONSTEXPR void on_arg_id(unsigned id) {
+    arg_id_ = id;
+    context_.check_arg_id(id);
+    check_arg_id();
+  }
+  FMT_CONSTEXPR void on_arg_id(basic_string_view<Char>) {}
 
-    FMT_CONSTEXPR void on_replacement_field(const Char *) {}
+  FMT_CONSTEXPR void on_replacement_field(const Char *) {}
 
-    FMT_CONSTEXPR const Char *on_format_specs(const Char *s)
-    {
-        context_.advance_to(s);
-        return to_unsigned(arg_id_) < NUM_ARGS ? parse_funcs_[arg_id_](context_) : s;
-    }
+  FMT_CONSTEXPR const Char *on_format_specs(const Char *s) {
+    context_.advance_to(s);
+    return to_unsigned(arg_id_) < NUM_ARGS ?
+          parse_funcs_[arg_id_](context_) : s;
+  }
 
-    FMT_CONSTEXPR void on_error(const char *message)
-    {
-        context_.on_error(message);
-    }
+  FMT_CONSTEXPR void on_error(const char *message) {
+    context_.on_error(message);
+  }
 
-private:
-    typedef basic_parse_context<Char, ErrorHandler> parse_context_type;
-    enum
-    {
-        NUM_ARGS = sizeof...(Args)
-    };
+ private:
+  typedef basic_parse_context<Char, ErrorHandler> parse_context_type;
+  enum { NUM_ARGS = sizeof...(Args) };
 
-    FMT_CONSTEXPR void check_arg_id()
-    {
-        if (internal::to_unsigned(arg_id_) >= NUM_ARGS)
-            context_.on_error("argument index out of range");
-    }
+  FMT_CONSTEXPR void check_arg_id() {
+    if (internal::to_unsigned(arg_id_) >= NUM_ARGS)
+      context_.on_error("argument index out of range");
+  }
 
-    // Format specifier parsing function.
-    typedef const Char *(*parse_func)(parse_context_type &);
+  // Format specifier parsing function.
+  typedef const Char *(*parse_func)(parse_context_type &);
 
-    int arg_id_;
-    parse_context_type context_;
-    parse_func parse_funcs_[NUM_ARGS > 0 ? NUM_ARGS : 1];
+  int arg_id_;
+  parse_context_type context_;
+  parse_func parse_funcs_[NUM_ARGS > 0 ? NUM_ARGS : 1];
 };
 
-template<typename Char, typename ErrorHandler, typename... Args>
-FMT_CONSTEXPR bool check_format_string(basic_string_view<Char> s, ErrorHandler eh = ErrorHandler())
-{
-    format_string_checker<Char, ErrorHandler, Args...> checker(s, eh);
-    parse_format_string(s.begin(), checker);
-    return true;
+template <typename Char, typename ErrorHandler, typename... Args>
+FMT_CONSTEXPR bool check_format_string(
+    basic_string_view<Char> s, ErrorHandler eh = ErrorHandler()) {
+  format_string_checker<Char, ErrorHandler, Args...> checker(s, eh);
+  parse_format_string(s.begin(), checker);
+  return true;
 }
 
-template<typename... Args, typename String>
-void check_format_string(String format_str)
-{
-    FMT_CONSTEXPR_DECL bool invalid_format =
-        internal::check_format_string<char, internal::error_handler, Args...>(string_view(format_str.data(), format_str.size()));
-    (void)invalid_format;
+template <typename... Args, typename String>
+void check_format_string(String format_str) {
+  FMT_CONSTEXPR_DECL bool invalid_format =
+      internal::check_format_string<char, internal::error_handler, Args...>(
+        string_view(format_str.data(), format_str.size()));
+  (void)invalid_format;
 }
 
 // Specifies whether to format T using the standard formatter.
 // It is not possible to use get_type in formatter specialization directly
 // because of a bug in MSVC.
-template<typename Context, typename T>
-struct format_type : std::integral_constant<bool, get_type<Context, T>::value != custom_type>
-{
-};
+template <typename Context, typename T>
+struct format_type :
+  std::integral_constant<bool, get_type<Context, T>::value != custom_type> {};
 
 // Specifies whether to format enums.
-template<typename T, typename Enable = void>
-struct format_enum : std::integral_constant<bool, std::is_enum<T>::value>
-{
-};
+template <typename T, typename Enable = void>
+struct format_enum : std::integral_constant<bool, std::is_enum<T>::value> {};
 
-template<template<typename> class Handler, typename Spec, typename Context>
-void handle_dynamic_spec(Spec &value, arg_ref<typename Context::char_type> ref, Context &ctx)
-{
-    typedef typename Context::char_type char_type;
-    switch (ref.kind)
-    {
-    case arg_ref<char_type>::NONE:
-        break;
-    case arg_ref<char_type>::INDEX:
-        internal::set_dynamic_spec<Handler>(value, ctx.get_arg(ref.index), ctx.error_handler());
-        break;
-    case arg_ref<char_type>::NAME:
-        internal::set_dynamic_spec<Handler>(value, ctx.get_arg(ref.name), ctx.error_handler());
-        break;
-    }
+template <template <typename> class Handler, typename Spec, typename Context>
+void handle_dynamic_spec(
+    Spec &value, arg_ref<typename Context::char_type> ref, Context &ctx) {
+  typedef typename Context::char_type char_type;
+  switch (ref.kind) {
+  case arg_ref<char_type>::NONE:
+    break;
+  case arg_ref<char_type>::INDEX:
+    internal::set_dynamic_spec<Handler>(
+          value, ctx.get_arg(ref.index), ctx.error_handler());
+    break;
+  case arg_ref<char_type>::NAME:
+    internal::set_dynamic_spec<Handler>(
+          value, ctx.get_arg(ref.name), ctx.error_handler());
+    break;
+  }
 }
-} // namespace internal
+}  // namespace internal
 
 /** The default argument formatter. */
-template<typename Range>
-class arg_formatter : public internal::function<typename internal::arg_formatter_base<Range>::iterator>,
-                      public internal::arg_formatter_base<Range>
-{
-private:
-    typedef typename Range::value_type char_type;
-    typedef internal::arg_formatter_base<Range> base;
-    typedef basic_format_context<typename base::iterator, char_type> context_type;
+template <typename Range>
+class arg_formatter:
+  public internal::function<
+    typename internal::arg_formatter_base<Range>::iterator>,
+  public internal::arg_formatter_base<Range> {
+ private:
+  typedef typename Range::value_type char_type;
+  typedef internal::arg_formatter_base<Range> base;
+  typedef basic_format_context<typename base::iterator, char_type> context_type;
 
-    context_type &ctx_;
+  context_type &ctx_;
 
-public:
-    typedef Range range;
-    typedef typename base::iterator iterator;
-    typedef typename base::format_specs format_specs;
+ public:
+  typedef Range range;
+  typedef typename base::iterator iterator;
+  typedef typename base::format_specs format_specs;
 
-    /**
-      \rst
-      Constructs an argument formatter object.
-      *ctx* is a reference to the formatting context,
-      *spec* contains format specifier information for standard argument types.
-      \endrst
-     */
-    arg_formatter(context_type &ctx, format_specs &spec)
-        : base(Range(ctx.out()), spec)
-        , ctx_(ctx)
-    {
-    }
+  /**
+    \rst
+    Constructs an argument formatter object.
+    *ctx* is a reference to the formatting context,
+    *spec* contains format specifier information for standard argument types.
+    \endrst
+   */
+  arg_formatter(context_type &ctx, format_specs &spec)
+  : base(Range(ctx.out()), spec), ctx_(ctx) {}
 
-    using base::operator();
+  using base::operator();
 
-    /** Formats an argument of a user-defined type. */
-    iterator operator()(typename basic_format_arg<context_type>::handle handle)
-    {
-        handle.format(ctx_);
-        return this->out();
-    }
+  /** Formats an argument of a user-defined type. */
+  iterator operator()(typename basic_format_arg<context_type>::handle handle) {
+    handle.format(ctx_);
+    return this->out();
+  }
 };
 
 /**
  An error returned by an operating system or a language runtime,
  for example a file opening error.
 */
-class system_error : public std::runtime_error
-{
-private:
-    FMT_API void init(int err_code, string_view format_str, format_args args);
+class system_error : public std::runtime_error {
+ private:
+  FMT_API void init(int err_code, string_view format_str, format_args args);
 
-protected:
-    int error_code_;
+ protected:
+  int error_code_;
 
-    system_error()
-        : std::runtime_error("")
-    {
-    }
+  system_error() : std::runtime_error("") {}
 
-public:
-    /**
-     \rst
-     Constructs a :class:`fmt::system_error` object with a description
-     formatted with `fmt::format_system_error`. *message* and additional
-     arguments passed into the constructor are formatted similarly to
-     `fmt::format`.
+ public:
+  /**
+   \rst
+   Constructs a :class:`fmt::system_error` object with a description
+   formatted with `fmt::format_system_error`. *message* and additional
+   arguments passed into the constructor are formatted similarly to
+   `fmt::format`.
 
-     **Example**::
+   **Example**::
 
-       // This throws a system_error 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::system_error(errno, "cannot open file '{}'", filename);
-     \endrst
-    */
-    template<typename... Args>
-    system_error(int error_code, string_view message, const Args &... args)
-        : std::runtime_error("")
-    {
-        init(error_code, message, make_format_args(args...));
-    }
+     // This throws a system_error 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::system_error(errno, "cannot open file '{}'", filename);
+   \endrst
+  */
+  template <typename... Args>
+  system_error(int error_code, string_view message, const Args & ... args)
+    : std::runtime_error("") {
+    init(error_code, message, make_format_args(args...));
+  }
 
-    int error_code() const
-    {
-        return error_code_;
-    }
+  int error_code() const { return error_code_; }
 };
 
 /**
@@ -2986,977 +2374,838 @@ public:
   may look like "Unknown error -1" and is platform-dependent.
   \endrst
  */
-FMT_API void format_system_error(internal::buffer &out, int error_code, fmt::string_view message) FMT_NOEXCEPT;
+FMT_API void format_system_error(internal::buffer &out, int error_code,
+                                 fmt::string_view message) FMT_NOEXCEPT;
 
 /**
   This template provides operations for formatting and writing data into a
   character range.
  */
-template<typename Range>
-class basic_writer
-{
-public:
-    typedef typename Range::value_type char_type;
-    typedef decltype(internal::declval<Range>().begin()) iterator;
-    typedef basic_format_specs<char_type> format_specs;
+template <typename Range>
+class basic_writer {
+ public:
+  typedef typename Range::value_type char_type;
+  typedef decltype(internal::declval<Range>().begin()) iterator;
+  typedef basic_format_specs<char_type> format_specs;
 
-private:
-    // Output iterator.
-    iterator out_;
+ private:
+  // Output iterator.
+  iterator out_;
 
-    std::unique_ptr<locale_provider> locale_;
+  std::unique_ptr<locale_provider> locale_;
 
-    FMT_DISALLOW_COPY_AND_ASSIGN(basic_writer);
+  FMT_DISALLOW_COPY_AND_ASSIGN(basic_writer);
 
-    iterator out() const
-    {
-        return out_;
+  iterator out() const { return out_; }
+
+  // Attempts to reserve space for n extra characters in the output range.
+  // Returns a pointer to the reserved range or a reference to out_.
+  auto reserve(std::size_t n) -> decltype(internal::reserve(out_, n)) {
+    return internal::reserve(out_, n);
+  }
+
+  // Writes a value in the format
+  //   <left-padding><value><right-padding>
+  // where <value> is written by f(it).
+  template <typename F>
+  void write_padded(std::size_t size, const align_spec &spec, F f);
+
+  template <typename F>
+  struct padded_int_writer {
+    string_view prefix;
+    char_type fill;
+    std::size_t padding;
+    F f;
+
+    template <typename It>
+    void operator()(It &&it) const {
+      if (prefix.size() != 0)
+        it = std::copy_n(prefix.data(), prefix.size(), it);
+      it = std::fill_n(it, padding, fill);
+      f(it);
     }
+  };
 
-    // Attempts to reserve space for n extra characters in the output range.
-    // Returns a pointer to the reserved range or a reference to out_.
-    auto reserve(std::size_t n) -> decltype(internal::reserve(out_, n))
-    {
-        return internal::reserve(out_, n);
-    }
-
-    // Writes a value in the format
-    //   <left-padding><value><right-padding>
-    // where <value> is written by f(it).
-    template<typename F>
-    void write_padded(std::size_t size, const align_spec &spec, F f);
-
-    template<typename F>
-    struct padded_int_writer
-    {
-        string_view prefix;
-        char_type fill;
-        std::size_t padding;
-        F f;
-
-        template<typename It>
-        void operator()(It &&it) const
-        {
-            if (prefix.size() != 0)
-                it = std::copy_n(prefix.data(), prefix.size(), it);
-            it = std::fill_n(it, padding, fill);
-            f(it);
-        }
-    };
-
-    // Writes an integer in the format
-    //   <left-padding><prefix><numeric-padding><digits><right-padding>
-    // where <digits> are written by f(it).
-    template<typename Spec, typename F>
-    void write_int(unsigned num_digits, string_view prefix, const Spec &spec, F f)
-    {
-        std::size_t size = prefix.size() + num_digits;
-        char_type fill = static_cast<char_type>(spec.fill());
-        std::size_t padding = 0;
-        if (spec.align() == ALIGN_NUMERIC)
-        {
-            if (spec.width() > size)
-            {
-                padding = spec.width() - size;
-                size = spec.width();
-            }
-        }
-        else if (spec.precision() > static_cast<int>(num_digits))
-        {
-            size = prefix.size() + spec.precision();
-            padding = spec.precision() - num_digits;
-            fill = '0';
-        }
-        align_spec as = spec;
-        if (spec.align() == ALIGN_DEFAULT)
-            as.align_ = ALIGN_RIGHT;
-        write_padded(size, as, padded_int_writer<F>{prefix, fill, padding, f});
-    }
-
-    // Writes a decimal integer.
-    template<typename Int>
-    void write_decimal(Int value)
-    {
-        typedef typename internal::int_traits<Int>::main_type main_type;
-        main_type abs_value = static_cast<main_type>(value);
-        bool is_negative = internal::is_negative(value);
-        if (is_negative)
-            abs_value = 0 - abs_value;
-        unsigned num_digits = internal::count_digits(abs_value);
-        auto &&it = reserve((is_negative ? 1 : 0) + num_digits);
-        if (is_negative)
-            *it++ = '-';
-        internal::format_decimal(it, abs_value, num_digits);
-    }
-
-    // The handle_int_type_spec handler that writes an integer.
-    template<typename Int, typename Spec>
-    struct int_writer
-    {
-        typedef typename internal::int_traits<Int>::main_type unsigned_type;
-
-        basic_writer<Range> &writer;
-        const Spec &spec;
-        unsigned_type abs_value;
-        char prefix[4];
-        unsigned prefix_size;
-
-        string_view get_prefix() const
-        {
-            return string_view(prefix, prefix_size);
-        }
-
-        // Counts the number of digits in abs_value. BITS = log2(radix).
-        template<unsigned BITS>
-        unsigned count_digits() const
-        {
-            unsigned_type n = abs_value;
-            unsigned num_digits = 0;
-            do
-            {
-                ++num_digits;
-            } while ((n >>= BITS) != 0);
-            return num_digits;
-        }
-
-        int_writer(basic_writer<Range> &w, Int value, const Spec &s)
-            : writer(w)
-            , spec(s)
-            , abs_value(static_cast<unsigned_type>(value))
-            , prefix_size(0)
-        {
-            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;
-            }
-        }
-
-        struct dec_writer
-        {
-            unsigned_type abs_value;
-            unsigned num_digits;
-
-            template<typename It>
-            void operator()(It &&it) const
-            {
-                it = internal::format_decimal(it, abs_value, num_digits);
-            }
-        };
-
-        void on_dec()
-        {
-            unsigned num_digits = internal::count_digits(abs_value);
-            writer.write_int(num_digits, get_prefix(), spec, dec_writer{abs_value, num_digits});
-        }
-
-        struct hex_writer
-        {
-            int_writer &self;
-            unsigned num_digits;
-
-            template<typename It>
-            void operator()(It &&it) const
-            {
-                it = internal::format_uint<4>(it, self.abs_value, num_digits, self.spec.type() != 'x');
-            }
-        };
-
-        void on_hex()
-        {
-            if (spec.flag(HASH_FLAG))
-            {
-                prefix[prefix_size++] = '0';
-                prefix[prefix_size++] = static_cast<char>(spec.type());
-            }
-            unsigned num_digits = count_digits<4>();
-            writer.write_int(num_digits, get_prefix(), spec, hex_writer{*this, num_digits});
-        }
-
-        template<int BITS>
-        struct bin_writer
-        {
-            unsigned_type abs_value;
-            unsigned num_digits;
-
-            template<typename It>
-            void operator()(It &&it) const
-            {
-                it = internal::format_uint<BITS>(it, abs_value, num_digits);
-            }
-        };
-
-        void on_bin()
-        {
-            if (spec.flag(HASH_FLAG))
-            {
-                prefix[prefix_size++] = '0';
-                prefix[prefix_size++] = static_cast<char>(spec.type());
-            }
-            unsigned num_digits = count_digits<1>();
-            writer.write_int(num_digits, get_prefix(), spec, bin_writer<1>{abs_value, num_digits});
-        }
-
-        void on_oct()
-        {
-            unsigned num_digits = count_digits<3>();
-            if (spec.flag(HASH_FLAG) && spec.precision() <= static_cast<int>(num_digits))
-            {
-                // Octal prefix '0' is counted as a digit, so only add it if precision
-                // is not greater than the number of digits.
-                prefix[prefix_size++] = '0';
-            }
-            writer.write_int(num_digits, get_prefix(), spec, bin_writer<3>{abs_value, num_digits});
-        }
-
-        enum
-        {
-            SEP_SIZE = 1
-        };
-
-        struct num_writer
-        {
-            unsigned_type abs_value;
-            unsigned size;
-            char_type sep;
-
-            template<typename It>
-            void operator()(It &&it) const
-            {
-                basic_string_view<char_type> s(&sep, SEP_SIZE);
-                it = format_decimal(it, abs_value, size, internal::add_thousands_sep<char_type>(s));
-            }
-        };
-
-        void on_num()
-        {
-            unsigned num_digits = internal::count_digits(abs_value);
-            char_type sep = internal::thousands_sep<char_type>(writer.locale_.get());
-            unsigned size = num_digits + SEP_SIZE * ((num_digits - 1) / 3);
-            writer.write_int(size, get_prefix(), spec, num_writer{abs_value, size, sep});
-        }
-
-        void on_error()
-        {
-            FMT_THROW(format_error("invalid type specifier"));
-        }
-    };
-
-    // Writes a formatted integer.
-    template<typename T, typename Spec>
-    void write_int(T value, const Spec &spec)
-    {
-        internal::handle_int_type_spec(spec.type(), int_writer<T, Spec>(*this, value, spec));
-    }
-
-    enum
-    {
-        INF_SIZE = 3
-    }; // This is an enum to workaround a bug in MSVC.
-
-    struct inf_or_nan_writer
-    {
-        char sign;
-        const char *str;
-
-        template<typename It>
-        void operator()(It &&it) const
-        {
-            if (sign)
-                *it++ = sign;
-            it = std::copy_n(str, static_cast<std::size_t>(INF_SIZE), it);
-        }
-    };
-
-    struct double_writer
-    {
-        size_t n;
-        char sign;
-        basic_memory_buffer<char_type> &buffer;
-
-        template<typename It>
-        void operator()(It &&it)
-        {
-            if (sign)
-            {
-                *it++ = sign;
-                --n;
-            }
-            it = std::copy_n(buffer.begin(), n, it);
-        }
-    };
-
-    // Formats a floating-point number (double or long double).
-    template<typename T>
-    void write_double(T value, const format_specs &spec);
-    template<typename T>
-    void write_double_sprintf(T value, const format_specs &spec, internal::basic_buffer<char_type> &buffer);
-
-    template<typename Char>
-    struct str_writer
-    {
-        const Char *s;
-        std::size_t size;
-
-        template<typename It>
-        void operator()(It &&it) const
-        {
-            it = std::copy_n(s, size, it);
-        }
-    };
-
-    // Writes a formatted string.
-    template<typename Char>
-    void write_str(const Char *s, std::size_t size, const align_spec &spec)
-    {
-        write_padded(size, spec, str_writer<Char>{s, size});
-    }
-
-    template<typename Char>
-    void write_str(basic_string_view<Char> str, const format_specs &spec);
-
-    // Appends floating-point length specifier to the format string.
-    // The second argument is only used for overload resolution.
-    void append_float_length(char_type *&format_ptr, long double)
-    {
-        *format_ptr++ = 'L';
-    }
-
-    template<typename T>
-    void append_float_length(char_type *&, T)
-    {
-    }
-
-    template<typename Char>
-    friend class internal::arg_formatter_base;
-
-public:
-    /** Constructs a ``basic_writer`` object. */
-    explicit basic_writer(Range out)
-        : out_(out.begin())
-    {
-    }
-
-    void write(int value)
-    {
-        write_decimal(value);
-    }
-    void write(long value)
-    {
-        write_decimal(value);
-    }
-    void write(long long value)
-    {
-        write_decimal(value);
-    }
-
-    void write(unsigned value)
-    {
-        write_decimal(value);
-    }
-    void write(unsigned long value)
-    {
-        write_decimal(value);
-    }
-    void write(unsigned long long value)
-    {
-        write_decimal(value);
-    }
-
-    /**
-      \rst
-      Formats *value* and writes it to the buffer.
-      \endrst
-     */
-    template<typename T, typename FormatSpec, typename... FormatSpecs>
-    typename std::enable_if<std::is_integral<T>::value, void>::type write(T value, FormatSpec spec, FormatSpecs... specs)
-    {
-        format_specs s(spec, specs...);
-        s.align_ = ALIGN_RIGHT;
-        write_int(value, s);
-    }
-
-    void write(double value)
-    {
-        write_double(value, format_specs());
-    }
-
-    /**
-      \rst
-      Formats *value* using the general format for floating-point numbers
-      (``'g'``) and writes it to the buffer.
-      \endrst
-     */
-    void write(long double value)
-    {
-        write_double(value, format_specs());
-    }
-
-    /** Writes a character to the buffer. */
-    void write(char value)
-    {
-        *reserve(1) = value;
-    }
-
-    void write(wchar_t value)
-    {
-        internal::require_wchar<char_type>();
-        *reserve(1) = value;
-    }
-
-    /**
-      \rst
-      Writes *value* to the buffer.
-      \endrst
-     */
-    void write(string_view value)
-    {
-        auto &&it = reserve(value.size());
-        it = std::copy(value.begin(), value.end(), it);
-    }
-
-    void write(wstring_view value)
-    {
-        internal::require_wchar<char_type>();
-        auto &&it = reserve(value.size());
-        it = std::uninitialized_copy(value.begin(), value.end(), it);
-    }
-
-    template<typename... FormatSpecs>
-    void write(basic_string_view<char_type> str, FormatSpecs... specs)
-    {
-        write_str(str, format_specs(specs...));
-    }
-
-    template<typename T>
-    typename std::enable_if<std::is_same<T, void>::value>::type write(const T *p)
-    {
-        format_specs specs;
-        specs.flags_ = HASH_FLAG;
-        specs.type_ = 'x';
-        write_int(reinterpret_cast<uintptr_t>(p), specs);
-    }
-};
-
-template<typename Range>
-template<typename F>
-void basic_writer<Range>::write_padded(std::size_t size, const align_spec &spec, F f)
-{
-    unsigned width = spec.width();
-    if (width <= size)
-        return f(reserve(size));
-    auto &&it = reserve(width);
+  // Writes an integer in the format
+  //   <left-padding><prefix><numeric-padding><digits><right-padding>
+  // where <digits> are written by f(it).
+  template <typename Spec, typename F>
+  void write_int(unsigned num_digits, string_view prefix,
+                 const Spec &spec, F f) {
+    std::size_t size = prefix.size() + num_digits;
     char_type fill = static_cast<char_type>(spec.fill());
-    std::size_t padding = width - size;
-    if (spec.align() == ALIGN_RIGHT)
-    {
-        it = std::fill_n(it, padding, fill);
-        f(it);
+    std::size_t padding = 0;
+    if (spec.align() == ALIGN_NUMERIC) {
+      if (spec.width() > size) {
+        padding = spec.width() - size;
+        size = spec.width();
+      }
+    } else if (spec.precision() > static_cast<int>(num_digits)) {
+      size = prefix.size() + static_cast<std::size_t>(spec.precision());
+      padding = static_cast<std::size_t>(spec.precision()) - num_digits;
+      fill = '0';
     }
-    else if (spec.align() == ALIGN_CENTER)
-    {
-        std::size_t left_padding = padding / 2;
-        it = std::fill_n(it, left_padding, fill);
-        f(it);
-        it = std::fill_n(it, padding - left_padding, fill);
-    }
-    else
-    {
-        f(it);
-        it = std::fill_n(it, padding, fill);
-    }
-}
+    align_spec as = spec;
+    if (spec.align() == ALIGN_DEFAULT)
+      as.align_ = ALIGN_RIGHT;
+    write_padded(size, as, padded_int_writer<F>{prefix, fill, padding, f});
+  }
 
-template<typename Range>
-template<typename Char>
-void basic_writer<Range>::write_str(basic_string_view<Char> s, const format_specs &spec)
-{
-    const Char *data = s.data();
-    std::size_t size = s.size();
-    std::size_t precision = static_cast<std::size_t>(spec.precision_);
-    if (spec.precision_ >= 0 && precision < size)
-        size = precision;
-    write_str(data, size, spec);
-}
+  // Writes a decimal integer.
+  template <typename Int>
+  void write_decimal(Int value) {
+    typedef typename internal::int_traits<Int>::main_type main_type;
+    main_type abs_value = static_cast<main_type>(value);
+    bool is_negative = internal::is_negative(value);
+    if (is_negative)
+      abs_value = 0 - abs_value;
+    unsigned num_digits = internal::count_digits(abs_value);
+    auto &&it = reserve((is_negative ? 1 : 0) + num_digits);
+    if (is_negative)
+      *it++ = '-';
+    internal::format_decimal(it, abs_value, num_digits);
+  }
 
-template<typename Char>
-struct float_spec_handler
-{
-    Char type;
-    bool upper;
+  // The handle_int_type_spec handler that writes an integer.
+  template <typename Int, typename Spec>
+  struct int_writer {
+    typedef typename internal::int_traits<Int>::main_type unsigned_type;
 
-    explicit float_spec_handler(Char t)
-        : type(t)
-        , upper(false)
-    {
+    basic_writer<Range> &writer;
+    const Spec &spec;
+    unsigned_type abs_value;
+    char prefix[4];
+    unsigned prefix_size;
+
+    string_view get_prefix() const { return string_view(prefix, prefix_size); }
+
+    // Counts the number of digits in abs_value. BITS = log2(radix).
+    template <unsigned BITS>
+    unsigned count_digits() const {
+      unsigned_type n = abs_value;
+      unsigned num_digits = 0;
+      do {
+        ++num_digits;
+      } while ((n >>= BITS) != 0);
+      return num_digits;
     }
 
-    void on_general()
-    {
-        if (type == 'G')
-            upper = true;
-        else
-            type = 'g';
+    int_writer(basic_writer<Range> &w, Int value, const Spec &s)
+      : writer(w), spec(s), abs_value(static_cast<unsigned_type>(value)),
+        prefix_size(0) {
+      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;
+      }
     }
 
-    void on_exp()
-    {
-        if (type == 'E')
-            upper = true;
+    struct dec_writer {
+      unsigned_type abs_value;
+      unsigned num_digits;
+
+      template <typename It>
+      void operator()(It &&it) const {
+        it = internal::format_decimal(it, abs_value, num_digits);
+      }
+    };
+
+    void on_dec() {
+      unsigned num_digits = internal::count_digits(abs_value);
+      writer.write_int(num_digits, get_prefix(), spec,
+                       dec_writer{abs_value, num_digits});
     }
 
-    void on_fixed()
-    {
-        if (type == 'F')
-        {
-            upper = true;
-#if FMT_MSC_VER
-            // MSVC's printf doesn't support 'F'.
-            type = 'f';
-#endif
-        }
+    struct hex_writer {
+      int_writer &self;
+      unsigned num_digits;
+
+      template <typename It>
+      void operator()(It &&it) const {
+        it = internal::format_uint<4>(it, self.abs_value, num_digits,
+                                      self.spec.type() != 'x');
+      }
+    };
+
+    void on_hex() {
+      if (spec.flag(HASH_FLAG)) {
+        prefix[prefix_size++] = '0';
+        prefix[prefix_size++] = static_cast<char>(spec.type());
+      }
+      unsigned num_digits = count_digits<4>();
+      writer.write_int(num_digits, get_prefix(), spec,
+                       hex_writer{*this, num_digits});
     }
 
-    void on_hex()
-    {
-        if (type == 'A')
-            upper = true;
+    template <int BITS>
+    struct bin_writer {
+      unsigned_type abs_value;
+      unsigned num_digits;
+
+      template <typename It>
+      void operator()(It &&it) const {
+        it = internal::format_uint<BITS>(it, abs_value, num_digits);
+      }
+    };
+
+    void on_bin() {
+      if (spec.flag(HASH_FLAG)) {
+        prefix[prefix_size++] = '0';
+        prefix[prefix_size++] = static_cast<char>(spec.type());
+      }
+      unsigned num_digits = count_digits<1>();
+      writer.write_int(num_digits, get_prefix(), spec,
+                       bin_writer<1>{abs_value, num_digits});
     }
 
-    void on_error()
-    {
-        FMT_THROW(format_error("invalid type specifier"));
+    void on_oct() {
+      unsigned num_digits = count_digits<3>();
+      if (spec.flag(HASH_FLAG) &&
+          spec.precision() <= static_cast<int>(num_digits)) {
+        // Octal prefix '0' is counted as a digit, so only add it if precision
+        // is not greater than the number of digits.
+        prefix[prefix_size++] = '0';
+      }
+      writer.write_int(num_digits, get_prefix(), spec,
+                       bin_writer<3>{abs_value, num_digits});
     }
+
+    enum { SEP_SIZE = 1 };
+
+    struct num_writer {
+      unsigned_type abs_value;
+      unsigned size;
+      char_type sep;
+
+      template <typename It>
+      void operator()(It &&it) const {
+        basic_string_view<char_type> s(&sep, SEP_SIZE);
+        it = format_decimal(it, abs_value, size,
+                            internal::add_thousands_sep<char_type>(s));
+      }
+    };
+
+    void on_num() {
+      unsigned num_digits = internal::count_digits(abs_value);
+      char_type sep = internal::thousands_sep<char_type>(writer.locale_.get());
+      unsigned size = num_digits + SEP_SIZE * ((num_digits - 1) / 3);
+      writer.write_int(size, get_prefix(), spec,
+                       num_writer{abs_value, size, sep});
+    }
+
+    void on_error() {
+      FMT_THROW(format_error("invalid type specifier"));
+    }
+  };
+
+  // Writes a formatted integer.
+  template <typename T, typename Spec>
+  void write_int(T value, const Spec &spec) {
+    internal::handle_int_type_spec(spec.type(),
+                                   int_writer<T, Spec>(*this, value, spec));
+  }
+
+  enum {INF_SIZE = 3}; // This is an enum to workaround a bug in MSVC.
+
+  struct inf_or_nan_writer {
+    char sign;
+    const char *str;
+
+    template <typename It>
+    void operator()(It &&it) const {
+      if (sign)
+        *it++ = sign;
+      it = std::copy_n(str, static_cast<std::size_t>(INF_SIZE), it);
+    }
+  };
+
+  struct double_writer {
+    size_t n;
+    char sign;
+    basic_memory_buffer<char_type> &buffer;
+
+    template <typename It>
+    void operator()(It &&it) {
+      if (sign) {
+        *it++ = sign;
+        --n;
+      }
+      it = std::copy_n(buffer.begin(), n, it);
+    }
+  };
+
+  // Formats a floating-point number (double or long double).
+  template <typename T>
+  void write_double(T value, const format_specs &spec);
+  template <typename T>
+  void write_double_sprintf(T value, const format_specs &spec,
+                            internal::basic_buffer<char_type>& buffer);
+
+  template <typename Char>
+  struct str_writer {
+    const Char *s;
+    std::size_t size;
+
+    template <typename It>
+    void operator()(It &&it) const {
+      it = std::copy_n(s, size, it);
+    }
+  };
+
+  // Writes a formatted string.
+  template <typename Char>
+  void write_str(const Char *s, std::size_t size, const align_spec &spec) {
+    write_padded(size, spec, str_writer<Char>{s, size});
+  }
+
+  template <typename Char>
+  void write_str(basic_string_view<Char> str, const format_specs &spec);
+
+  // Appends floating-point length specifier to the format string.
+  // The second argument is only used for overload resolution.
+  void append_float_length(char_type *&format_ptr, long double) {
+    *format_ptr++ = 'L';
+  }
+
+  template<typename T>
+  void append_float_length(char_type *&, T) {}
+
+  template <typename Char>
+  friend class internal::arg_formatter_base;
+
+ public:
+  /** Constructs a ``basic_writer`` object. */
+  explicit basic_writer(Range out): out_(out.begin()) {}
+
+  void write(int value) { write_decimal(value); }
+  void write(long value) { write_decimal(value); }
+  void write(long long value) { write_decimal(value); }
+
+  void write(unsigned value) { write_decimal(value); }
+  void write(unsigned long value) { write_decimal(value); }
+  void write(unsigned long long value) { write_decimal(value); }
+
+  /**
+    \rst
+    Formats *value* and writes it to the buffer.
+    \endrst
+   */
+  template <typename T, typename FormatSpec, typename... FormatSpecs>
+  typename std::enable_if<std::is_integral<T>::value, void>::type
+      write(T value, FormatSpec spec, FormatSpecs... specs) {
+    format_specs s(spec, specs...);
+    s.align_ = ALIGN_RIGHT;
+    write_int(value, s);
+  }
+
+  void write(double value) {
+    write_double(value, format_specs());
+  }
+
+  /**
+    \rst
+    Formats *value* using the general format for floating-point numbers
+    (``'g'``) and writes it to the buffer.
+    \endrst
+   */
+  void write(long double value) {
+    write_double(value, format_specs());
+  }
+
+  /** Writes a character to the buffer. */
+  void write(char value) {
+    *reserve(1) = value;
+  }
+
+  void write(wchar_t value) {
+    internal::require_wchar<char_type>();
+    *reserve(1) = value;
+  }
+
+  /**
+    \rst
+    Writes *value* to the buffer.
+    \endrst
+   */
+  void write(string_view value) {
+    auto &&it = reserve(value.size());
+    it = std::copy(value.begin(), value.end(), it);
+  }
+
+  void write(wstring_view value) {
+    internal::require_wchar<char_type>();
+    auto &&it = reserve(value.size());
+    it = std::uninitialized_copy(value.begin(), value.end(), it);
+  }
+
+  template <typename... FormatSpecs>
+  void write(basic_string_view<char_type> str, FormatSpecs... specs) {
+    write_str(str, format_specs(specs...));
+  }
+
+  template <typename T>
+  typename std::enable_if<std::is_same<T, void>::value>::type write(const T* p) {
+    format_specs specs;
+    specs.flags_ = HASH_FLAG;
+    specs.type_ = 'x';
+    write_int(reinterpret_cast<uintptr_t>(p), specs);
+  }
 };
 
-template<typename Range>
-template<typename T>
-void basic_writer<Range>::write_double(T value, const format_specs &spec)
-{
-    // Check type.
-    float_spec_handler<char_type> handler(spec.type());
-    internal::handle_float_type_spec(spec.type(), handler);
-
-    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) ? '+' : ' ';
-    }
-
-    struct write_inf_or_nan_t
-    {
-        basic_writer &writer;
-        format_specs spec;
-        char sign;
-        void operator()(const char *str) const
-        {
-            writer.write_padded(INF_SIZE + (sign ? 1 : 0), spec, inf_or_nan_writer{sign, str});
-        }
-    } write_inf_or_nan = {*this, spec, sign};
-
-    // Format NaN and ininity ourselves because sprintf's output is not consistent
-    // across platforms.
-    if (internal::fputil::isnotanumber(value))
-        return write_inf_or_nan(handler.upper ? "NAN" : "nan");
-    if (internal::fputil::isinfinity(value))
-        return write_inf_or_nan(handler.upper ? "INF" : "inf");
-
-    basic_memory_buffer<char_type> buffer;
-    if (FMT_USE_GRISU && sizeof(T) <= sizeof(double) && std::numeric_limits<double>::is_iec559)
-    {
-        internal::fp fp_value(static_cast<double>(value));
-        fp_value.normalize();
-        // Find a cached power of 10 close to 1 / fp_value.
-        int dec_exp = 0;
-        const int min_exp = -60;
-        auto dec_pow = internal::get_cached_power(min_exp - (fp_value.e + internal::fp::significand_size), dec_exp);
-        internal::fp product = fp_value * dec_pow;
-        // Generate output.
-        internal::fp one(1ull << -product.e, product.e);
-        uint64_t hi = product.f >> -one.e;
-        uint64_t f = product.f & (one.f - 1);
-        typedef back_insert_range<internal::basic_buffer<char_type>> range;
-        basic_writer<range> w{range(buffer)};
-        w.write(hi);
-        size_t digits = buffer.size();
-        w.write('.');
-        const unsigned max_digits = 18;
-        while (digits++ < max_digits)
-        {
-            f *= 10;
-            w.write(static_cast<char>('0' + (f >> -one.e)));
-            f &= one.f - 1;
-        }
-        w.write('e');
-        w.write(-dec_exp);
-    }
-    else
-    {
-        format_specs normalized_spec(spec);
-        normalized_spec.type_ = handler.type;
-        write_double_sprintf(value, normalized_spec, buffer);
-    }
-    size_t n = buffer.size();
-    align_spec as = spec;
-    if (spec.align() == ALIGN_NUMERIC)
-    {
-        if (sign)
-        {
-            auto &&it = reserve(1);
-            *it++ = sign;
-            sign = 0;
-            if (as.width_)
-                --as.width_;
-        }
-        as.align_ = ALIGN_RIGHT;
-    }
-    else
-    {
-        if (spec.align() == ALIGN_DEFAULT)
-            as.align_ = ALIGN_RIGHT;
-        if (sign)
-            ++n;
-    }
-    write_padded(n, as, double_writer{n, sign, buffer});
+template <typename Range>
+template <typename F>
+void basic_writer<Range>::write_padded(
+    std::size_t size, const align_spec &spec, F f) {
+  unsigned width = spec.width();
+  if (width <= size)
+    return f(reserve(size));
+  auto &&it = reserve(width);
+  char_type fill = static_cast<char_type>(spec.fill());
+  std::size_t padding = width - size;
+  if (spec.align() == ALIGN_RIGHT) {
+    it = std::fill_n(it, padding, fill);
+    f(it);
+  } else if (spec.align() == ALIGN_CENTER) {
+    std::size_t left_padding = padding / 2;
+    it = std::fill_n(it, left_padding, fill);
+    f(it);
+    it = std::fill_n(it, padding - left_padding, fill);
+  } else {
+    f(it);
+    it = std::fill_n(it, padding, fill);
+  }
 }
 
-template<typename Range>
-template<typename T>
-void basic_writer<Range>::write_double_sprintf(T value, const format_specs &spec, internal::basic_buffer<char_type> &buffer)
-{
-    // Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail.
-    FMT_ASSERT(buffer.capacity() != 0, "empty buffer");
+template <typename Range>
+template <typename Char>
+void basic_writer<Range>::write_str(
+    basic_string_view<Char> s, const format_specs &spec) {
+  const Char *data = s.data();
+  std::size_t size = s.size();
+  std::size_t precision = static_cast<std::size_t>(spec.precision_);
+  if (spec.precision_ >= 0 && precision < size)
+    size = precision;
+  write_str(data, size, spec);
+}
 
-    // Build format string.
-    enum
-    {
-        MAX_FORMAT_SIZE = 10
-    }; // longest format: %#-*.*Lg
-    char_type format[MAX_FORMAT_SIZE];
-    char_type *format_ptr = format;
-    *format_ptr++ = '%';
-    if (spec.flag(HASH_FLAG))
-        *format_ptr++ = '#';
-    if (spec.precision() >= 0)
-    {
-        *format_ptr++ = '.';
-        *format_ptr++ = '*';
+template <typename Char>
+struct float_spec_handler {
+  Char type;
+  bool upper;
+
+  explicit float_spec_handler(Char t) : type(t), upper(false) {}
+
+  void on_general() {
+    if (type == 'G')
+      upper = true;
+    else
+      type = 'g';
+  }
+
+  void on_exp() {
+    if (type == 'E')
+      upper = true;
+  }
+
+  void on_fixed() {
+    if (type == 'F') {
+      upper = true;
+#if FMT_MSC_VER
+      // MSVC's printf doesn't support 'F'.
+      type = 'f';
+#endif
     }
+  }
 
-    append_float_length(format_ptr, value);
-    *format_ptr++ = spec.type();
-    *format_ptr = '\0';
+  void on_hex() {
+    if (type == 'A')
+      upper = true;
+  }
 
-    // Format using snprintf.
-    char_type *start = FMT_NULL;
-    for (;;)
-    {
-        std::size_t buffer_size = buffer.capacity();
-        start = &buffer[0];
-        int result = internal::char_traits<char_type>::format_float(start, buffer_size, format, spec.precision(), value);
-        if (result >= 0)
-        {
-            unsigned n = internal::to_unsigned(result);
-            if (n < buffer.capacity())
-            {
-                buffer.resize(n);
-                break; // The buffer is large enough - continue with formatting.
-            }
-            buffer.reserve(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);
-        }
+  void on_error() {
+    FMT_THROW(format_error("invalid type specifier"));
+  }
+};
+
+template <typename Range>
+template <typename T>
+void basic_writer<Range>::write_double(T value, const format_specs &spec) {
+  // Check type.
+  float_spec_handler<char_type> handler(spec.type());
+  internal::handle_float_type_spec(spec.type(), handler);
+
+  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) ? '+' : ' ';
+  }
+
+  struct write_inf_or_nan_t {
+    basic_writer &writer;
+    format_specs spec;
+    char sign;
+    void operator()(const char *str) const {
+      writer.write_padded(INF_SIZE + (sign ? 1 : 0), spec,
+                          inf_or_nan_writer{sign, str});
     }
+  } write_inf_or_nan = {*this, spec, sign};
+
+  // Format NaN and ininity ourselves because sprintf's output is not consistent
+  // across platforms.
+  if (internal::fputil::isnotanumber(value))
+    return write_inf_or_nan(handler.upper ? "NAN" : "nan");
+  if (internal::fputil::isinfinity(value))
+    return write_inf_or_nan(handler.upper ? "INF" : "inf");
+
+  basic_memory_buffer<char_type> buffer;
+  if (FMT_USE_GRISU && sizeof(T) <= sizeof(double) &&
+      std::numeric_limits<double>::is_iec559) {
+    internal::fp fp_value(static_cast<double>(value));
+    fp_value.normalize();
+    // Find a cached power of 10 close to 1 / fp_value.
+    int dec_exp = 0;
+    const int min_exp = -60;
+    auto dec_pow = internal::get_cached_power(
+        min_exp - (fp_value.e + internal::fp::significand_size), dec_exp);
+    internal::fp product = fp_value * dec_pow;
+    // Generate output.
+    internal::fp one(1ull << -product.e, product.e);
+    uint64_t hi = product.f >> -one.e;
+    uint64_t f = product.f & (one.f - 1);
+    typedef back_insert_range<internal::basic_buffer<char_type>> range;
+    basic_writer<range> w{range(buffer)};
+    w.write(hi);
+    size_t digits = buffer.size();
+    w.write('.');
+    const unsigned max_digits = 18;
+    while (digits++ < max_digits) {
+      f *= 10;
+      w.write(static_cast<char>('0' + (f >> -one.e)));
+      f &= one.f - 1;
+    }
+    w.write('e');
+    w.write(-dec_exp);
+  } else {
+    format_specs normalized_spec(spec);
+    normalized_spec.type_ = handler.type;
+    write_double_sprintf(value, normalized_spec, buffer);
+  }
+  size_t n = buffer.size();
+  align_spec as = spec;
+  if (spec.align() == ALIGN_NUMERIC) {
+    if (sign) {
+      auto &&it = reserve(1);
+      *it++ = sign;
+      sign = 0;
+      if (as.width_)
+        --as.width_;
+    }
+    as.align_ = ALIGN_RIGHT;
+  } else {
+    if (spec.align() == ALIGN_DEFAULT)
+      as.align_ = ALIGN_RIGHT;
+    if (sign)
+      ++n;
+  }
+  write_padded(n, as, double_writer{n, sign, buffer});
+}
+
+template <typename Range>
+template <typename T>
+void basic_writer<Range>::write_double_sprintf(
+    T value, const format_specs &spec,
+    internal::basic_buffer<char_type>& buffer) {
+  // Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail.
+  FMT_ASSERT(buffer.capacity() != 0, "empty buffer");
+
+  // Build format string.
+  enum { MAX_FORMAT_SIZE = 10}; // longest format: %#-*.*Lg
+  char_type format[MAX_FORMAT_SIZE];
+  char_type *format_ptr = format;
+  *format_ptr++ = '%';
+  if (spec.flag(HASH_FLAG))
+    *format_ptr++ = '#';
+  if (spec.precision() >= 0) {
+    *format_ptr++ = '.';
+    *format_ptr++ = '*';
+  }
+
+  append_float_length(format_ptr, value);
+  *format_ptr++ = spec.type();
+  *format_ptr = '\0';
+
+  // Format using snprintf.
+  char_type *start = FMT_NULL;
+  for (;;) {
+    std::size_t buffer_size = buffer.capacity();
+    start = &buffer[0];
+    int result = internal::char_traits<char_type>::format_float(
+        start, buffer_size, format, spec.precision(), value);
+    if (result >= 0) {
+      unsigned n = internal::to_unsigned(result);
+      if (n < buffer.capacity()) {
+        buffer.resize(n);
+        break;  // The buffer is large enough - continue with formatting.
+      }
+      buffer.reserve(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);
+    }
+  }
 }
 
 // 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, string_view message) FMT_NOEXCEPT;
+FMT_API void report_system_error(int error_code,
+                                 string_view message) FMT_NOEXCEPT;
 
 #if FMT_USE_WINDOWS_H
 
 /** A Windows error. */
-class windows_error : public system_error
-{
-private:
-    FMT_API void init(int error_code, string_view format_str, format_args args);
+class windows_error : public system_error {
+ private:
+  FMT_API void init(int error_code, string_view format_str, format_args args);
 
-public:
-    /**
-     \rst
-     Constructs a :class:`fmt::windows_error` object with the description
-     of the form
+ public:
+  /**
+   \rst
+   Constructs a :class:`fmt::windows_error` object with the description
+   of the form
 
-     .. parsed-literal::
-       *<message>*: *<system-message>*
+   .. 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".
+   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**::
+   **Example**::
 
-       // This throws a windows_error 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::windows_error(GetLastError(),
-                                  "cannot open file '{}'", filename);
-       }
-     \endrst
-    */
-    template<typename... Args>
-    windows_error(int error_code, string_view message, const Args &... args)
-    {
-        init(error_code, message, make_format_args(args...));
-    }
+     // This throws a windows_error 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::windows_error(GetLastError(),
+                                "cannot open file '{}'", filename);
+     }
+   \endrst
+  */
+  template <typename... Args>
+  windows_error(int error_code, string_view message, const Args & ... args) {
+    init(error_code, message, make_format_args(args...));
+  }
 };
 
 // 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, string_view message) FMT_NOEXCEPT;
+FMT_API void report_windows_error(int error_code,
+                                  string_view message) FMT_NOEXCEPT;
 
 #endif
 
 /** Fast integer formatter. */
-class format_int
-{
-private:
-    // Buffer should be large enough to hold all digits (digits10 + 1),
-    // a sign and a null character.
-    enum
-    {
-        BUFFER_SIZE = std::numeric_limits<unsigned long long>::digits10 + 3
-    };
-    mutable char buffer_[BUFFER_SIZE];
-    char *str_;
+class format_int {
+ private:
+  // Buffer should be large enough to hold all digits (digits10 + 1),
+  // a sign and a null character.
+  enum {BUFFER_SIZE = std::numeric_limits<unsigned long long>::digits10 + 3};
+  mutable char buffer_[BUFFER_SIZE];
+  char *str_;
 
-    // Formats value in reverse and returns a pointer to the beginning.
-    char *format_decimal(unsigned long long value)
-    {
-        char *ptr = 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;
-            *--ptr = internal::data::DIGITS[index + 1];
-            *--ptr = internal::data::DIGITS[index];
-        }
-        if (value < 10)
-        {
-            *--ptr = static_cast<char>('0' + value);
-            return ptr;
-        }
-        unsigned index = static_cast<unsigned>(value * 2);
-        *--ptr = internal::data::DIGITS[index + 1];
-        *--ptr = internal::data::DIGITS[index];
-        return ptr;
+  // Formats value in reverse and returns a pointer to the beginning.
+  char *format_decimal(unsigned long long value) {
+    char *ptr = 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;
+      *--ptr = internal::data::DIGITS[index + 1];
+      *--ptr = internal::data::DIGITS[index];
     }
+    if (value < 10) {
+      *--ptr = static_cast<char>('0' + value);
+      return ptr;
+    }
+    unsigned index = static_cast<unsigned>(value * 2);
+    *--ptr = internal::data::DIGITS[index + 1];
+    *--ptr = internal::data::DIGITS[index];
+    return ptr;
+  }
 
-    void format_signed(long long value)
-    {
-        unsigned long long abs_value = static_cast<unsigned long long>(value);
-        bool negative = value < 0;
-        if (negative)
-            abs_value = 0 - abs_value;
-        str_ = format_decimal(abs_value);
-        if (negative)
-            *--str_ = '-';
-    }
+  void format_signed(long long value) {
+    unsigned long long abs_value = static_cast<unsigned long long>(value);
+    bool negative = value < 0;
+    if (negative)
+      abs_value = 0 - abs_value;
+    str_ = format_decimal(abs_value);
+    if (negative)
+      *--str_ = '-';
+  }
 
-public:
-    explicit format_int(int value)
-    {
-        format_signed(value);
-    }
-    explicit format_int(long value)
-    {
-        format_signed(value);
-    }
-    explicit format_int(long long value)
-    {
-        format_signed(value);
-    }
-    explicit format_int(unsigned value)
-        : str_(format_decimal(value))
-    {
-    }
-    explicit format_int(unsigned long value)
-        : str_(format_decimal(value))
-    {
-    }
-    explicit format_int(unsigned long long value)
-        : str_(format_decimal(value))
-    {
-    }
+ public:
+  explicit format_int(int value) { format_signed(value); }
+  explicit format_int(long value) { format_signed(value); }
+  explicit format_int(long long value) { format_signed(value); }
+  explicit format_int(unsigned value) : str_(format_decimal(value)) {}
+  explicit format_int(unsigned long value) : str_(format_decimal(value)) {}
+  explicit format_int(unsigned long long 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 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. 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_;
-    }
+  /**
+    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());
-    }
+  /**
+    \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::int_traits<T>::main_type main_type;
-    main_type abs_value = static_cast<main_type>(value);
-    if (internal::is_negative(value))
-    {
-        *buffer++ = '-';
-        abs_value = 0 - abs_value;
+template <typename T>
+inline void format_decimal(char *&buffer, T value) {
+  typedef typename internal::int_traits<T>::main_type main_type;
+  main_type abs_value = static_cast<main_type>(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;
     }
-    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;
+    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;
 }
 
 // Formatter of objects of type T.
-template<typename T, typename Char>
-struct formatter<T, Char, typename std::enable_if<internal::format_type<typename buffer_context<Char>::type, T>::value>::type>
-{
+template <typename T, typename Char>
+struct formatter<
+    T, Char,
+    typename std::enable_if<internal::format_type<
+        typename buffer_context<Char>::type, T>::value>::type> {
 
-    // Parses format specifiers stopping either at the end of the range or at the
-    // terminating '}'.
-    template<typename ParseContext>
-    FMT_CONSTEXPR typename ParseContext::iterator parse(ParseContext &ctx)
-    {
-        auto it = internal::null_terminating_iterator<Char>(ctx);
-        typedef internal::dynamic_specs_handler<ParseContext> handler_type;
-        auto type = internal::get_type<typename buffer_context<Char>::type, T>::value;
-        internal::specs_checker<handler_type> handler(handler_type(specs_, ctx), type);
-        it = parse_format_specs(it, handler);
-        auto type_spec = specs_.type();
-        auto eh = ctx.error_handler();
-        switch (type)
-        {
-        case internal::none_type:
-        case internal::named_arg_type:
-            FMT_ASSERT(false, "invalid argument type");
-            break;
-        case internal::int_type:
-        case internal::uint_type:
-        case internal::long_long_type:
-        case internal::ulong_long_type:
-        case internal::bool_type:
-            handle_int_type_spec(type_spec, internal::int_type_checker<decltype(eh)>(eh));
-            break;
-        case internal::char_type:
-            handle_char_specs(specs_, internal::char_specs_checker<decltype(eh), decltype(type_spec)>(type_spec, eh));
-            break;
-        case internal::double_type:
-        case internal::long_double_type:
-            handle_float_type_spec(type_spec, internal::float_type_checker<decltype(eh)>(eh));
-            break;
-        case internal::cstring_type:
-            internal::handle_cstring_type_spec(type_spec, internal::cstring_type_checker<decltype(eh)>(eh));
-            break;
-        case internal::string_type:
-            internal::check_string_type_spec(type_spec, eh);
-            break;
-        case internal::pointer_type:
-            internal::check_pointer_type_spec(type_spec, eh);
-            break;
-        case internal::custom_type:
-            // Custom format specifiers should be checked in parse functions of
-            // formatter specializations.
-            break;
-        }
-        return pointer_from(it);
+  // Parses format specifiers stopping either at the end of the range or at the
+  // terminating '}'.
+  template <typename ParseContext>
+  FMT_CONSTEXPR typename ParseContext::iterator parse(ParseContext &ctx) {
+    auto it = internal::null_terminating_iterator<Char>(ctx);
+    typedef internal::dynamic_specs_handler<ParseContext> handler_type;
+    auto type = internal::get_type<
+      typename buffer_context<Char>::type, T>::value;
+    internal::specs_checker<handler_type>
+        handler(handler_type(specs_, ctx), type);
+    it = parse_format_specs(it, handler);
+    auto type_spec = specs_.type();
+    auto eh = ctx.error_handler();
+    switch (type) {
+    case internal::none_type:
+    case internal::named_arg_type:
+      FMT_ASSERT(false, "invalid argument type");
+      break;
+    case internal::int_type:
+    case internal::uint_type:
+    case internal::long_long_type:
+    case internal::ulong_long_type:
+    case internal::bool_type:
+      handle_int_type_spec(
+            type_spec, internal::int_type_checker<decltype(eh)>(eh));
+      break;
+    case internal::char_type:
+      handle_char_specs(
+          specs_,
+          internal::char_specs_checker<decltype(eh), decltype(type_spec)>(
+              type_spec, eh));
+      break;
+    case internal::double_type:
+    case internal::long_double_type:
+      handle_float_type_spec(
+            type_spec, internal::float_type_checker<decltype(eh)>(eh));
+      break;
+    case internal::cstring_type:
+      internal::handle_cstring_type_spec(
+            type_spec, internal::cstring_type_checker<decltype(eh)>(eh));
+      break;
+    case internal::string_type:
+      internal::check_string_type_spec(type_spec, eh);
+      break;
+    case internal::pointer_type:
+      internal::check_pointer_type_spec(type_spec, eh);
+      break;
+    case internal::custom_type:
+      // Custom format specifiers should be checked in parse functions of
+      // formatter specializations.
+      break;
     }
+    return pointer_from(it);
+  }
 
-    template<typename FormatContext>
-    auto format(const T &val, FormatContext &ctx) -> decltype(ctx.out())
-    {
-        internal::handle_dynamic_spec<internal::width_checker>(specs_.width_, specs_.width_ref, ctx);
-        internal::handle_dynamic_spec<internal::precision_checker>(specs_.precision_, specs_.precision_ref, ctx);
-        typedef output_range<typename FormatContext::iterator, typename FormatContext::char_type> range_type;
-        visit(arg_formatter<range_type>(ctx, specs_), internal::make_arg<FormatContext>(val));
-        return ctx.out();
-    }
+  template <typename FormatContext>
+  auto format(const T &val, FormatContext &ctx) -> decltype(ctx.out()) {
+    internal::handle_dynamic_spec<internal::width_checker>(
+      specs_.width_, specs_.width_ref, ctx);
+    internal::handle_dynamic_spec<internal::precision_checker>(
+      specs_.precision_, specs_.precision_ref, ctx);
+    typedef output_range<typename FormatContext::iterator,
+                         typename FormatContext::char_type> range_type;
+    return visit(arg_formatter<range_type>(ctx, specs_),
+                 internal::make_arg<FormatContext>(val));
+  }
 
-private:
-    internal::dynamic_format_specs<Char> specs_;
+ private:
+  internal::dynamic_format_specs<Char> specs_;
 };
 
-template<typename T, typename Char>
-struct formatter<T, Char, typename std::enable_if<internal::format_enum<T>::value>::type> : public formatter<int, Char>
-{
-    template<typename ParseContext>
-    auto parse(ParseContext &ctx) -> decltype(ctx.begin())
-    {
-        return ctx.begin();
-    }
+template <typename T, typename Char>
+struct formatter<T, Char,
+    typename std::enable_if<internal::format_enum<T>::value>::type>
+    : public formatter<int, Char> {
+  template <typename ParseContext>
+  auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
 };
 
 // A formatter for types known only at run time such as variant alternatives.
@@ -3969,228 +3218,201 @@ struct formatter<T, Char, typename std::enable_if<internal::format_enum<T>::valu
 //       visit([&](const auto &val) { format(buf, val, ctx); }, v);
 //     }
 //   };
-template<typename Char = char>
-class dynamic_formatter
-{
-private:
-    struct null_handler : internal::error_handler
-    {
-        void on_align(alignment) {}
-        void on_plus() {}
-        void on_minus() {}
-        void on_space() {}
-        void on_hash() {}
-    };
+template <typename Char = char>
+class dynamic_formatter {
+ private:
+  struct null_handler: internal::error_handler {
+    void on_align(alignment) {}
+    void on_plus() {}
+    void on_minus() {}
+    void on_space() {}
+    void on_hash() {}
+  };
 
-public:
-    template<typename ParseContext>
-    auto parse(ParseContext &ctx) -> decltype(ctx.begin())
-    {
-        auto it = internal::null_terminating_iterator<Char>(ctx);
-        // Checks are deferred to formatting time when the argument type is known.
-        internal::dynamic_specs_handler<ParseContext> handler(specs_, ctx);
-        it = parse_format_specs(it, handler);
-        return pointer_from(it);
+ public:
+  template <typename ParseContext>
+  auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
+    auto it = internal::null_terminating_iterator<Char>(ctx);
+    // Checks are deferred to formatting time when the argument type is known.
+    internal::dynamic_specs_handler<ParseContext> handler(specs_, ctx);
+    it = parse_format_specs(it, handler);
+    return pointer_from(it);
+  }
+
+  template <typename T, typename FormatContext>
+  auto format(const T &val, FormatContext &ctx) -> decltype(ctx.out()) {
+    handle_specs(ctx);
+    internal::specs_checker<null_handler>
+        checker(null_handler(), internal::get_type<FormatContext, T>::value);
+    checker.on_align(specs_.align());
+    if (specs_.flags_ == 0) {
+      // Do nothing.
+    } else if (specs_.flag(SIGN_FLAG)) {
+      if (specs_.flag(PLUS_FLAG))
+        checker.on_plus();
+      else
+        checker.on_space();
+    } else if (specs_.flag(MINUS_FLAG)) {
+      checker.on_minus();
+    } else if (specs_.flag(HASH_FLAG)) {
+      checker.on_hash();
     }
+    if (specs_.precision_ != -1)
+      checker.end_precision();
+    typedef output_range<typename FormatContext::iterator,
+                         typename FormatContext::char_type> range;
+    visit(arg_formatter<range>(ctx, specs_),
+          internal::make_arg<FormatContext>(val));
+    return ctx.out();
+  }
 
-    template<typename T, typename FormatContext>
-    auto format(const T &val, FormatContext &ctx) -> decltype(ctx.out())
-    {
-        handle_specs(ctx);
-        internal::specs_checker<null_handler> checker(null_handler(), internal::get_type<FormatContext, T>::value);
-        checker.on_align(specs_.align());
-        if (specs_.flags_ == 0)
-        {
-            // Do nothing.
-        }
-        else if (specs_.flag(SIGN_FLAG))
-        {
-            if (specs_.flag(PLUS_FLAG))
-                checker.on_plus();
-            else
-                checker.on_space();
-        }
-        else if (specs_.flag(MINUS_FLAG))
-        {
-            checker.on_minus();
-        }
-        else if (specs_.flag(HASH_FLAG))
-        {
-            checker.on_hash();
-        }
-        if (specs_.precision_ != -1)
-            checker.end_precision();
-        typedef output_range<typename FormatContext::iterator, typename FormatContext::char_type> range;
-        visit(arg_formatter<range>(ctx, specs_), internal::make_arg<FormatContext>(val));
-        return ctx.out();
-    }
+ private:
+  template <typename Context>
+  void handle_specs(Context &ctx) {
+    internal::handle_dynamic_spec<internal::width_checker>(
+      specs_.width_, specs_.width_ref, ctx);
+    internal::handle_dynamic_spec<internal::precision_checker>(
+      specs_.precision_, specs_.precision_ref, ctx);
+  }
 
-private:
-    template<typename Context>
-    void handle_specs(Context &ctx)
-    {
-        internal::handle_dynamic_spec<internal::width_checker>(specs_.width_, specs_.width_ref, ctx);
-        internal::handle_dynamic_spec<internal::precision_checker>(specs_.precision_, specs_.precision_ref, ctx);
-    }
-
-    internal::dynamic_format_specs<Char> specs_;
+  internal::dynamic_format_specs<Char> specs_;
 };
 
-template<typename Range, typename Char>
-typename basic_format_context<Range, Char>::format_arg basic_format_context<Range, Char>::get_arg(basic_string_view<char_type> name)
-{
-    map_.init(this->args());
-    format_arg arg = map_.find(name);
-    if (arg.type() == internal::none_type)
-        this->on_error("argument not found");
-    return arg;
+template <typename Range, typename Char>
+typename basic_format_context<Range, Char>::format_arg
+  basic_format_context<Range, Char>::get_arg(basic_string_view<char_type> name) {
+  map_.init(this->args());
+  format_arg arg = map_.find(name);
+  if (arg.type() == internal::none_type)
+    this->on_error("argument not found");
+  return arg;
 }
 
-template<typename ArgFormatter, typename Char, typename Context>
-struct format_handler : internal::error_handler
-{
-    typedef internal::null_terminating_iterator<Char> iterator;
-    typedef typename ArgFormatter::range range;
+template <typename ArgFormatter, typename Char, typename Context>
+struct format_handler : internal::error_handler {
+  typedef internal::null_terminating_iterator<Char> iterator;
+  typedef typename ArgFormatter::range range;
 
-    format_handler(range r, basic_string_view<Char> str, basic_format_args<Context> format_args)
-        : context(r.begin(), str, format_args)
-    {
-    }
+  format_handler(range r, basic_string_view<Char> str,
+                 basic_format_args<Context> format_args)
+    : context(r.begin(), str, format_args) {}
 
-    void on_text(iterator begin, iterator end)
-    {
-        size_t size = end - begin;
-        auto out = context.out();
-        auto &&it = internal::reserve(out, size);
-        it = std::copy_n(begin, size, it);
-        context.advance_to(out);
-    }
+  void on_text(iterator begin, iterator end) {
+    auto size = internal::to_unsigned(end - begin);
+    auto out = context.out();
+    auto &&it = internal::reserve(out, size);
+    it = std::copy_n(begin, size, it);
+    context.advance_to(out);
+  }
 
-    void on_arg_id()
-    {
-        arg = context.next_arg();
-    }
-    void on_arg_id(unsigned id)
-    {
-        context.parse_context().check_arg_id(id);
-        arg = context.get_arg(id);
-    }
-    void on_arg_id(basic_string_view<Char> id)
-    {
-        arg = context.get_arg(id);
-    }
+  void on_arg_id() { arg = context.next_arg(); }
+  void on_arg_id(unsigned id) {
+    context.parse_context().check_arg_id(id);
+    arg = context.get_arg(id);
+  }
+  void on_arg_id(basic_string_view<Char> id) {
+    arg = context.get_arg(id);
+  }
 
-    void on_replacement_field(iterator it)
-    {
-        context.parse_context().advance_to(pointer_from(it));
-        if (visit(internal::custom_formatter<Char, Context>(context), arg))
-            return;
-        basic_format_specs<Char> specs;
-        context.advance_to(visit(ArgFormatter(context, specs), arg));
-    }
+  void on_replacement_field(iterator it) {
+    context.parse_context().advance_to(pointer_from(it));
+    if (visit(internal::custom_formatter<Char, Context>(context), arg))
+      return;
+    basic_format_specs<Char> specs;
+    context.advance_to(visit(ArgFormatter(context, specs), arg));
+  }
 
-    iterator on_format_specs(iterator it)
-    {
-        auto &parse_ctx = context.parse_context();
-        parse_ctx.advance_to(pointer_from(it));
-        if (visit(internal::custom_formatter<Char, Context>(context), arg))
-            return iterator(parse_ctx);
-        basic_format_specs<Char> specs;
-        using internal::specs_handler;
-        internal::specs_checker<specs_handler<Context>> handler(specs_handler<Context>(specs, context), arg.type());
-        it = parse_format_specs(it, handler);
-        if (*it != '}')
-            on_error("missing '}' in format string");
-        parse_ctx.advance_to(pointer_from(it));
-        context.advance_to(visit(ArgFormatter(context, specs), arg));
-        return it;
-    }
+  iterator on_format_specs(iterator it) {
+    auto& parse_ctx = context.parse_context();
+    parse_ctx.advance_to(pointer_from(it));
+    if (visit(internal::custom_formatter<Char, Context>(context), arg))
+      return iterator(parse_ctx);
+    basic_format_specs<Char> specs;
+    using internal::specs_handler;
+    internal::specs_checker<specs_handler<Context>>
+        handler(specs_handler<Context>(specs, context), arg.type());
+    it = parse_format_specs(it, handler);
+    if (*it != '}')
+      on_error("missing '}' in format string");
+    parse_ctx.advance_to(pointer_from(it));
+    context.advance_to(visit(ArgFormatter(context, specs), arg));
+    return it;
+  }
 
-    Context context;
-    basic_format_arg<Context> arg;
+  Context context;
+  basic_format_arg<Context> arg;
 };
 
 /** Formats arguments and writes the output to the range. */
-template<typename ArgFormatter, typename Char, typename Context>
-typename Context::iterator vformat_to(typename ArgFormatter::range out, basic_string_view<Char> format_str, basic_format_args<Context> args)
-{
-    typedef internal::null_terminating_iterator<Char> iterator;
-    format_handler<ArgFormatter, Char, Context> h(out, format_str, args);
-    parse_format_string(iterator(format_str.begin(), format_str.end()), h);
-    return h.context.out();
+template <typename ArgFormatter, typename Char, typename Context>
+typename Context::iterator vformat_to(typename ArgFormatter::range out,
+                                      basic_string_view<Char> format_str,
+                                      basic_format_args<Context> args) {
+  typedef internal::null_terminating_iterator<Char> iterator;
+  format_handler<ArgFormatter, Char, Context> h(out, format_str, args);
+  parse_format_string(iterator(format_str.begin(), format_str.end()), h);
+  return h.context.out();
 }
 
 // Casts ``p`` to ``const void*`` for pointer formatting.
 // Example:
 //   auto s = format("{}", ptr(p));
-template<typename T>
-inline const void *ptr(const T *p)
-{
-    return p;
-}
+template <typename T>
+inline const void *ptr(const T *p) { return p; }
 
-template<typename It, typename Char>
-struct arg_join
-{
-    It begin;
-    It end;
-    basic_string_view<Char> sep;
+template <typename It, typename Char>
+struct arg_join {
+  It begin;
+  It end;
+  basic_string_view<Char> sep;
 
-    arg_join(It begin, It end, basic_string_view<Char> sep)
-        : begin(begin)
-        , end(end)
-        , sep(sep)
-    {
-    }
+  arg_join(It begin, It end, basic_string_view<Char> sep)
+    : begin(begin), end(end), sep(sep) {}
 };
 
-template<typename It, typename Char>
-struct formatter<arg_join<It, Char>, Char> : formatter<typename std::iterator_traits<It>::value_type, Char>
-{
-    template<typename FormatContext>
-    auto format(const arg_join<It, Char> &value, FormatContext &ctx) -> decltype(ctx.out())
-    {
-        typedef formatter<typename std::iterator_traits<It>::value_type, Char> base;
-        auto it = value.begin;
-        auto out = ctx.out();
-        if (it != value.end)
-        {
-            out = base::format(*it++, ctx);
-            while (it != value.end)
-            {
-                out = std::copy(value.sep.begin(), value.sep.end(), out);
-                ctx.advance_to(out);
-                out = base::format(*it++, ctx);
-            }
-        }
-        return out;
+template <typename It, typename Char>
+struct formatter<arg_join<It, Char>, Char>:
+    formatter<typename std::iterator_traits<It>::value_type, Char> {
+  template <typename FormatContext>
+  auto format(const arg_join<It, Char> &value, FormatContext &ctx)
+      -> decltype(ctx.out()) {
+    typedef formatter<typename std::iterator_traits<It>::value_type, Char> base;
+    auto it = value.begin;
+    auto out = ctx.out();
+    if (it != value.end) {
+      out = base::format(*it++, ctx);
+      while (it != value.end) {
+        out = std::copy(value.sep.begin(), value.sep.end(), out);
+        ctx.advance_to(out);
+        out = base::format(*it++, ctx);
+      }
     }
+    return out;
+  }
 };
 
-template<typename It>
-arg_join<It, char> join(It begin, It end, string_view sep)
-{
-    return arg_join<It, char>(begin, end, sep);
+template <typename It>
+arg_join<It, char> join(It begin, It end, string_view sep) {
+  return arg_join<It, char>(begin, end, sep);
 }
 
-template<typename It>
-arg_join<It, wchar_t> join(It begin, It end, wstring_view sep)
-{
-    return arg_join<It, wchar_t>(begin, end, sep);
+template <typename It>
+arg_join<It, wchar_t> join(It begin, It end, wstring_view sep) {
+  return arg_join<It, wchar_t>(begin, end, sep);
 }
 
 // The following causes ICE in gcc 4.4.
 #if FMT_USE_TRAILING_RETURN && (!FMT_GCC_VERSION || FMT_GCC_VERSION >= 405)
-template<typename Range>
-auto join(const Range &range, string_view sep) -> arg_join<decltype(internal::begin(range)), char>
-{
-    return join(internal::begin(range), internal::end(range), sep);
+template <typename Range>
+auto join(const Range &range, string_view sep)
+    -> arg_join<decltype(internal::begin(range)), char> {
+  return join(internal::begin(range), internal::end(range), sep);
 }
 
-template<typename Range>
-auto join(const Range &range, wstring_view sep) -> arg_join<decltype(internal::begin(range)), wchar_t>
-{
-    return join(internal::begin(range), internal::end(range), sep);
+template <typename Range>
+auto join(const Range &range, wstring_view sep)
+    -> arg_join<decltype(internal::begin(range)), wchar_t> {
+  return join(internal::begin(range), internal::end(range), sep);
 }
 #endif
 
@@ -4205,76 +3427,79 @@ auto join(const Range &range, wstring_view sep) -> arg_join<decltype(internal::b
     std::string answer = fmt::to_string(42);
   \endrst
  */
-template<typename T>
-std::string to_string(const T &value)
-{
-    std::string str;
-    internal::container_buffer<std::string> buf(str);
-    writer(buf).write(value);
-    return str;
+template <typename T>
+std::string to_string(const T &value) {
+  std::string str;
+  internal::container_buffer<std::string> buf(str);
+  writer(buf).write(value);
+  return str;
 }
 
 /**
   Converts *value* to ``std::wstring`` using the default format for type *T*.
  */
-template<typename T>
-std::wstring to_wstring(const T &value)
-{
-    std::wstring str;
-    internal::container_buffer<std::wstring> buf(str);
-    wwriter(buf).write(value);
-    return str;
+template <typename T>
+std::wstring to_wstring(const T &value) {
+  std::wstring str;
+  internal::container_buffer<std::wstring> buf(str);
+  wwriter(buf).write(value);
+  return str;
 }
 
-template<typename Char>
-std::basic_string<Char> to_string(const basic_memory_buffer<Char> &buffer)
-{
-    return std::basic_string<Char>(buffer.data(), buffer.size());
+template <typename Char, std::size_t SIZE>
+std::basic_string<Char> to_string(const basic_memory_buffer<Char, SIZE> &buf) {
+  return std::basic_string<Char>(buf.data(), buf.size());
 }
 
-inline format_context::iterator vformat_to(internal::buffer &buf, string_view format_str, format_args args)
-{
-    typedef back_insert_range<internal::buffer> range;
-    return vformat_to<arg_formatter<range>>(buf, format_str, args);
+inline format_context::iterator vformat_to(
+    internal::buffer &buf, string_view format_str, format_args args) {
+  typedef back_insert_range<internal::buffer> range;
+  return vformat_to<arg_formatter<range>>(buf, format_str, args);
 }
 
-inline wformat_context::iterator vformat_to(internal::wbuffer &buf, wstring_view format_str, wformat_args args)
-{
-    typedef back_insert_range<internal::wbuffer> range;
-    return vformat_to<arg_formatter<range>>(buf, format_str, args);
+inline wformat_context::iterator vformat_to(
+    internal::wbuffer &buf, wstring_view format_str, wformat_args args) {
+  typedef back_insert_range<internal::wbuffer> range;
+  return vformat_to<arg_formatter<range>>(buf, format_str, args);
 }
 
-template<typename... Args>
-inline format_context::iterator format_to(memory_buffer &buf, string_view format_str, const Args &... args)
-{
-    return vformat_to(buf, format_str, make_format_args(args...));
+template <typename... Args, std::size_t SIZE = inline_buffer_size>
+inline format_context::iterator format_to(
+    basic_memory_buffer<char, SIZE> &buf, string_view format_str,
+    const Args & ... args) {
+  return vformat_to(buf, format_str, make_format_args(args...));
 }
 
-template<typename... Args>
-inline wformat_context::iterator format_to(wmemory_buffer &buf, wstring_view format_str, const Args &... args)
-{
-    return vformat_to(buf, format_str, make_format_args<wformat_context>(args...));
+template <typename... Args, std::size_t SIZE = inline_buffer_size>
+inline wformat_context::iterator format_to(
+    basic_memory_buffer<wchar_t, SIZE> &buf, wstring_view format_str,
+    const Args & ... args) {
+  return vformat_to(buf, format_str, make_format_args<wformat_context>(args...));
 }
 
-template<typename OutputIt, typename Char = char>
-// using format_context_t = basic_format_context<OutputIt, Char>;
-struct format_context_t
-{
-    typedef basic_format_context<OutputIt, Char> type;
+template <typename OutputIt, typename Char = char>
+//using format_context_t = basic_format_context<OutputIt, Char>;
+struct format_context_t { typedef basic_format_context<OutputIt, Char> type; };
+
+template <typename OutputIt, typename Char = char>
+//using format_args_t = basic_format_args<format_context_t<OutputIt, Char>>;
+struct format_args_t {
+  typedef basic_format_args<
+    typename format_context_t<OutputIt, Char>::type> type;
 };
 
-template<typename OutputIt, typename Char = char>
-// using format_args_t = basic_format_args<format_context_t<OutputIt, Char>>;
-struct format_args_t
-{
-    typedef basic_format_args<typename format_context_t<OutputIt, Char>::type> type;
-};
-
-template<typename OutputIt, typename... Args>
-inline OutputIt vformat_to(OutputIt out, string_view format_str, typename format_args_t<OutputIt>::type args)
-{
-    typedef output_range<OutputIt, char> range;
-    return vformat_to<arg_formatter<range>>(range(out), format_str, args);
+template <typename OutputIt, typename... Args>
+inline OutputIt vformat_to(OutputIt out, string_view format_str,
+                           typename format_args_t<OutputIt>::type args) {
+  typedef output_range<OutputIt, char> range;
+  return vformat_to<arg_formatter<range>>(range(out), format_str, args);
+}
+template <typename OutputIt, typename... Args>
+inline OutputIt vformat_to(
+    OutputIt out, wstring_view format_str,
+    typename format_args_t<OutputIt, wchar_t>::type args) {
+  typedef output_range<OutputIt, wchar_t> range;
+  return vformat_to<arg_formatter<range>>(range(out), format_str, args);
 }
 
 /**
@@ -4288,35 +3513,59 @@ inline OutputIt vformat_to(OutputIt out, string_view format_str, typename format
    fmt::format_to(std::back_inserter(out), "{}", 42);
  \endrst
  */
-template<typename OutputIt, typename... Args>
-inline OutputIt format_to(OutputIt out, string_view format_str, const Args &... args)
-{
-    return vformat_to(out, format_str, make_format_args<typename format_context_t<OutputIt>::type>(args...));
+template <typename OutputIt, typename... Args>
+inline OutputIt format_to(OutputIt out, string_view format_str,
+                          const Args & ... args) {
+  return vformat_to(out, format_str,
+      make_format_args<typename format_context_t<OutputIt>::type>(args...));
 }
 
-template<typename Container, typename... Args>
-inline typename std::enable_if<is_contiguous<Container>::value, std::back_insert_iterator<Container>>::type format_to(
-    std::back_insert_iterator<Container> out, string_view format_str, const Args &... args)
-{
-    return vformat_to(out, format_str, make_format_args<format_context>(args...));
+template <typename Container, typename... Args>
+inline typename std::enable_if<
+  is_contiguous<Container>::value, std::back_insert_iterator<Container>>::type
+    format_to(std::back_insert_iterator<Container> out,
+              string_view format_str, const Args & ... args) {
+  return vformat_to(out, format_str, make_format_args<format_context>(args...));
 }
 
-template<typename Container, typename... Args>
-inline typename std::enable_if<is_contiguous<Container>::value, std::back_insert_iterator<Container>>::type format_to(
-    std::back_insert_iterator<Container> out, wstring_view format_str, const Args &... args)
-{
-    return vformat_to(out, format_str, make_format_args<wformat_context>(args...));
+template <typename Container, typename... Args>
+inline typename std::enable_if<
+  is_contiguous<Container>::value, std::back_insert_iterator<Container>>::type
+    format_to(std::back_insert_iterator<Container> out,
+              wstring_view format_str, const Args & ... args) {
+  return vformat_to(out, format_str, make_format_args<wformat_context>(args...));
 }
 
-template<typename OutputIt>
-struct format_to_n_result
-{
-    /** Iterator past the end of the output range. */
-    OutputIt out;
-    /** Total (not truncated) output size. */
-    std::size_t size;
+template <typename OutputIt>
+struct format_to_n_result {
+  /** Iterator past the end of the output range. */
+  OutputIt out;
+  /** Total (not truncated) output size. */
+  std::size_t size;
 };
 
+template <typename OutputIt>
+using format_to_n_context = typename fmt::format_context_t<
+  fmt::internal::truncating_iterator<OutputIt>>::type;
+
+template <typename OutputIt>
+using format_to_n_args = fmt::basic_format_args<format_to_n_context<OutputIt>>;
+
+template <typename OutputIt, typename ...Args>
+inline format_arg_store<format_to_n_context<OutputIt>, Args...>
+    make_format_to_n_args(const Args & ... args) {
+  return format_arg_store<format_to_n_context<OutputIt>, Args...>(args...);
+}
+
+template <typename OutputIt, typename... Args>
+inline format_to_n_result<OutputIt> vformat_to_n(
+    OutputIt out, std::size_t n, string_view format_str,
+    format_to_n_args<OutputIt> args) {
+  typedef internal::truncating_iterator<OutputIt> It;
+  auto it = vformat_to(It(out, n), format_str, args);
+  return {it.base(), it.count()};
+}
+
 /**
  \rst
  Formats arguments, writes up to ``n`` characters of the result to the output
@@ -4324,108 +3573,298 @@ struct format_to_n_result
  of the output range.
  \endrst
  */
-template<typename OutputIt, typename... Args>
-inline format_to_n_result<OutputIt> format_to_n(OutputIt out, std::size_t n, string_view format_str, const Args &... args)
-{
-    typedef internal::truncating_iterator<OutputIt> It;
-    auto it = vformat_to(It(out, n), format_str, make_format_args<typename format_context_t<It>::type>(args...));
-    return {it.base(), it.count()};
+template <typename OutputIt, typename... Args>
+inline format_to_n_result<OutputIt> format_to_n(
+    OutputIt out, std::size_t n, string_view format_str, const Args &... args) {
+  return vformat_to_n<OutputIt>(
+    out, n, format_str, make_format_to_n_args<OutputIt>(args...));
+}
+template <typename OutputIt, typename... Args>
+inline format_to_n_result<OutputIt> format_to_n(
+    OutputIt out, std::size_t n, wstring_view format_str, const Args &... args) {
+  typedef internal::truncating_iterator<OutputIt> It;
+  auto it = vformat_to(It(out, n), format_str,
+      make_format_args<typename format_context_t<It, wchar_t>::type>(args...));
+  return {it.base(), it.count()};
 }
 
-inline std::string vformat(string_view format_str, format_args args)
-{
-    memory_buffer buffer;
-    vformat_to(buffer, format_str, args);
-    return fmt::to_string(buffer);
+inline std::string vformat(string_view format_str, format_args args) {
+  memory_buffer buffer;
+  vformat_to(buffer, format_str, args);
+  return fmt::to_string(buffer);
 }
 
-inline std::wstring vformat(wstring_view format_str, wformat_args args)
-{
-    wmemory_buffer buffer;
-    vformat_to(buffer, format_str, args);
-    return to_string(buffer);
+inline std::wstring vformat(wstring_view format_str, wformat_args args) {
+  wmemory_buffer buffer;
+  vformat_to(buffer, format_str, args);
+  return to_string(buffer);
 }
 
-template<typename String, typename... Args>
-inline typename std::enable_if<internal::is_format_string<String>::value, std::string>::type format(String format_str, const Args &... args)
-{
-    internal::check_format_string<Args...>(format_str);
-    return vformat(format_str.data(), make_format_args(args...));
+template <typename String, typename... Args>
+inline typename std::enable_if<
+  internal::is_format_string<String>::value, std::string>::type
+    format(String format_str, const Args & ... args) {
+  internal::check_format_string<Args...>(format_str);
+  return vformat(format_str.data(), make_format_args(args...));
 }
 
-template<typename String, typename... Args>
-inline typename std::enable_if<internal::is_format_string<String>::value>::type print(String format_str, const Args &... args)
-{
-    internal::check_format_string<Args...>(format_str);
-    return vprint(format_str.data(), make_format_args(args...));
+template <typename String, typename... Args>
+inline typename std::enable_if<internal::is_format_string<String>::value>::type
+    print(String format_str, const Args & ... args) {
+  internal::check_format_string<Args...>(format_str);
+  return vprint(format_str.data(), make_format_args(args...));
 }
 
 /**
- Returns the number of characters in the output of
- ``format(format_str, args...)``.
+  Returns the number of characters in the output of
+  ``format(format_str, args...)``.
  */
-template<typename... Args>
-inline std::size_t formatted_size(string_view format_str, const Args &... args)
-{
-    auto it = format_to(internal::counting_iterator<char>(), format_str, args...);
-    return it.count();
+template <typename... Args>
+inline std::size_t formatted_size(string_view format_str,
+                                  const Args & ... args) {
+  auto it = format_to(internal::counting_iterator<char>(), format_str, args...);
+  return it.count();
 }
 
+// Experimental color support.
+#ifdef FMT_EXTENDED_COLORS
+enum class color : uint32_t {
+  alice_blue              = 0xF0F8FF, // rgb(240,248,255)
+  antique_white           = 0xFAEBD7, // rgb(250,235,215)
+  aqua                    = 0x00FFFF, // rgb(0,255,255)
+  aquamarine              = 0x7FFFD4, // rgb(127,255,212)
+  azure                   = 0xF0FFFF, // rgb(240,255,255)
+  beige                   = 0xF5F5DC, // rgb(245,245,220)
+  bisque                  = 0xFFE4C4, // rgb(255,228,196)
+  black                   = 0x000000, // rgb(0,0,0)
+  blanched_almond         = 0xFFEBCD, // rgb(255,235,205)
+  blue                    = 0x0000FF, // rgb(0,0,255)
+  blue_violet             = 0x8A2BE2, // rgb(138,43,226)
+  brown                   = 0xA52A2A, // rgb(165,42,42)
+  burly_wood              = 0xDEB887, // rgb(222,184,135)
+  cadet_blue              = 0x5F9EA0, // rgb(95,158,160)
+  chartreuse              = 0x7FFF00, // rgb(127,255,0)
+  chocolate               = 0xD2691E, // rgb(210,105,30)
+  coral                   = 0xFF7F50, // rgb(255,127,80)
+  cornflower_blue         = 0x6495ED, // rgb(100,149,237)
+  cornsilk                = 0xFFF8DC, // rgb(255,248,220)
+  crimson                 = 0xDC143C, // rgb(220,20,60)
+  cyan                    = 0x00FFFF, // rgb(0,255,255)
+  dark_blue               = 0x00008B, // rgb(0,0,139)
+  dark_cyan               = 0x008B8B, // rgb(0,139,139)
+  dark_golden_rod         = 0xB8860B, // rgb(184,134,11)
+  dark_gray               = 0xA9A9A9, // rgb(169,169,169)
+  dark_green              = 0x006400, // rgb(0,100,0)
+  dark_khaki              = 0xBDB76B, // rgb(189,183,107)
+  dark_magenta            = 0x8B008B, // rgb(139,0,139)
+  dark_olive_green        = 0x556B2F, // rgb(85,107,47)
+  dark_orange             = 0xFF8C00, // rgb(255,140,0)
+  dark_orchid             = 0x9932CC, // rgb(153,50,204)
+  dark_red                = 0x8B0000, // rgb(139,0,0)
+  dark_salmon             = 0xE9967A, // rgb(233,150,122)
+  dark_sea_green          = 0x8FBC8F, // rgb(143,188,143)
+  dark_slate_blue         = 0x483D8B, // rgb(72,61,139)
+  dark_slate_gray         = 0x2F4F4F, // rgb(47,79,79)
+  dark_turquoise          = 0x00CED1, // rgb(0,206,209)
+  dark_violet             = 0x9400D3, // rgb(148,0,211)
+  deep_pink               = 0xFF1493, // rgb(255,20,147)
+  deep_sky_blue           = 0x00BFFF, // rgb(0,191,255)
+  dim_gray                = 0x696969, // rgb(105,105,105)
+  dodger_blue             = 0x1E90FF, // rgb(30,144,255)
+  fire_brick              = 0xB22222, // rgb(178,34,34)
+  floral_white            = 0xFFFAF0, // rgb(255,250,240)
+  forest_green            = 0x228B22, // rgb(34,139,34)
+  fuchsia                 = 0xFF00FF, // rgb(255,0,255)
+  gainsboro               = 0xDCDCDC, // rgb(220,220,220)
+  ghost_white             = 0xF8F8FF, // rgb(248,248,255)
+  gold                    = 0xFFD700, // rgb(255,215,0)
+  golden_rod              = 0xDAA520, // rgb(218,165,32)
+  gray                    = 0x808080, // rgb(128,128,128)
+  green                   = 0x008000, // rgb(0,128,0)
+  green_yellow            = 0xADFF2F, // rgb(173,255,47)
+  honey_dew               = 0xF0FFF0, // rgb(240,255,240)
+  hot_pink                = 0xFF69B4, // rgb(255,105,180)
+  indian_red              = 0xCD5C5C, // rgb(205,92,92)
+  indigo                  = 0x4B0082, // rgb(75,0,130)
+  ivory                   = 0xFFFFF0, // rgb(255,255,240)
+  khaki                   = 0xF0E68C, // rgb(240,230,140)
+  lavender                = 0xE6E6FA, // rgb(230,230,250)
+  lavender_blush          = 0xFFF0F5, // rgb(255,240,245)
+  lawn_green              = 0x7CFC00, // rgb(124,252,0)
+  lemon_chiffon           = 0xFFFACD, // rgb(255,250,205)
+  light_blue              = 0xADD8E6, // rgb(173,216,230)
+  light_coral             = 0xF08080, // rgb(240,128,128)
+  light_cyan              = 0xE0FFFF, // rgb(224,255,255)
+  light_golden_rod_yellow = 0xFAFAD2, // rgb(250,250,210)
+  light_gray              = 0xD3D3D3, // rgb(211,211,211)
+  light_green             = 0x90EE90, // rgb(144,238,144)
+  light_pink              = 0xFFB6C1, // rgb(255,182,193)
+  light_salmon            = 0xFFA07A, // rgb(255,160,122)
+  light_sea_green         = 0x20B2AA, // rgb(32,178,170)
+  light_sky_blue          = 0x87CEFA, // rgb(135,206,250)
+  light_slate_gray        = 0x778899, // rgb(119,136,153)
+  light_steel_blue        = 0xB0C4DE, // rgb(176,196,222)
+  light_yellow            = 0xFFFFE0, // rgb(255,255,224)
+  lime                    = 0x00FF00, // rgb(0,255,0)
+  lime_green              = 0x32CD32, // rgb(50,205,50)
+  linen                   = 0xFAF0E6, // rgb(250,240,230)
+  magenta                 = 0xFF00FF, // rgb(255,0,255)
+  maroon                  = 0x800000, // rgb(128,0,0)
+  medium_aquamarine       = 0x66CDAA, // rgb(102,205,170)
+  medium_blue             = 0x0000CD, // rgb(0,0,205)
+  medium_orchid           = 0xBA55D3, // rgb(186,85,211)
+  medium_purple           = 0x9370DB, // rgb(147,112,219)
+  medium_sea_green        = 0x3CB371, // rgb(60,179,113)
+  medium_slate_blue       = 0x7B68EE, // rgb(123,104,238)
+  medium_spring_green     = 0x00FA9A, // rgb(0,250,154)
+  medium_turquoise        = 0x48D1CC, // rgb(72,209,204)
+  medium_violet_red       = 0xC71585, // rgb(199,21,133)
+  midnight_blue           = 0x191970, // rgb(25,25,112)
+  mint_cream              = 0xF5FFFA, // rgb(245,255,250)
+  misty_rose              = 0xFFE4E1, // rgb(255,228,225)
+  moccasin                = 0xFFE4B5, // rgb(255,228,181)
+  navajo_white            = 0xFFDEAD, // rgb(255,222,173)
+  navy                    = 0x000080, // rgb(0,0,128)
+  old_lace                = 0xFDF5E6, // rgb(253,245,230)
+  olive                   = 0x808000, // rgb(128,128,0)
+  olive_drab              = 0x6B8E23, // rgb(107,142,35)
+  orange                  = 0xFFA500, // rgb(255,165,0)
+  orange_red              = 0xFF4500, // rgb(255,69,0)
+  orchid                  = 0xDA70D6, // rgb(218,112,214)
+  pale_golden_rod         = 0xEEE8AA, // rgb(238,232,170)
+  pale_green              = 0x98FB98, // rgb(152,251,152)
+  pale_turquoise          = 0xAFEEEE, // rgb(175,238,238)
+  pale_violet_red         = 0xDB7093, // rgb(219,112,147)
+  papaya_whip             = 0xFFEFD5, // rgb(255,239,213)
+  peach_puff              = 0xFFDAB9, // rgb(255,218,185)
+  peru                    = 0xCD853F, // rgb(205,133,63)
+  pink                    = 0xFFC0CB, // rgb(255,192,203)
+  plum                    = 0xDDA0DD, // rgb(221,160,221)
+  powder_blue             = 0xB0E0E6, // rgb(176,224,230)
+  purple                  = 0x800080, // rgb(128,0,128)
+  rebecca_purple          = 0x663399, // rgb(102,51,153)
+  red                     = 0xFF0000, // rgb(255,0,0)
+  rosy_brown              = 0xBC8F8F, // rgb(188,143,143)
+  royal_blue              = 0x4169E1, // rgb(65,105,225)
+  saddle_brown            = 0x8B4513, // rgb(139,69,19)
+  salmon                  = 0xFA8072, // rgb(250,128,114)
+  sandy_brown             = 0xF4A460, // rgb(244,164,96)
+  sea_green               = 0x2E8B57, // rgb(46,139,87)
+  sea_shell               = 0xFFF5EE, // rgb(255,245,238)
+  sienna                  = 0xA0522D, // rgb(160,82,45)
+  silver                  = 0xC0C0C0, // rgb(192,192,192)
+  sky_blue                = 0x87CEEB, // rgb(135,206,235)
+  slate_blue              = 0x6A5ACD, // rgb(106,90,205)
+  slate_gray              = 0x708090, // rgb(112,128,144)
+  snow                    = 0xFFFAFA, // rgb(255,250,250)
+  spring_green            = 0x00FF7F, // rgb(0,255,127)
+  steel_blue              = 0x4682B4, // rgb(70,130,180)
+  tan                     = 0xD2B48C, // rgb(210,180,140)
+  teal                    = 0x008080, // rgb(0,128,128)
+  thistle                 = 0xD8BFD8, // rgb(216,191,216)
+  tomato                  = 0xFF6347, // rgb(255,99,71)
+  turquoise               = 0x40E0D0, // rgb(64,224,208)
+  violet                  = 0xEE82EE, // rgb(238,130,238)
+  wheat                   = 0xF5DEB3, // rgb(245,222,179)
+  white                   = 0xFFFFFF, // rgb(255,255,255)
+  white_smoke             = 0xF5F5F5, // rgb(245,245,245)
+  yellow                  = 0xFFFF00, // rgb(255,255,0)
+  yellow_green            = 0x9ACD32, // rgb(154,205,50)
+};  // enum class color
+
+// rgb is a struct for red, green and blue colors.
+// We use rgb as name because some editors will show it as color direct in the
+// editor.
+struct rgb {
+  FMT_CONSTEXPR_DECL rgb() : r(0), g(0), b(0) {}
+  FMT_CONSTEXPR_DECL rgb(uint8_t r_, uint8_t g_, uint8_t b_)
+    : r(r_), g(g_), b(b_) {}
+  FMT_CONSTEXPR_DECL rgb(uint32_t hex)
+    : r((hex >> 16) & 0xFF), g((hex >> 8) & 0xFF), b((hex) & 0xFF) {}
+  FMT_CONSTEXPR_DECL rgb(color hex)
+    : r((uint32_t(hex) >> 16) & 0xFF), g((uint32_t(hex) >> 8) & 0xFF),
+      b(uint32_t(hex) & 0xFF) {}
+  uint8_t r;
+  uint8_t g;
+  uint8_t b;
+};
+
+void vprint_rgb(rgb fd, string_view format, format_args args);
+void vprint_rgb(rgb fd, rgb bg, string_view format, format_args args);
+
+/**
+  Formats a string and prints it to stdout using ANSI escape sequences to
+  specify foreground color 'fd'.
+  Example:
+    fmt::print(fmt::color::red, "Elapsed time: {0:.2f} seconds", 1.23);
+ */
+template <typename... Args>
+inline void print(rgb fd, string_view format_str, const Args & ... args) {
+  vprint_rgb(fd, format_str, make_format_args(args...));
+}
+
+/**
+  Formats a string and prints it to stdout using ANSI escape sequences to
+  specify foreground color 'fd' and background color 'bg'.
+  Example:
+    fmt::print(fmt::color::red, fmt::color::black, "Elapsed time: {0:.2f} seconds", 1.23);
+ */
+template <typename... Args>
+inline void print(rgb fd, rgb bg, string_view format_str, const Args & ... args) {
+  vprint_rgb(fd, bg, format_str, make_format_args(args...));
+}
+#endif  // FMT_EXTENDED_COLORS
+
 #if FMT_USE_USER_DEFINED_LITERALS
 namespace internal {
 
-#if FMT_UDL_TEMPLATE
-template<typename Char, Char... CHARS>
-class udl_formatter
-{
-public:
-    template<typename... Args>
-    std::basic_string<Char> operator()(const Args &... args) const
-    {
-        FMT_CONSTEXPR_DECL Char s[] = {CHARS..., '\0'};
-        FMT_CONSTEXPR_DECL bool invalid_format =
-            check_format_string<Char, error_handler, Args...>(basic_string_view<Char>(s, sizeof...(CHARS)));
-        (void)invalid_format;
-        return format(s, args...);
-    }
+# if FMT_UDL_TEMPLATE
+template <typename Char, Char... CHARS>
+class udl_formatter {
+ public:
+  template <typename... Args>
+  std::basic_string<Char> operator()(const Args &... args) const {
+    FMT_CONSTEXPR_DECL Char s[] = {CHARS..., '\0'};
+    FMT_CONSTEXPR_DECL bool invalid_format =
+        check_format_string<Char, error_handler, Args...>(
+          basic_string_view<Char>(s, sizeof...(CHARS)));
+    (void)invalid_format;
+    return format(s, args...);
+  }
 };
-#else
-template<typename Char>
-struct udl_formatter
-{
-    const Char *str;
+# else
+template <typename Char>
+struct udl_formatter {
+  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... Args>
+  auto operator()(Args && ... args) const
+                  -> decltype(format(str, std::forward<Args>(args)...)) {
+    return format(str, std::forward<Args>(args)...);
+  }
 };
-#endif // FMT_UDL_TEMPLATE
+# endif // FMT_UDL_TEMPLATE
 
-template<typename Char>
-struct udl_arg
-{
-    const Char *str;
+template <typename Char>
+struct udl_arg {
+  const Char *str;
 
-    template<typename T>
-    named_arg<T, Char> operator=(T &&value) const
-    {
-        return {str, std::forward<T>(value)};
-    }
+  template <typename T>
+  named_arg<T, Char> operator=(T &&value) const {
+    return {str, std::forward<T>(value)};
+  }
 };
 
 } // namespace internal
 
 inline namespace literals {
 
-#if FMT_UDL_TEMPLATE
-template<typename Char, Char... CHARS>
-FMT_CONSTEXPR internal::udl_formatter<Char, CHARS...> operator""_format()
-{
-    return {};
+# if FMT_UDL_TEMPLATE
+template <typename Char, Char... CHARS>
+FMT_CONSTEXPR internal::udl_formatter<Char, CHARS...> operator""_format() {
+  return {};
 }
-#else
+# else
 /**
   \rst
   User-defined literal equivalent of :func:`fmt::format`.
@@ -4436,15 +3875,11 @@ FMT_CONSTEXPR internal::udl_formatter<Char, CHARS...> operator""_format()
     std::string message = "The answer is {}"_format(42);
   \endrst
  */
-inline internal::udl_formatter<char> operator"" _format(const char *s, std::size_t)
-{
-    return {s};
-}
-inline internal::udl_formatter<wchar_t> operator"" _format(const wchar_t *s, std::size_t)
-{
-    return {s};
-}
-#endif // FMT_UDL_TEMPLATE
+inline internal::udl_formatter<char>
+operator"" _format(const char *s, std::size_t) { return {s}; }
+inline internal::udl_formatter<wchar_t>
+operator"" _format(const wchar_t *s, std::size_t) { return {s}; }
+# endif // FMT_UDL_TEMPLATE
 
 /**
   \rst
@@ -4456,33 +3891,21 @@ inline internal::udl_formatter<wchar_t> operator"" _format(const wchar_t *s, std
     fmt::print("Elapsed time: {s:.2f} seconds", "s"_a=1.23);
   \endrst
  */
-inline internal::udl_arg<char> operator"" _a(const char *s, std::size_t)
-{
-    return {s};
-}
-inline internal::udl_arg<wchar_t> operator"" _a(const wchar_t *s, std::size_t)
-{
-    return {s};
-}
-} // namespace literals
+inline internal::udl_arg<char>
+operator"" _a(const char *s, std::size_t) { return {s}; }
+inline internal::udl_arg<wchar_t>
+operator"" _a(const wchar_t *s, std::size_t) { return {s}; }
+} // inline namespace literals
 #endif // FMT_USE_USER_DEFINED_LITERALS
 FMT_END_NAMESPACE
 
-#define FMT_STRING(s)                                                                                                                      \
-    [] {                                                                                                                                   \
-        struct S : fmt::format_string                                                                                                      \
-        {                                                                                                                                  \
-            static FMT_CONSTEXPR decltype(s) data()                                                                                        \
-            {                                                                                                                              \
-                return s;                                                                                                                  \
-            }                                                                                                                              \
-            static FMT_CONSTEXPR size_t size()                                                                                             \
-            {                                                                                                                              \
-                return sizeof(s);                                                                                                          \
-            }                                                                                                                              \
-        };                                                                                                                                 \
-        return S{};                                                                                                                        \
-    }()
+#define FMT_STRING(s) [] { \
+    struct S : fmt::format_string { \
+      static FMT_CONSTEXPR decltype(s) data() { return s; } \
+      static FMT_CONSTEXPR size_t size() { return sizeof(s); } \
+    }; \
+    return S{}; \
+  }()
 
 #ifndef FMT_NO_FMT_STRING_ALIAS
 /**
@@ -4496,19 +3919,19 @@ FMT_END_NAMESPACE
     std::string s = format(fmt("{:d}"), "foo");
   \endrst
  */
-#define fmt(s) FMT_STRING(s)
+# define fmt(s) FMT_STRING(s)
 #endif
 
 #ifdef FMT_HEADER_ONLY
-#define FMT_FUNC inline
-#include "format-inl.h"
+# define FMT_FUNC inline
+# include "format-inl.h"
 #else
-#define FMT_FUNC
+# define FMT_FUNC
 #endif
 
 // Restore warnings.
 #if FMT_GCC_VERSION >= 406 || FMT_CLANG_VERSION
-#pragma GCC diagnostic pop
+# pragma GCC diagnostic pop
 #endif
 
-#endif // FMT_FORMAT_H_
+#endif  // FMT_FORMAT_H_
diff --git a/include/spdlog/fmt/bundled/ostream.h b/include/spdlog/fmt/bundled/ostream.h
index df7b03d5..94f18834 100644
--- a/include/spdlog/fmt/bundled/ostream.h
+++ b/include/spdlog/fmt/bundled/ostream.h
@@ -14,137 +14,128 @@
 FMT_BEGIN_NAMESPACE
 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;
+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;
 
-    basic_buffer<Char> &buffer_;
+  basic_buffer<Char> &buffer_;
 
-public:
-    formatbuf(basic_buffer<Char> &buffer)
-        : buffer_(buffer)
-    {
-    }
+ public:
+  formatbuf(basic_buffer<Char> &buffer) : buffer_(buffer) {}
 
-protected:
-    // The put-area is actually always empty. This makes the implementation
-    // simpler and has the advantage that the streambuf and the buffer are always
-    // in sync and sputc never writes into uninitialized memory. The obvious
-    // disadvantage is that each call to sputc always results in a (virtual) call
-    // to overflow. There is no disadvantage here for sputn since this always
-    // results in a call to xsputn.
+ protected:
+  // The put-area is actually always empty. This makes the implementation
+  // simpler and has the advantage that the streambuf and the buffer are always
+  // in sync and sputc never writes into uninitialized memory. The obvious
+  // disadvantage is that each call to sputc always results in a (virtual) call
+  // to overflow. There is no disadvantage here for sputn since this always
+  // results in a call to xsputn.
 
-    int_type overflow(int_type ch = traits_type::eof()) FMT_OVERRIDE
-    {
-        if (!traits_type::eq_int_type(ch, traits_type::eof()))
-            buffer_.push_back(static_cast<Char>(ch));
-        return ch;
-    }
+  int_type overflow(int_type ch = traits_type::eof()) FMT_OVERRIDE {
+    if (!traits_type::eq_int_type(ch, traits_type::eof()))
+      buffer_.push_back(static_cast<Char>(ch));
+    return ch;
+  }
 
-    std::streamsize xsputn(const Char *s, std::streamsize count) FMT_OVERRIDE
-    {
-        buffer_.append(s, s + count);
-        return count;
-    }
+  std::streamsize xsputn(const Char *s, std::streamsize count) FMT_OVERRIDE {
+    buffer_.append(s, s + count);
+    return count;
+  }
 };
 
-template<typename Char>
-struct test_stream : std::basic_ostream<Char>
-{
-private:
-    struct null;
-    // Hide all operator<< from std::basic_ostream<Char>.
-    void operator<<(null);
+template <typename Char>
+struct test_stream : std::basic_ostream<Char> {
+ private:
+  struct null;
+  // Hide all operator<< from std::basic_ostream<Char>.
+  void operator<<(null);
 };
 
 // Checks if T has a user-defined operator<< (e.g. not a member of std::ostream).
-template<typename T, typename Char>
-class is_streamable
-{
-private:
-    template<typename U>
-    static decltype(internal::declval<test_stream<Char> &>() << internal::declval<U>(), std::true_type()) test(int);
+template <typename T, typename Char>
+class is_streamable {
+ private:
+  template <typename U>
+  static decltype(
+    internal::declval<test_stream<Char>&>()
+      << internal::declval<U>(), std::true_type()) test(int);
 
-    template<typename>
-    static std::false_type test(...);
+  template <typename>
+  static std::false_type test(...);
 
-    typedef decltype(test<T>(0)) result;
+  typedef decltype(test<T>(0)) result;
 
-public:
-    // std::string operator<< is not considered user-defined because we handle strings
-    // specially.
-    static const bool value = result::value && !std::is_same<T, std::string>::value;
+ public:
+  // std::string operator<< is not considered user-defined because we handle strings
+  // specially.
+  static const bool value = result::value && !std::is_same<T, std::string>::value;
 };
 
 // Disable conversion to int if T has an overloaded operator<< which is a free
 // function (not a member of std::ostream).
-template<typename T, typename Char>
-class convert_to_int<T, Char, true>
-{
-public:
-    static const bool value = convert_to_int<T, Char, false>::value && !is_streamable<T, Char>::value;
+template <typename T, typename Char>
+class convert_to_int<T, Char, true> {
+ public:
+  static const bool value =
+    convert_to_int<T, Char, false>::value && !is_streamable<T, Char>::value;
 };
 
 // Write the content of buf to os.
-template<typename Char>
-void write(std::basic_ostream<Char> &os, basic_buffer<Char> &buf)
-{
-    const Char *data = buf.data();
-    typedef std::make_unsigned<std::streamsize>::type UnsignedStreamSize;
-    UnsignedStreamSize size = buf.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);
+template <typename Char>
+void write(std::basic_ostream<Char> &os, basic_buffer<Char> &buf) {
+  const Char *data = buf.data();
+  typedef std::make_unsigned<std::streamsize>::type UnsignedStreamSize;
+  UnsignedStreamSize size = buf.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);
 }
 
-template<typename Char, typename T>
-void format_value(basic_buffer<Char> &buffer, const T &value)
-{
-    internal::formatbuf<Char> format_buf(buffer);
-    std::basic_ostream<Char> output(&format_buf);
-    output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
-    output << value;
-    buffer.resize(buffer.size());
+template <typename Char, typename T>
+void format_value(basic_buffer<Char> &buffer, const T &value) {
+  internal::formatbuf<Char> format_buf(buffer);
+  std::basic_ostream<Char> output(&format_buf);
+  output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
+  output << value;
+  buffer.resize(buffer.size());
 }
 
 // Disable builtin formatting of enums and use operator<< instead.
-template<typename T>
-struct format_enum<T, typename std::enable_if<std::is_enum<T>::value>::type> : std::false_type
-{
-};
-} // namespace internal
+template <typename T>
+struct format_enum<T,
+    typename std::enable_if<std::is_enum<T>::value>::type> : std::false_type {};
+}  // namespace internal
 
 // Formats an object of type T that has an overloaded ostream operator<<.
-template<typename T, typename Char>
-struct formatter<T, Char, typename std::enable_if<internal::is_streamable<T, Char>::value>::type> : formatter<basic_string_view<Char>, Char>
-{
+template <typename T, typename Char>
+struct formatter<T, Char,
+    typename std::enable_if<internal::is_streamable<T, Char>::value>::type>
+    : formatter<basic_string_view<Char>, Char> {
 
-    template<typename Context>
-    auto format(const T &value, Context &ctx) -> decltype(ctx.out())
-    {
-        basic_memory_buffer<Char> buffer;
-        internal::format_value(buffer, value);
-        basic_string_view<Char> str(buffer.data(), buffer.size());
-        formatter<basic_string_view<Char>, Char>::format(str, ctx);
-        return ctx.out();
-    }
+  template <typename Context>
+  auto format(const T &value, Context &ctx) -> decltype(ctx.out()) {
+    basic_memory_buffer<Char> buffer;
+    internal::format_value(buffer, value);
+    basic_string_view<Char> str(buffer.data(), buffer.size());
+    formatter<basic_string_view<Char>, Char>::format(str, ctx);
+    return ctx.out();
+  }
 };
 
-template<typename Char>
-inline void vprint(
-    std::basic_ostream<Char> &os, basic_string_view<Char> format_str, basic_format_args<typename buffer_context<Char>::type> args)
-{
-    basic_memory_buffer<Char> buffer;
-    vformat_to(buffer, format_str, args);
-    internal::write(os, buffer);
+template <typename Char>
+inline void vprint(std::basic_ostream<Char> &os,
+                   basic_string_view<Char> format_str,
+                   basic_format_args<typename buffer_context<Char>::type> args) {
+  basic_memory_buffer<Char> buffer;
+  vformat_to(buffer, format_str, args);
+  internal::write(os, buffer);
 }
 /**
   \rst
@@ -155,17 +146,17 @@ inline void vprint(
     fmt::print(cerr, "Don't {}!", "panic");
   \endrst
  */
-template<typename... Args>
-inline void print(std::ostream &os, string_view format_str, const Args &... args)
-{
-    vprint<char>(os, format_str, make_format_args<format_context>(args...));
+template <typename... Args>
+inline void print(std::ostream &os, string_view format_str,
+                  const Args & ... args) {
+  vprint<char>(os, format_str, make_format_args<format_context>(args...));
 }
 
-template<typename... Args>
-inline void print(std::wostream &os, wstring_view format_str, const Args &... args)
-{
-    vprint<wchar_t>(os, format_str, make_format_args<wformat_context>(args...));
+template <typename... Args>
+inline void print(std::wostream &os, wstring_view format_str,
+                  const Args & ... args) {
+  vprint<wchar_t>(os, format_str, make_format_args<wformat_context>(args...));
 }
 FMT_END_NAMESPACE
 
-#endif // FMT_OSTREAM_H_
+#endif  // FMT_OSTREAM_H_
diff --git a/include/spdlog/fmt/bundled/posix.h b/include/spdlog/fmt/bundled/posix.h
index 20c75899..8682d716 100644
--- a/include/spdlog/fmt/bundled/posix.h
+++ b/include/spdlog/fmt/bundled/posix.h
@@ -10,55 +10,54 @@
 
 #if defined(__MINGW32__) || defined(__CYGWIN__)
 // Workaround MinGW bug https://sourceforge.net/p/mingw/bugs/2024/.
-#undef __STRICT_ANSI__
+# undef __STRICT_ANSI__
 #endif
 
 #include <errno.h>
-#include <fcntl.h>  // for O_RDONLY
-#include <locale.h> // for locale_t
+#include <fcntl.h>   // for O_RDONLY
+#include <locale.h>  // for locale_t
 #include <stdio.h>
-#include <stdlib.h> // for strtod_l
+#include <stdlib.h>  // for strtod_l
 
 #include <cstddef>
 
 #if defined __APPLE__ || defined(__FreeBSD__)
-#include <xlocale.h> // for LC_NUMERIC_MASK on OS X
+# include <xlocale.h>  // for LC_NUMERIC_MASK on OS X
 #endif
 
 #include "format.h"
 
 #ifndef FMT_POSIX
-#if defined(_WIN32) && !defined(__MINGW32__)
+# if defined(_WIN32) && !defined(__MINGW32__)
 // Fix warnings about deprecated symbols.
-#define FMT_POSIX(call) _##call
-#else
-#define FMT_POSIX(call) call
-#endif
+#  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)
+# define FMT_POSIX_CALL(call) FMT_SYSTEM(call)
 #else
-#define FMT_SYSTEM(call) call
-#ifdef _WIN32
+# 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
+#  define FMT_POSIX_CALL(call) ::_##call
+# else
+#  define FMT_POSIX_CALL(call) ::call
+# endif
 #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)
+# 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)
+# define FMT_RETRY_VAL(result, expression, error_result) result = (expression)
 #endif
 
 #define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1)
@@ -90,167 +89,137 @@ FMT_BEGIN_NAMESPACE
     format(std::string("{}"), 42);
   \endrst
  */
-template<typename Char>
-class basic_cstring_view
-{
-private:
-    const Char *data_;
+template <typename Char>
+class basic_cstring_view {
+ private:
+  const Char *data_;
 
-public:
-    /** Constructs a string reference object from a C string. */
-    basic_cstring_view(const Char *s)
-        : data_(s)
-    {
-    }
+ public:
+  /** Constructs a string reference object from a C string. */
+  basic_cstring_view(const Char *s) : data_(s) {}
 
-    /**
-      \rst
-      Constructs a string reference from an ``std::string`` object.
-      \endrst
-     */
-    basic_cstring_view(const std::basic_string<Char> &s)
-        : data_(s.c_str())
-    {
-    }
+  /**
+    \rst
+    Constructs a string reference from an ``std::string`` object.
+    \endrst
+   */
+  basic_cstring_view(const std::basic_string<Char> &s) : data_(s.c_str()) {}
 
-    /** Returns the pointer to a C string. */
-    const Char *c_str() const
-    {
-        return data_;
-    }
+  /** Returns the pointer to a C string. */
+  const Char *c_str() const { return data_; }
 };
 
 typedef basic_cstring_view<char> cstring_view;
 typedef basic_cstring_view<wchar_t> wcstring_view;
 
 // An error code.
-class error_code
-{
-private:
-    int value_;
+class error_code {
+ private:
+  int value_;
 
-public:
-    explicit error_code(int value = 0) FMT_NOEXCEPT : value_(value) {}
+ public:
+  explicit error_code(int value = 0) FMT_NOEXCEPT : value_(value) {}
 
-    int get() const FMT_NOEXCEPT
-    {
-        return value_;
-    }
+  int get() const FMT_NOEXCEPT { return value_; }
 };
 
 // A buffered file.
-class buffered_file
-{
-private:
-    FILE *file_;
+class buffered_file {
+ private:
+  FILE *file_;
 
-    friend class file;
+  friend class file;
 
-    explicit buffered_file(FILE *f)
-        : file_(f)
-    {
-    }
+  explicit buffered_file(FILE *f) : file_(f) {}
 
-public:
-    // Constructs a buffered_file object which doesn't represent any file.
-    buffered_file() FMT_NOEXCEPT : file_(FMT_NULL) {}
+ public:
+  // Constructs a buffered_file object which doesn't represent any file.
+  buffered_file() FMT_NOEXCEPT : file_(FMT_NULL) {}
 
-    // Destroys the object closing the file it represents if any.
-    FMT_API ~buffered_file() FMT_DTOR_NOEXCEPT;
+  // Destroys the object closing the file it represents if any.
+  FMT_API ~buffered_file() FMT_DTOR_NOEXCEPT;
 
 #if !FMT_USE_RVALUE_REFERENCES
-    // Emulate a move constructor and a move assignment operator if rvalue
-    // references are not supported.
+  // 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;
-    };
+ 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.
-    buffered_file(Proxy p) FMT_NOEXCEPT : file_(p.file) {}
+  // A "move constructor" for moving from a temporary.
+  buffered_file(Proxy p) FMT_NOEXCEPT : file_(p.file) {}
 
-    // A "move constructor" for moving from an lvalue.
-    buffered_file(buffered_file &f) FMT_NOEXCEPT : file_(f.file_)
-    {
-        f.file_ = FMT_NULL;
-    }
+  // A "move constructor" for moving from an lvalue.
+  buffered_file(buffered_file &f) FMT_NOEXCEPT : file_(f.file_) {
+    f.file_ = FMT_NULL;
+  }
 
-    // A "move assignment operator" for moving from a temporary.
-    buffered_file &operator=(Proxy p)
-    {
-        close();
-        file_ = p.file;
-        return *this;
-    }
+  // A "move assignment operator" for moving from a temporary.
+  buffered_file &operator=(Proxy p) {
+    close();
+    file_ = p.file;
+    return *this;
+  }
 
-    // A "move assignment operator" for moving from an lvalue.
-    buffered_file &operator=(buffered_file &other)
-    {
-        close();
-        file_ = other.file_;
-        other.file_ = FMT_NULL;
-        return *this;
-    }
+  // A "move assignment operator" for moving from an lvalue.
+  buffered_file &operator=(buffered_file &other) {
+    close();
+    file_ = other.file_;
+    other.file_ = FMT_NULL;
+    return *this;
+  }
 
-    // Returns a proxy object for moving from a temporary:
-    //   buffered_file file = buffered_file(...);
-    operator Proxy() FMT_NOEXCEPT
-    {
-        Proxy p = {file_};
-        file_ = FMT_NULL;
-        return p;
-    }
+  // Returns a proxy object for moving from a temporary:
+  //   buffered_file file = buffered_file(...);
+  operator Proxy() FMT_NOEXCEPT {
+    Proxy p = {file_};
+    file_ = FMT_NULL;
+    return p;
+  }
 
 #else
-private:
-    FMT_DISALLOW_COPY_AND_ASSIGN(buffered_file);
+ private:
+  FMT_DISALLOW_COPY_AND_ASSIGN(buffered_file);
 
-public:
-    buffered_file(buffered_file &&other) FMT_NOEXCEPT : file_(other.file_)
-    {
-        other.file_ = FMT_NULL;
-    }
+ public:
+  buffered_file(buffered_file &&other) FMT_NOEXCEPT : file_(other.file_) {
+    other.file_ = FMT_NULL;
+  }
 
-    buffered_file &operator=(buffered_file &&other)
-    {
-        close();
-        file_ = other.file_;
-        other.file_ = FMT_NULL;
-        return *this;
-    }
+  buffered_file& operator=(buffered_file &&other) {
+    close();
+    file_ = other.file_;
+    other.file_ = FMT_NULL;
+    return *this;
+  }
 #endif
 
-    // Opens a file.
-    FMT_API buffered_file(cstring_view filename, cstring_view mode);
+  // Opens a file.
+  FMT_API buffered_file(cstring_view filename, cstring_view mode);
 
-    // Closes the file.
-    FMT_API void close();
+  // Closes the file.
+  FMT_API void close();
 
-    // Returns the pointer to a FILE object representing this file.
-    FILE *get() const FMT_NOEXCEPT
-    {
-        return file_;
-    }
+  // 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.
-    FMT_API int(fileno)() const;
+  // We place parentheses around fileno to workaround a bug in some versions
+  // of MinGW that define fileno as a macro.
+  FMT_API int (fileno)() const;
 
-    void vprint(string_view format_str, format_args args)
-    {
-        fmt::vprint(file_, format_str, args);
-    }
+  void vprint(string_view format_str, format_args args) {
+    fmt::vprint(file_, format_str, args);
+  }
 
-    template<typename... Args>
-    inline void print(string_view format_str, const Args &... args)
-    {
-        vprint(format_str, make_format_args(args...));
-    }
+  template <typename... Args>
+  inline void print(string_view format_str, const Args & ... args) {
+    vprint(format_str, make_format_args(args...));
+  }
 };
 
 // A file. Closed file is represented by a file object with descriptor -1.
@@ -259,226 +228,190 @@ public:
 // 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.
+class file {
+ private:
+  int fd_;  // File descriptor.
 
-    // Constructs a file object with a given descriptor.
-    explicit file(int fd)
-        : fd_(fd)
-    {
-    }
+  // 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.
-    };
+ 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) {}
+  // 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.
-    FMT_API file(cstring_view path, int oflag);
+  // Opens a file and constructs a file object representing this file.
+  FMT_API file(cstring_view path, int oflag);
 
 #if !FMT_USE_RVALUE_REFERENCES
-    // Emulate a move constructor and a move assignment operator if rvalue
-    // references are not supported.
+  // 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;
-    };
+ 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) {}
+ 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 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 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;
-    }
+  // 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 f = file(...);
-    operator Proxy() FMT_NOEXCEPT
-    {
-        Proxy p = {fd_};
-        fd_ = -1;
-        return p;
-    }
+  // Returns a proxy object for moving from a temporary:
+  //   file f = file(...);
+  operator Proxy() FMT_NOEXCEPT {
+    Proxy p = {fd_};
+    fd_ = -1;
+    return p;
+  }
 
 #else
-private:
-    FMT_DISALLOW_COPY_AND_ASSIGN(file);
+ private:
+  FMT_DISALLOW_COPY_AND_ASSIGN(file);
 
-public:
-    file(file &&other) FMT_NOEXCEPT : fd_(other.fd_)
-    {
-        other.fd_ = -1;
-    }
+ 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;
-    }
+  file& operator=(file &&other) {
+    close();
+    fd_ = other.fd_;
+    other.fd_ = -1;
+    return *this;
+  }
 #endif
 
-    // Destroys the object closing the file it represents if any.
-    FMT_API ~file() FMT_DTOR_NOEXCEPT;
+  // Destroys the object closing the file it represents if any.
+  FMT_API ~file() FMT_DTOR_NOEXCEPT;
 
-    // Returns the file descriptor.
-    int descriptor() const FMT_NOEXCEPT
-    {
-        return fd_;
-    }
+  // Returns the file descriptor.
+  int descriptor() const FMT_NOEXCEPT { return fd_; }
 
-    // Closes the file.
-    FMT_API void close();
+  // Closes the file.
+  FMT_API void close();
 
-    // Returns the file size. The size has signed type for consistency with
-    // stat::st_size.
-    FMT_API long long size() const;
+  // Returns the file size. The size has signed type for consistency with
+  // stat::st_size.
+  FMT_API long long size() const;
 
-    // Attempts to read count bytes from the file into the specified buffer.
-    FMT_API std::size_t read(void *buffer, std::size_t count);
+  // Attempts to read count bytes from the file into the specified buffer.
+  FMT_API std::size_t read(void *buffer, std::size_t count);
 
-    // Attempts to write count bytes from the specified buffer to the file.
-    FMT_API std::size_t write(const void *buffer, std::size_t count);
+  // Attempts to write count bytes from the specified buffer to the file.
+  FMT_API 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.
-    FMT_API static file dup(int fd);
+  // Duplicates a file descriptor with the dup function and returns
+  // the duplicate as a file object.
+  FMT_API static file dup(int fd);
 
-    // Makes fd be the copy of this file descriptor, closing fd first if
-    // necessary.
-    FMT_API void dup2(int fd);
+  // Makes fd be the copy of this file descriptor, closing fd first if
+  // necessary.
+  FMT_API void dup2(int fd);
 
-    // Makes fd be the copy of this file descriptor, closing fd first if
-    // necessary.
-    FMT_API void dup2(int fd, error_code &ec) FMT_NOEXCEPT;
+  // Makes fd be the copy of this file descriptor, closing fd first if
+  // necessary.
+  FMT_API void dup2(int fd, error_code &ec) FMT_NOEXCEPT;
 
-    // Creates a pipe setting up read_end and write_end file objects for reading
-    // and writing respectively.
-    FMT_API static void pipe(file &read_end, file &write_end);
+  // Creates a pipe setting up read_end and write_end file objects for reading
+  // and writing respectively.
+  FMT_API static void pipe(file &read_end, file &write_end);
 
-    // Creates a buffered_file object associated with this file and detaches
-    // this file object from the file.
-    FMT_API buffered_file fdopen(const char *mode);
+  // Creates a buffered_file object associated with this file and detaches
+  // this file object from the file.
+  FMT_API buffered_file fdopen(const char *mode);
 };
 
 // Returns the memory page size.
 long getpagesize();
 
-#if (defined(LC_NUMERIC_MASK) || defined(_MSC_VER)) && !defined(__ANDROID__) && !defined(__CYGWIN__) && !defined(__OpenBSD__)
-#define FMT_LOCALE
+#if (defined(LC_NUMERIC_MASK) || defined(_MSC_VER)) && \
+    !defined(__ANDROID__) && !defined(__CYGWIN__) && !defined(__OpenBSD__)
+# define FMT_LOCALE
 #endif
 
 #ifdef FMT_LOCALE
 // A "C" numeric locale.
-class Locale
-{
-private:
-#ifdef _MSC_VER
-    typedef _locale_t locale_t;
+class Locale {
+ private:
+# ifdef _MSC_VER
+  typedef _locale_t locale_t;
 
-    enum
-    {
-        LC_NUMERIC_MASK = LC_NUMERIC
-    };
+  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 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 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
+  static double strtod_l(const char *nptr, char **endptr, _locale_t locale) {
+    return _strtod_l(nptr, endptr, locale);
+  }
+# endif
 
-    locale_t locale_;
+  locale_t locale_;
 
-    FMT_DISALLOW_COPY_AND_ASSIGN(Locale);
+  FMT_DISALLOW_COPY_AND_ASSIGN(Locale);
 
-public:
-    typedef locale_t Type;
+ public:
+  typedef locale_t Type;
 
-    Locale()
-        : locale_(newlocale(LC_NUMERIC_MASK, "C", FMT_NULL))
-    {
-        if (!locale_)
-            FMT_THROW(system_error(errno, "cannot create locale"));
-    }
-    ~Locale()
-    {
-        freelocale(locale_);
-    }
+  Locale() : locale_(newlocale(LC_NUMERIC_MASK, "C", FMT_NULL)) {
+    if (!locale_)
+      FMT_THROW(system_error(errno, "cannot create locale"));
+  }
+  ~Locale() { freelocale(locale_); }
 
-    Type get() const
-    {
-        return 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 = FMT_NULL;
-        double result = strtod_l(str, &end, locale_);
-        str = end;
-        return result;
-    }
+  // Converts string to floating-point number and advances str past the end
+  // of the parsed input.
+  double strtod(const char *&str) const {
+    char *end = FMT_NULL;
+    double result = strtod_l(str, &end, locale_);
+    str = end;
+    return result;
+  }
 };
-#endif // FMT_LOCALE
+#endif  // FMT_LOCALE
 FMT_END_NAMESPACE
 
 #if !FMT_USE_RVALUE_REFERENCES
 namespace std {
 // For compatibility with C++98.
-inline fmt::buffered_file &move(fmt::buffered_file &f)
-{
-    return f;
+inline fmt::buffered_file &move(fmt::buffered_file &f) { return f; }
+inline fmt::file &move(fmt::file &f) { return f; }
 }
-inline fmt::file &move(fmt::file &f)
-{
-    return f;
-}
-} // namespace std
 #endif
 
-#endif // FMT_POSIX_H_
+#endif  // FMT_POSIX_H_
diff --git a/include/spdlog/fmt/bundled/printf.h b/include/spdlog/fmt/bundled/printf.h
index 073439e6..dd2df386 100644
--- a/include/spdlog/fmt/bundled/printf.h
+++ b/include/spdlog/fmt/bundled/printf.h
@@ -8,8 +8,8 @@
 #ifndef FMT_PRINTF_H_
 #define FMT_PRINTF_H_
 
-#include <algorithm> // std::fill_n
-#include <limits>    // std::numeric_limits
+#include <algorithm>  // std::fill_n
+#include <limits>     // std::numeric_limits
 
 #include "ostream.h"
 
@@ -18,231 +18,193 @@ namespace internal {
 
 // Checks if a value fits in int - used to avoid warnings about comparing
 // signed and unsigned integers.
-template<bool IsSigned>
-struct int_checker
-{
-    template<typename T>
-    static bool fits_in_int(T value)
-    {
-        unsigned max = std::numeric_limits<int>::max();
-        return value <= max;
-    }
-    static bool fits_in_int(bool)
-    {
-        return true;
-    }
+template <bool IsSigned>
+struct int_checker {
+  template <typename T>
+  static bool fits_in_int(T value) {
+    unsigned max = std::numeric_limits<int>::max();
+    return value <= max;
+  }
+  static bool fits_in_int(bool) { return true; }
 };
 
-template<>
-struct int_checker<true>
-{
-    template<typename T>
-    static bool fits_in_int(T value)
-    {
-        return value >= std::numeric_limits<int>::min() && value <= std::numeric_limits<int>::max();
-    }
-    static bool fits_in_int(int)
-    {
-        return true;
-    }
+template <>
+struct int_checker<true> {
+  template <typename T>
+  static bool fits_in_int(T value) {
+    return value >= std::numeric_limits<int>::min() &&
+           value <= std::numeric_limits<int>::max();
+  }
+  static bool fits_in_int(int) { return true; }
 };
 
-class printf_precision_handler : public function<int>
-{
-public:
-    template<typename T>
-    typename std::enable_if<std::is_integral<T>::value, int>::type operator()(T value)
-    {
-        if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
-            FMT_THROW(format_error("number is too big"));
-        return static_cast<int>(value);
-    }
+class printf_precision_handler: public function<int> {
+ public:
+  template <typename T>
+  typename std::enable_if<std::is_integral<T>::value, int>::type
+      operator()(T value) {
+    if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
+      FMT_THROW(format_error("number is too big"));
+    return static_cast<int>(value);
+  }
 
-    template<typename T>
-    typename std::enable_if<!std::is_integral<T>::value, int>::type operator()(T)
-    {
-        FMT_THROW(format_error("precision is not integer"));
-        return 0;
-    }
+  template <typename T>
+  typename std::enable_if<!std::is_integral<T>::value, int>::type operator()(T) {
+    FMT_THROW(format_error("precision is not integer"));
+    return 0;
+  }
 };
 
 // An argument visitor that returns true iff arg is a zero integer.
-class is_zero_int : public function<bool>
-{
-public:
-    template<typename T>
-    typename std::enable_if<std::is_integral<T>::value, bool>::type operator()(T value)
-    {
-        return value == 0;
-    }
+class is_zero_int: public function<bool> {
+ public:
+  template <typename T>
+  typename std::enable_if<std::is_integral<T>::value, bool>::type
+      operator()(T value) { return value == 0; }
 
-    template<typename T>
-    typename std::enable_if<!std::is_integral<T>::value, bool>::type operator()(T)
-    {
-        return false;
-    }
+  template <typename T>
+  typename std::enable_if<!std::is_integral<T>::value, bool>::type
+      operator()(T) { return false; }
 };
 
-template<typename T>
-struct make_unsigned_or_bool : std::make_unsigned<T>
-{
+template <typename T>
+struct make_unsigned_or_bool : std::make_unsigned<T> {};
+
+template <>
+struct make_unsigned_or_bool<bool> {
+  typedef bool type;
 };
 
-template<>
-struct make_unsigned_or_bool<bool>
-{
-    typedef bool type;
-};
+template <typename T, typename Context>
+class arg_converter: public function<void> {
+ private:
+  typedef typename Context::char_type Char;
 
-template<typename T, typename Context>
-class arg_converter : public function<void>
-{
-private:
-    typedef typename Context::char_type Char;
+  basic_format_arg<Context> &arg_;
+  typename Context::char_type type_;
 
-    basic_format_arg<Context> &arg_;
-    typename Context::char_type type_;
+ public:
+  arg_converter(basic_format_arg<Context> &arg, Char type)
+    : arg_(arg), type_(type) {}
 
-public:
-    arg_converter(basic_format_arg<Context> &arg, Char type)
-        : arg_(arg)
-        , type_(type)
-    {
+  void operator()(bool value) {
+    if (type_ != 's')
+      operator()<bool>(value);
+  }
+
+  template <typename U>
+  typename std::enable_if<std::is_integral<U>::value>::type
+      operator()(U value) {
+    bool is_signed = type_ == 'd' || type_ == 'i';
+    typedef typename std::conditional<
+        std::is_same<T, void>::value, U, T>::type TargetType;
+    if (const_check(sizeof(TargetType) <= sizeof(int))) {
+      // Extra casts are used to silence warnings.
+      if (is_signed) {
+        arg_ = internal::make_arg<Context>(
+          static_cast<int>(static_cast<TargetType>(value)));
+      } else {
+        typedef typename make_unsigned_or_bool<TargetType>::type Unsigned;
+        arg_ = internal::make_arg<Context>(
+          static_cast<unsigned>(static_cast<Unsigned>(value)));
+      }
+    } else {
+      if (is_signed) {
+        // 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_ = internal::make_arg<Context>(static_cast<long long>(value));
+      } else {
+        arg_ = internal::make_arg<Context>(
+          static_cast<typename make_unsigned_or_bool<U>::type>(value));
+      }
     }
+  }
 
-    void operator()(bool value)
-    {
-        if (type_ != 's')
-            operator()<bool>(value);
-    }
-
-    template<typename U>
-    typename std::enable_if<std::is_integral<U>::value>::type operator()(U value)
-    {
-        bool is_signed = type_ == 'd' || type_ == 'i';
-        typedef typename std::conditional<std::is_same<T, void>::value, U, T>::type TargetType;
-        if (const_check(sizeof(TargetType) <= sizeof(int)))
-        {
-            // Extra casts are used to silence warnings.
-            if (is_signed)
-            {
-                arg_ = internal::make_arg<Context>(static_cast<int>(static_cast<TargetType>(value)));
-            }
-            else
-            {
-                typedef typename make_unsigned_or_bool<TargetType>::type Unsigned;
-                arg_ = internal::make_arg<Context>(static_cast<unsigned>(static_cast<Unsigned>(value)));
-            }
-        }
-        else
-        {
-            if (is_signed)
-            {
-                // 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_ = internal::make_arg<Context>(static_cast<long long>(value));
-            }
-            else
-            {
-                arg_ = internal::make_arg<Context>(static_cast<typename make_unsigned_or_bool<U>::type>(value));
-            }
-        }
-    }
-
-    template<typename U>
-    typename std::enable_if<!std::is_integral<U>::value>::type operator()(U)
-    {
-        // No coversion needed for non-integral types.
-    }
+  template <typename U>
+  typename std::enable_if<!std::is_integral<U>::value>::type operator()(U) {
+    // No coversion needed for non-integral types.
+  }
 };
 
 // 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, typename Context, typename Char>
-void convert_arg(basic_format_arg<Context> &arg, Char type)
-{
-    visit(arg_converter<T, Context>(arg, type), arg);
+template <typename T, typename Context, typename Char>
+void convert_arg(basic_format_arg<Context> &arg, Char type) {
+  visit(arg_converter<T, Context>(arg, type), arg);
 }
 
 // Converts an integer argument to char for printf.
-template<typename Context>
-class char_converter : public function<void>
-{
-private:
-    basic_format_arg<Context> &arg_;
+template <typename Context>
+class char_converter: public function<void> {
+ private:
+  basic_format_arg<Context> &arg_;
 
-    FMT_DISALLOW_COPY_AND_ASSIGN(char_converter);
+  FMT_DISALLOW_COPY_AND_ASSIGN(char_converter);
 
-public:
-    explicit char_converter(basic_format_arg<Context> &arg)
-        : arg_(arg)
-    {
-    }
+ public:
+  explicit char_converter(basic_format_arg<Context> &arg) : arg_(arg) {}
 
-    template<typename T>
-    typename std::enable_if<std::is_integral<T>::value>::type operator()(T value)
-    {
-        typedef typename Context::char_type Char;
-        arg_ = internal::make_arg<Context>(static_cast<Char>(value));
-    }
+  template <typename T>
+  typename std::enable_if<std::is_integral<T>::value>::type
+      operator()(T value) {
+    typedef typename Context::char_type Char;
+    arg_ = internal::make_arg<Context>(static_cast<Char>(value));
+  }
 
-    template<typename T>
-    typename std::enable_if<!std::is_integral<T>::value>::type operator()(T)
-    {
-        // No coversion needed for non-integral types.
-    }
+  template <typename T>
+  typename std::enable_if<!std::is_integral<T>::value>::type operator()(T) {
+    // No coversion needed for non-integral types.
+  }
 };
 
 // Checks if an argument is a valid printf width specifier and sets
 // left alignment if it is negative.
-template<typename Char>
-class printf_width_handler : public function<unsigned>
-{
-private:
-    typedef basic_format_specs<Char> format_specs;
+template <typename Char>
+class printf_width_handler: public function<unsigned> {
+ private:
+  typedef basic_format_specs<Char> format_specs;
 
-    format_specs &spec_;
+  format_specs &spec_;
 
-    FMT_DISALLOW_COPY_AND_ASSIGN(printf_width_handler);
+  FMT_DISALLOW_COPY_AND_ASSIGN(printf_width_handler);
 
-public:
-    explicit printf_width_handler(format_specs &spec)
-        : spec_(spec)
-    {
+ public:
+  explicit printf_width_handler(format_specs &spec) : spec_(spec) {}
+
+  template <typename T>
+  typename std::enable_if<std::is_integral<T>::value, unsigned>::type
+      operator()(T value) {
+    typedef typename internal::int_traits<T>::main_type UnsignedType;
+    UnsignedType width = static_cast<UnsignedType>(value);
+    if (internal::is_negative(value)) {
+      spec_.align_ = ALIGN_LEFT;
+      width = 0 - width;
     }
+    unsigned int_max = std::numeric_limits<int>::max();
+    if (width > int_max)
+      FMT_THROW(format_error("number is too big"));
+    return static_cast<unsigned>(width);
+  }
 
-    template<typename T>
-    typename std::enable_if<std::is_integral<T>::value, unsigned>::type operator()(T value)
-    {
-        typedef typename internal::int_traits<T>::main_type UnsignedType;
-        UnsignedType width = static_cast<UnsignedType>(value);
-        if (internal::is_negative(value))
-        {
-            spec_.align_ = ALIGN_LEFT;
-            width = 0 - width;
-        }
-        unsigned int_max = std::numeric_limits<int>::max();
-        if (width > int_max)
-            FMT_THROW(format_error("number is too big"));
-        return static_cast<unsigned>(width);
-    }
-
-    template<typename T>
-    typename std::enable_if<!std::is_integral<T>::value, unsigned>::type operator()(T)
-    {
-        FMT_THROW(format_error("width is not integer"));
-        return 0;
-    }
+  template <typename T>
+  typename std::enable_if<!std::is_integral<T>::value, unsigned>::type
+      operator()(T) {
+    FMT_THROW(format_error("width is not integer"));
+    return 0;
+  }
 };
-} // namespace internal
+}  // namespace internal
 
-template<typename Range>
+template <typename Range>
 class printf_arg_formatter;
 
-template<typename OutputIt, typename Char, typename ArgFormatter = printf_arg_formatter<back_insert_range<internal::basic_buffer<Char>>>>
+template <
+    typename OutputIt, typename Char,
+    typename ArgFormatter =
+      printf_arg_formatter<back_insert_range<internal::basic_buffer<Char>>>>
 class basic_printf_context;
 
 /**
@@ -250,406 +212,385 @@ class basic_printf_context;
   The ``printf`` argument formatter.
   \endrst
  */
-template<typename Range>
-class printf_arg_formatter : public internal::function<typename internal::arg_formatter_base<Range>::iterator>,
-                             public internal::arg_formatter_base<Range>
-{
-private:
-    typedef typename Range::value_type char_type;
-    typedef decltype(internal::declval<Range>().begin()) iterator;
-    typedef internal::arg_formatter_base<Range> base;
-    typedef basic_printf_context<iterator, char_type> context_type;
+template <typename Range>
+class printf_arg_formatter:
+  public internal::function<
+    typename internal::arg_formatter_base<Range>::iterator>,
+  public internal::arg_formatter_base<Range> {
+ private:
+  typedef typename Range::value_type char_type;
+  typedef decltype(internal::declval<Range>().begin()) iterator;
+  typedef internal::arg_formatter_base<Range> base;
+  typedef basic_printf_context<iterator, char_type> context_type;
 
-    context_type &context_;
+  context_type &context_;
 
-    void write_null_pointer(char)
-    {
-        this->spec().type_ = 0;
-        this->write("(nil)");
+  void write_null_pointer(char) {
+    this->spec().type_ = 0;
+    this->write("(nil)");
+  }
+
+  void write_null_pointer(wchar_t) {
+    this->spec().type_ = 0;
+    this->write(L"(nil)");
+  }
+
+ public:
+  typedef typename base::format_specs format_specs;
+
+  /**
+    \rst
+    Constructs an argument formatter object.
+    *buffer* is a reference to the output buffer and *spec* contains format
+    specifier information for standard argument types.
+    \endrst
+   */
+  printf_arg_formatter(internal::basic_buffer<char_type> &buffer,
+                       format_specs &spec, context_type &ctx)
+    : base(back_insert_range<internal::basic_buffer<char_type>>(buffer), spec),
+      context_(ctx) {}
+
+  template <typename T>
+  typename std::enable_if<std::is_integral<T>::value, iterator>::type
+      operator()(T value) {
+    // MSVC2013 fails to compile separate overloads for bool and char_type so
+    // use std::is_same instead.
+    if (std::is_same<T, bool>::value) {
+      format_specs &fmt_spec = this->spec();
+      if (fmt_spec.type_ != 's')
+        return base::operator()(value ? 1 : 0);
+      fmt_spec.type_ = 0;
+      this->write(value != 0);
+    } else if (std::is_same<T, char_type>::value) {
+      format_specs &fmt_spec = this->spec();
+      if (fmt_spec.type_ && fmt_spec.type_ != 'c')
+        return (*this)(static_cast<int>(value));
+      fmt_spec.flags_ = 0;
+      fmt_spec.align_ = ALIGN_RIGHT;
+      return base::operator()(value);
+    } else {
+      return base::operator()(value);
     }
+    return this->out();
+  }
 
-    void write_null_pointer(wchar_t)
-    {
-        this->spec().type_ = 0;
-        this->write(L"(nil)");
-    }
+  template <typename T>
+  typename std::enable_if<std::is_floating_point<T>::value, iterator>::type
+      operator()(T value) {
+    return base::operator()(value);
+  }
 
-public:
-    typedef typename base::format_specs format_specs;
+  /** Formats a null-terminated C string. */
+  iterator operator()(const char *value) {
+    if (value)
+      base::operator()(value);
+    else if (this->spec().type_ == 'p')
+      write_null_pointer(char_type());
+    else
+      this->write("(null)");
+    return this->out();
+  }
 
-    /**
-      \rst
-      Constructs an argument formatter object.
-      *buffer* is a reference to the output buffer and *spec* contains format
-      specifier information for standard argument types.
-      \endrst
-     */
-    printf_arg_formatter(internal::basic_buffer<char_type> &buffer, format_specs &spec, context_type &ctx)
-        : base(back_insert_range<internal::basic_buffer<char_type>>(buffer), spec)
-        , context_(ctx)
-    {
-    }
+  /** Formats a null-terminated wide C string. */
+  iterator operator()(const wchar_t *value) {
+    if (value)
+      base::operator()(value);
+    else if (this->spec().type_ == 'p')
+      write_null_pointer(char_type());
+    else
+      this->write(L"(null)");
+    return this->out();
+  }
 
-    using base::operator();
+  iterator operator()(basic_string_view<char_type> value) {
+    return base::operator()(value);
+  }
 
-    /** Formats an argument of type ``bool``. */
-    iterator operator()(bool value)
-    {
-        format_specs &fmt_spec = this->spec();
-        if (fmt_spec.type_ != 's')
-            return (*this)(value ? 1 : 0);
-        fmt_spec.type_ = 0;
-        this->write(value);
-        return this->out();
-    }
+  iterator operator()(monostate value) {
+    return base::operator()(value);
+  }
 
-    /** Formats a character. */
-    iterator operator()(char_type value)
-    {
-        format_specs &fmt_spec = this->spec();
-        if (fmt_spec.type_ && fmt_spec.type_ != 'c')
-            return (*this)(static_cast<int>(value));
-        fmt_spec.flags_ = 0;
-        fmt_spec.align_ = ALIGN_RIGHT;
-        return base::operator()(value);
-    }
+  /** Formats a pointer. */
+  iterator operator()(const void *value) {
+    if (value)
+      return base::operator()(value);
+    this->spec().type_ = 0;
+    write_null_pointer(char_type());
+    return this->out();
+  }
 
-    /** Formats a null-terminated C string. */
-    iterator operator()(const char *value)
-    {
-        if (value)
-            base::operator()(value);
-        else if (this->spec().type_ == 'p')
-            write_null_pointer(char_type());
-        else
-            this->write("(null)");
-        return this->out();
-    }
-
-    /** Formats a null-terminated wide C string. */
-    iterator operator()(const wchar_t *value)
-    {
-        if (value)
-            base::operator()(value);
-        else if (this->spec().type_ == 'p')
-            write_null_pointer(char_type());
-        else
-            this->write(L"(null)");
-        return this->out();
-    }
-
-    /** Formats a pointer. */
-    iterator operator()(const void *value)
-    {
-        if (value)
-            return base::operator()(value);
-        this->spec().type_ = 0;
-        write_null_pointer(char_type());
-        return this->out();
-    }
-
-    /** Formats an argument of a custom (user-defined) type. */
-    iterator operator()(typename basic_format_arg<context_type>::handle handle)
-    {
-        handle.format(context_);
-        return this->out();
-    }
+  /** Formats an argument of a custom (user-defined) type. */
+  iterator operator()(typename basic_format_arg<context_type>::handle handle) {
+    handle.format(context_);
+    return this->out();
+  }
 };
 
-template<typename T>
-struct printf_formatter
-{
-    template<typename ParseContext>
-    auto parse(ParseContext &ctx) -> decltype(ctx.begin())
-    {
-        return ctx.begin();
-    }
+template <typename T>
+struct printf_formatter {
+  template <typename ParseContext>
+  auto parse(ParseContext &ctx) -> decltype(ctx.begin()) { return ctx.begin(); }
 
-    template<typename FormatContext>
-    auto format(const T &value, FormatContext &ctx) -> decltype(ctx.out())
-    {
-        internal::format_value(internal::get_container(ctx.out()), value);
-        return ctx.out();
-    }
+  template <typename FormatContext>
+  auto format(const T &value, FormatContext &ctx) -> decltype(ctx.out()) {
+    internal::format_value(internal::get_container(ctx.out()), value);
+    return ctx.out();
+  }
 };
 
 /** This template formats data and writes the output to a writer. */
-template<typename OutputIt, typename Char, typename ArgFormatter>
-class basic_printf_context : private internal::context_base<OutputIt, basic_printf_context<OutputIt, Char, ArgFormatter>, Char>
-{
-public:
-    /** The character type for the output. */
-    typedef Char char_type;
+template <typename OutputIt, typename Char, typename ArgFormatter>
+class basic_printf_context :
+  private internal::context_base<
+    OutputIt, basic_printf_context<OutputIt, Char, ArgFormatter>, Char> {
+ public:
+  /** The character type for the output. */
+  typedef Char char_type;
 
-    template<typename T>
-    struct formatter_type
-    {
-        typedef printf_formatter<T> type;
-    };
+  template <typename T>
+  struct formatter_type { typedef printf_formatter<T> type; };
 
-private:
-    typedef internal::context_base<OutputIt, basic_printf_context, Char> base;
-    typedef typename base::format_arg format_arg;
-    typedef basic_format_specs<char_type> format_specs;
-    typedef internal::null_terminating_iterator<char_type> iterator;
+ private:
+  typedef internal::context_base<OutputIt, basic_printf_context, Char> base;
+  typedef typename base::format_arg format_arg;
+  typedef basic_format_specs<char_type> format_specs;
+  typedef internal::null_terminating_iterator<char_type> iterator;
 
-    void parse_flags(format_specs &spec, iterator &it);
+  void parse_flags(format_specs &spec, iterator &it);
 
-    // Returns the argument with specified index or, if arg_index is equal
-    // to the maximum unsigned value, the next argument.
-    format_arg get_arg(iterator it, unsigned arg_index = (std::numeric_limits<unsigned>::max)());
+  // Returns the argument with specified index or, if arg_index is equal
+  // to the maximum unsigned value, the next argument.
+  format_arg get_arg(
+      iterator it,
+      unsigned arg_index = (std::numeric_limits<unsigned>::max)());
 
-    // Parses argument index, flags and width and returns the argument index.
-    unsigned parse_header(iterator &it, format_specs &spec);
+  // Parses argument index, flags and width and returns the argument index.
+  unsigned parse_header(iterator &it, format_specs &spec);
 
-public:
-    /**
-     \rst
-     Constructs a ``printf_context`` object. References to the arguments and
-     the writer are stored in the context object so make sure they have
-     appropriate lifetimes.
-     \endrst
-     */
-    basic_printf_context(OutputIt out, basic_string_view<char_type> format_str, basic_format_args<basic_printf_context> args)
-        : base(out, format_str, args)
-    {
-    }
+ public:
+  /**
+   \rst
+   Constructs a ``printf_context`` object. References to the arguments and
+   the writer are stored in the context object so make sure they have
+   appropriate lifetimes.
+   \endrst
+   */
+  basic_printf_context(OutputIt out, basic_string_view<char_type> format_str,
+                       basic_format_args<basic_printf_context> args)
+    : base(out, format_str, args) {}
 
-    using base::advance_to;
-    using base::out;
-    using base::parse_context;
+  using base::parse_context;
+  using base::out;
+  using base::advance_to;
 
-    /** Formats stored arguments and writes the output to the range. */
-    void format();
+  /** Formats stored arguments and writes the output to the range. */
+  void format();
 };
 
-template<typename OutputIt, typename Char, typename AF>
-void basic_printf_context<OutputIt, Char, AF>::parse_flags(format_specs &spec, iterator &it)
-{
-    for (;;)
-    {
-        switch (*it++)
-        {
-        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:
-            --it;
-            return;
-        }
+template <typename OutputIt, typename Char, typename AF>
+void basic_printf_context<OutputIt, Char, AF>::parse_flags(
+    format_specs &spec, iterator &it) {
+  for (;;) {
+    switch (*it++) {
+      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:
+        --it;
+        return;
     }
+  }
 }
 
-template<typename OutputIt, typename Char, typename AF>
-typename basic_printf_context<OutputIt, Char, AF>::format_arg basic_printf_context<OutputIt, Char, AF>::get_arg(
-    iterator it, unsigned arg_index)
-{
-    (void)it;
-    if (arg_index == std::numeric_limits<unsigned>::max())
-        return this->do_get_arg(this->parse_context().next_arg_id());
-    return base::get_arg(arg_index - 1);
+template <typename OutputIt, typename Char, typename AF>
+typename basic_printf_context<OutputIt, Char, AF>::format_arg
+  basic_printf_context<OutputIt, Char, AF>::get_arg(
+    iterator it, unsigned arg_index) {
+  (void)it;
+  if (arg_index == std::numeric_limits<unsigned>::max())
+    return this->do_get_arg(this->parse_context().next_arg_id());
+  return base::get_arg(arg_index - 1);
 }
 
-template<typename OutputIt, typename Char, typename AF>
-unsigned basic_printf_context<OutputIt, Char, AF>::parse_header(iterator &it, format_specs &spec)
-{
-    unsigned arg_index = std::numeric_limits<unsigned>::max();
-    char_type c = *it;
-    if (c >= '0' && c <= '9')
-    {
-        // Parse an argument index (if followed by '$') or a width possibly
-        // preceded with '0' flag(s).
-        internal::error_handler eh;
-        unsigned value = parse_nonnegative_int(it, eh);
-        if (*it == '$')
-        { // value is an argument index
-            ++it;
-            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;
-            }
-        }
+template <typename OutputIt, typename Char, typename AF>
+unsigned basic_printf_context<OutputIt, Char, AF>::parse_header(
+  iterator &it, format_specs &spec) {
+  unsigned arg_index = std::numeric_limits<unsigned>::max();
+  char_type c = *it;
+  if (c >= '0' && c <= '9') {
+    // Parse an argument index (if followed by '$') or a width possibly
+    // preceded with '0' flag(s).
+    internal::error_handler eh;
+    unsigned value = parse_nonnegative_int(it, eh);
+    if (*it == '$') {  // value is an argument index
+      ++it;
+      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, it);
-    // Parse width.
-    if (*it >= '0' && *it <= '9')
-    {
-        internal::error_handler eh;
-        spec.width_ = parse_nonnegative_int(it, eh);
+  }
+  parse_flags(spec, it);
+  // Parse width.
+  if (*it >= '0' && *it <= '9') {
+    internal::error_handler eh;
+    spec.width_ = parse_nonnegative_int(it, eh);
+  } else if (*it == '*') {
+    ++it;
+    spec.width_ =
+        visit(internal::printf_width_handler<char_type>(spec), get_arg(it));
+  }
+  return arg_index;
+}
+
+template <typename OutputIt, typename Char, typename AF>
+void basic_printf_context<OutputIt, Char, AF>::format() {
+  auto &buffer = internal::get_container(this->out());
+  auto start = iterator(this->parse_context());
+  auto it = start;
+  using internal::pointer_from;
+  while (*it) {
+    char_type c = *it++;
+    if (c != '%') continue;
+    if (*it == c) {
+      buffer.append(pointer_from(start), pointer_from(it));
+      start = ++it;
+      continue;
     }
-    else if (*it == '*')
-    {
+    buffer.append(pointer_from(start), pointer_from(it) - 1);
+
+    format_specs spec;
+    spec.align_ = ALIGN_RIGHT;
+
+    // Parse argument index, flags and width.
+    unsigned arg_index = parse_header(it, spec);
+
+    // Parse precision.
+    if (*it == '.') {
+      ++it;
+      if ('0' <= *it && *it <= '9') {
+        internal::error_handler eh;
+        spec.precision_ = static_cast<int>(parse_nonnegative_int(it, eh));
+      } else if (*it == '*') {
         ++it;
-        spec.width_ = visit(internal::printf_width_handler<char_type>(spec), get_arg(it));
+        spec.precision_ =
+            visit(internal::printf_precision_handler(), get_arg(it));
+      } else {
+        spec.precision_ = 0;
+      }
     }
-    return arg_index;
-}
 
-template<typename OutputIt, typename Char, typename AF>
-void basic_printf_context<OutputIt, Char, AF>::format()
-{
-    auto &buffer = internal::get_container(this->out());
-    auto start = iterator(this->parse_context());
-    auto it = start;
-    using internal::pointer_from;
-    while (*it)
-    {
-        char_type c = *it++;
-        if (c != '%')
-            continue;
-        if (*it == c)
-        {
-            buffer.append(pointer_from(start), pointer_from(it));
-            start = ++it;
-            continue;
-        }
-        buffer.append(pointer_from(start), pointer_from(it) - 1);
-
-        format_specs spec;
-        spec.align_ = ALIGN_RIGHT;
-
-        // Parse argument index, flags and width.
-        unsigned arg_index = parse_header(it, spec);
-
-        // Parse precision.
-        if (*it == '.')
-        {
-            ++it;
-            if ('0' <= *it && *it <= '9')
-            {
-                internal::error_handler eh;
-                spec.precision_ = static_cast<int>(parse_nonnegative_int(it, eh));
-            }
-            else if (*it == '*')
-            {
-                ++it;
-                spec.precision_ = visit(internal::printf_precision_handler(), get_arg(it));
-            }
-            else
-            {
-                spec.precision_ = 0;
-            }
-        }
-
-        format_arg arg = get_arg(it, arg_index);
-        if (spec.flag(HASH_FLAG) && visit(internal::is_zero_int(), arg))
-            spec.flags_ &= ~internal::to_unsigned<int>(HASH_FLAG);
-        if (spec.fill_ == '0')
-        {
-            if (arg.is_arithmetic())
-                spec.align_ = ALIGN_NUMERIC;
-            else
-                spec.fill_ = ' '; // Ignore '0' flag for non-numeric types.
-        }
-
-        // Parse length and convert the argument to the required type.
-        using internal::convert_arg;
-        switch (*it++)
-        {
-        case 'h':
-            if (*it == 'h')
-                convert_arg<signed char>(arg, *++it);
-            else
-                convert_arg<short>(arg, *it);
-            break;
-        case 'l':
-            if (*it == 'l')
-                convert_arg<long long>(arg, *++it);
-            else
-                convert_arg<long>(arg, *it);
-            break;
-        case 'j':
-            convert_arg<intmax_t>(arg, *it);
-            break;
-        case 'z':
-            convert_arg<std::size_t>(arg, *it);
-            break;
-        case 't':
-            convert_arg<std::ptrdiff_t>(arg, *it);
-            break;
-        case 'L':
-            // printf produces garbage when 'L' is omitted for long double, no
-            // need to do the same.
-            break;
-        default:
-            --it;
-            convert_arg<void>(arg, *it);
-        }
-
-        // Parse type.
-        if (!*it)
-            FMT_THROW(format_error("invalid format string"));
-        spec.type_ = static_cast<char>(*it++);
-        if (arg.is_integral())
-        {
-            // Normalize type.
-            switch (spec.type_)
-            {
-            case 'i':
-            case 'u':
-                spec.type_ = 'd';
-                break;
-            case 'c':
-                // TODO: handle wchar_t better?
-                visit(internal::char_converter<basic_printf_context>(arg), arg);
-                break;
-            }
-        }
-
-        start = it;
-
-        // Format argument.
-        visit(AF(buffer, spec, *this), arg);
+    format_arg arg = get_arg(it, arg_index);
+    if (spec.flag(HASH_FLAG) && visit(internal::is_zero_int(), arg))
+      spec.flags_ &= ~internal::to_unsigned<int>(HASH_FLAG);
+    if (spec.fill_ == '0') {
+      if (arg.is_arithmetic())
+        spec.align_ = ALIGN_NUMERIC;
+      else
+        spec.fill_ = ' ';  // Ignore '0' flag for non-numeric types.
     }
-    buffer.append(pointer_from(start), pointer_from(it));
+
+    // Parse length and convert the argument to the required type.
+    using internal::convert_arg;
+    switch (*it++) {
+    case 'h':
+      if (*it == 'h')
+        convert_arg<signed char>(arg, *++it);
+      else
+        convert_arg<short>(arg, *it);
+      break;
+    case 'l':
+      if (*it == 'l')
+        convert_arg<long long>(arg, *++it);
+      else
+        convert_arg<long>(arg, *it);
+      break;
+    case 'j':
+      convert_arg<intmax_t>(arg, *it);
+      break;
+    case 'z':
+      convert_arg<std::size_t>(arg, *it);
+      break;
+    case 't':
+      convert_arg<std::ptrdiff_t>(arg, *it);
+      break;
+    case 'L':
+      // printf produces garbage when 'L' is omitted for long double, no
+      // need to do the same.
+      break;
+    default:
+      --it;
+      convert_arg<void>(arg, *it);
+    }
+
+    // Parse type.
+    if (!*it)
+      FMT_THROW(format_error("invalid format string"));
+    spec.type_ = static_cast<char>(*it++);
+    if (arg.is_integral()) {
+      // Normalize type.
+      switch (spec.type_) {
+      case 'i': case 'u':
+        spec.type_ = 'd';
+        break;
+      case 'c':
+        // TODO: handle wchar_t better?
+        visit(internal::char_converter<basic_printf_context>(arg), arg);
+        break;
+      }
+    }
+
+    start = it;
+
+    // Format argument.
+    visit(AF(buffer, spec, *this), arg);
+  }
+  buffer.append(pointer_from(start), pointer_from(it));
 }
 
-template<typename Char, typename Context>
-void printf(internal::basic_buffer<Char> &buf, basic_string_view<Char> format, basic_format_args<Context> args)
-{
-    Context(std::back_inserter(buf), format, args).format();
+template <typename Char, typename Context>
+void printf(internal::basic_buffer<Char> &buf, basic_string_view<Char> format,
+            basic_format_args<Context> args) {
+  Context(std::back_inserter(buf), format, args).format();
 }
 
-template<typename Buffer>
-struct printf_context
-{
-    typedef basic_printf_context<std::back_insert_iterator<Buffer>, typename Buffer::value_type> type;
+template <typename Buffer>
+struct printf_context {
+  typedef basic_printf_context<
+    std::back_insert_iterator<Buffer>, typename Buffer::value_type> type;
 };
 
-template<typename... Args>
-inline format_arg_store<printf_context<internal::buffer>::type, Args...> make_printf_args(const Args &... args)
-{
-    return format_arg_store<printf_context<internal::buffer>::type, Args...>(args...);
+template <typename ...Args>
+inline format_arg_store<printf_context<internal::buffer>::type, Args...>
+    make_printf_args(const Args & ... args) {
+  return format_arg_store<printf_context<internal::buffer>::type, Args...>(
+      args...);
 }
 typedef basic_format_args<printf_context<internal::buffer>::type> printf_args;
 typedef basic_format_args<printf_context<internal::wbuffer>::type> wprintf_args;
 
-inline std::string vsprintf(string_view format, printf_args args)
-{
-    memory_buffer buffer;
-    printf(buffer, format, args);
-    return to_string(buffer);
+inline std::string vsprintf(string_view format, printf_args args) {
+  memory_buffer buffer;
+  printf(buffer, format, args);
+  return to_string(buffer);
 }
 
 /**
@@ -661,33 +602,33 @@ inline std::string vsprintf(string_view format, printf_args args)
     std::string message = fmt::sprintf("The answer is %d", 42);
   \endrst
 */
-template<typename... Args>
-inline std::string sprintf(string_view format_str, const Args &... args)
-{
-    return vsprintf(format_str, make_format_args<typename printf_context<internal::buffer>::type>(args...));
+template <typename... Args>
+inline std::string sprintf(string_view format_str, const Args & ... args) {
+  return vsprintf(format_str,
+    make_format_args<typename printf_context<internal::buffer>::type>(args...));
 }
 
-inline std::wstring vsprintf(wstring_view format, wprintf_args args)
-{
-    wmemory_buffer buffer;
-    printf(buffer, format, args);
-    return to_string(buffer);
+inline std::wstring vsprintf(wstring_view format, wprintf_args args) {
+  wmemory_buffer buffer;
+  printf(buffer, format, args);
+  return to_string(buffer);
 }
 
-template<typename... Args>
-inline std::wstring sprintf(wstring_view format_str, const Args &... args)
-{
-    return vsprintf(format_str, make_format_args<typename printf_context<internal::wbuffer>::type>(args...));
+template <typename... Args>
+inline std::wstring sprintf(wstring_view format_str, const Args & ... args) {
+  return vsprintf(format_str,
+    make_format_args<typename printf_context<internal::wbuffer>::type>(args...));
 }
 
-template<typename Char>
-inline int vfprintf(
-    std::FILE *f, basic_string_view<Char> format, basic_format_args<typename printf_context<internal::basic_buffer<Char>>::type> args)
-{
-    basic_memory_buffer<Char> buffer;
-    printf(buffer, format, args);
-    std::size_t size = buffer.size();
-    return std::fwrite(buffer.data(), sizeof(Char), size, f) < size ? -1 : static_cast<int>(size);
+template <typename Char>
+inline int vfprintf(std::FILE *f, basic_string_view<Char> format,
+                    basic_format_args<typename printf_context<
+                      internal::basic_buffer<Char>>::type> args) {
+  basic_memory_buffer<Char> buffer;
+  printf(buffer, format, args);
+  std::size_t size = buffer.size();
+  return std::fwrite(
+    buffer.data(), sizeof(Char), size, f) < size ? -1 : static_cast<int>(size);
 }
 
 /**
@@ -699,27 +640,26 @@ inline int vfprintf(
     fmt::fprintf(stderr, "Don't %s!", "panic");
   \endrst
  */
-template<typename... Args>
-inline int fprintf(std::FILE *f, string_view format_str, const Args &... args)
-{
-    auto vargs = make_format_args<typename printf_context<internal::buffer>::type>(args...);
-    return vfprintf<char>(f, format_str, vargs);
+template <typename... Args>
+inline int fprintf(std::FILE *f, string_view format_str, const Args & ... args) {
+  auto vargs = make_format_args<
+    typename printf_context<internal::buffer>::type>(args...);
+  return vfprintf<char>(f, format_str, vargs);
 }
 
-template<typename... Args>
-inline int fprintf(std::FILE *f, wstring_view format_str, const Args &... args)
-{
-    return vfprintf(f, format_str, make_format_args<typename printf_context<internal::wbuffer>::type>(args...));
+template <typename... Args>
+inline int fprintf(std::FILE *f, wstring_view format_str,
+                   const Args & ... args) {
+  return vfprintf(f, format_str,
+    make_format_args<typename printf_context<internal::wbuffer>::type>(args...));
 }
 
-inline int vprintf(string_view format, printf_args args)
-{
-    return vfprintf(stdout, format, args);
+inline int vprintf(string_view format, printf_args args) {
+  return vfprintf(stdout, format, args);
 }
 
-inline int vprintf(wstring_view format, wprintf_args args)
-{
-    return vfprintf(stdout, format, args);
+inline int vprintf(wstring_view format, wprintf_args args) {
+  return vfprintf(stdout, format, args);
 }
 
 /**
@@ -731,32 +671,32 @@ inline int vprintf(wstring_view format, wprintf_args args)
     fmt::printf("Elapsed time: %.2f seconds", 1.23);
   \endrst
  */
-template<typename... Args>
-inline int printf(string_view format_str, const Args &... args)
-{
-    return vprintf(format_str, make_format_args<typename printf_context<internal::buffer>::type>(args...));
+template <typename... Args>
+inline int printf(string_view format_str, const Args & ... args) {
+  return vprintf(format_str,
+    make_format_args<typename printf_context<internal::buffer>::type>(args...));
 }
 
-template<typename... Args>
-inline int printf(wstring_view format_str, const Args &... args)
-{
-    return vprintf(format_str, make_format_args<typename printf_context<internal::wbuffer>::type>(args...));
+template <typename... Args>
+inline int printf(wstring_view format_str, const Args & ... args) {
+  return vprintf(format_str,
+    make_format_args<typename printf_context<internal::wbuffer>::type>(args...));
 }
 
-inline int vfprintf(std::ostream &os, string_view format_str, printf_args args)
-{
-    memory_buffer buffer;
-    printf(buffer, format_str, args);
-    internal::write(os, buffer);
-    return static_cast<int>(buffer.size());
+inline int vfprintf(std::ostream &os, string_view format_str,
+                    printf_args args) {
+  memory_buffer buffer;
+  printf(buffer, format_str, args);
+  internal::write(os, buffer);
+  return static_cast<int>(buffer.size());
 }
 
-inline int vfprintf(std::wostream &os, wstring_view format_str, wprintf_args args)
-{
-    wmemory_buffer buffer;
-    printf(buffer, format_str, args);
-    internal::write(os, buffer);
-    return static_cast<int>(buffer.size());
+inline int vfprintf(std::wostream &os, wstring_view format_str,
+                    wprintf_args args) {
+  wmemory_buffer buffer;
+  printf(buffer, format_str, args);
+  internal::write(os, buffer);
+  return static_cast<int>(buffer.size());
 }
 
 /**
@@ -768,19 +708,21 @@ inline int vfprintf(std::wostream &os, wstring_view format_str, wprintf_args arg
     fmt::fprintf(cerr, "Don't %s!", "panic");
   \endrst
  */
-template<typename... Args>
-inline int fprintf(std::ostream &os, string_view format_str, const Args &... args)
-{
-    auto vargs = make_format_args<typename printf_context<internal::buffer>::type>(args...);
-    return vfprintf(os, format_str, vargs);
+template <typename... Args>
+inline int fprintf(std::ostream &os, string_view format_str,
+                   const Args & ... args) {
+  auto vargs = make_format_args<
+    typename printf_context<internal::buffer>::type>(args...);
+  return vfprintf(os, format_str, vargs);
 }
 
-template<typename... Args>
-inline int fprintf(std::wostream &os, wstring_view format_str, const Args &... args)
-{
-    auto vargs = make_format_args<typename printf_context<internal::buffer>::type>(args...);
-    return vfprintf(os, format_str, vargs);
+template <typename... Args>
+inline int fprintf(std::wostream &os, wstring_view format_str,
+                   const Args & ... args) {
+  auto vargs = make_format_args<
+    typename printf_context<internal::buffer>::type>(args...);
+  return vfprintf(os, format_str, vargs);
 }
 FMT_END_NAMESPACE
 
-#endif // FMT_PRINTF_H_
+#endif  // FMT_PRINTF_H_
diff --git a/include/spdlog/fmt/bundled/ranges.h b/include/spdlog/fmt/bundled/ranges.h
index 0c871cc6..df22f389 100644
--- a/include/spdlog/fmt/bundled/ranges.h
+++ b/include/spdlog/fmt/bundled/ranges.h
@@ -17,326 +17,289 @@
 
 // output only up to N items from the range.
 #ifndef FMT_RANGE_OUTPUT_LENGTH_LIMIT
-#define FMT_RANGE_OUTPUT_LENGTH_LIMIT 256
+# define FMT_RANGE_OUTPUT_LENGTH_LIMIT 256
 #endif
 
 FMT_BEGIN_NAMESPACE
 
-template<typename Char>
-struct formatting_base
-{
-    template<typename ParseContext>
-    FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin())
-    {
-        return ctx.begin();
-    }
+template <typename Char>
+struct formatting_base {
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
 };
 
-template<typename Char, typename Enable = void>
-struct formatting_range : formatting_base<Char>
-{
-    static FMT_CONSTEXPR_DECL const std::size_t range_length_limit =
-        FMT_RANGE_OUTPUT_LENGTH_LIMIT; // output only up to N items from the range.
-    Char prefix;
-    Char delimiter;
-    Char postfix;
-    formatting_range()
-        : prefix('{')
-        , delimiter(',')
-        , postfix('}')
-    {
-    }
-    static FMT_CONSTEXPR_DECL const bool add_delimiter_spaces = true;
-    static FMT_CONSTEXPR_DECL const bool add_prepostfix_space = false;
+template <typename Char, typename Enable = void>
+struct formatting_range : formatting_base<Char> {
+  static FMT_CONSTEXPR_DECL const std::size_t range_length_limit =
+      FMT_RANGE_OUTPUT_LENGTH_LIMIT; // output only up to N items from the range.
+  Char prefix;
+  Char delimiter;
+  Char postfix;
+  formatting_range() : prefix('{'), delimiter(','), postfix('}') {}
+  static FMT_CONSTEXPR_DECL const bool add_delimiter_spaces = true;
+  static FMT_CONSTEXPR_DECL const bool add_prepostfix_space = false;
 };
 
-template<typename Char, typename Enable = void>
-struct formatting_tuple : formatting_base<Char>
-{
-    Char prefix;
-    Char delimiter;
-    Char postfix;
-    formatting_tuple()
-        : prefix('(')
-        , delimiter(',')
-        , postfix(')')
-    {
-    }
-    static FMT_CONSTEXPR_DECL const bool add_delimiter_spaces = true;
-    static FMT_CONSTEXPR_DECL const bool add_prepostfix_space = false;
+template <typename Char, typename Enable = void>
+struct formatting_tuple : formatting_base<Char> {
+  Char prefix;
+  Char delimiter;
+  Char postfix;
+  formatting_tuple() : prefix('('), delimiter(','), postfix(')') {}
+  static FMT_CONSTEXPR_DECL const bool add_delimiter_spaces = true;
+  static FMT_CONSTEXPR_DECL const bool add_prepostfix_space = false;
 };
 
 namespace internal {
 
-template<typename RangeT, typename OutputIterator>
-void copy(const RangeT &range, OutputIterator out)
-{
-    for (auto it = range.begin(), end = range.end(); it != end; ++it)
-        *out++ = *it;
+template <typename RangeT, typename OutputIterator>
+void copy(const RangeT &range, OutputIterator out) {
+  for (auto it = range.begin(), end = range.end(); it != end; ++it)
+    *out++ = *it;
 }
 
-template<typename OutputIterator>
-void copy(const char *str, OutputIterator out)
-{
-    const char *p_curr = str;
-    while (*p_curr)
-    {
-        *out++ = *p_curr++;
-    }
+template <typename OutputIterator>
+void copy(const char *str, OutputIterator out) {
+  const char *p_curr = str;
+  while (*p_curr) {
+    *out++ = *p_curr++;
+  }
 }
 
-template<typename OutputIterator>
-void copy(char ch, OutputIterator out)
-{
-    *out++ = ch;
+template <typename OutputIterator>
+void copy(char ch, OutputIterator out) {
+  *out++ = ch;
 }
 
 /// Return true value if T has std::string interface, like std::string_view.
-template<typename T>
-class is_like_std_string
-{
-    template<typename U>
-    static auto check(U *p) -> decltype(p->find('a'), p->length(), p->data(), int());
-    template<typename>
-    static void check(...);
+template <typename T>
+class is_like_std_string {
+  template <typename U>
+  static auto check(U *p) ->
+    decltype(p->find('a'), p->length(), p->data(), int());
+  template <typename>
+  static void check(...);
 
-public:
-    static FMT_CONSTEXPR_DECL const bool value = !std::is_void<decltype(check<T>(FMT_NULL))>::value;
+ public:
+  static FMT_CONSTEXPR_DECL const bool value =
+    !std::is_void<decltype(check<T>(FMT_NULL))>::value;
 };
 
-template<typename... Ts>
-struct conditional_helper
-{
-};
+template <typename... Ts>
+struct conditional_helper {};
 
-template<typename T, typename _ = void>
-struct is_range_ : std::false_type
-{
-};
+template <typename T, typename _ = void>
+struct is_range_ : std::false_type {};
 
-template<typename T>
-struct is_range_<T, typename std::conditional<false,
-                        conditional_helper<decltype(internal::declval<T>().begin()), decltype(internal::declval<T>().end())>, void>::type>
-    : std::true_type
-{
-};
+#if !FMT_MSC_VER || FMT_MSC_VER > 1800
+template <typename T>
+struct is_range_<T, typename std::conditional<
+                    false,
+                    conditional_helper<decltype(internal::declval<T>().begin()),
+                                       decltype(internal::declval<T>().end())>,
+                    void>::type> : std::true_type {};
+#endif
 
 /// tuple_size and tuple_element check.
-template<typename T>
-class is_tuple_like_
-{
-    template<typename U>
-    static auto check(U *p) -> decltype(std::tuple_size<U>::value, internal::declval<typename std::tuple_element<0, U>::type>(), int());
-    template<typename>
-    static void check(...);
+template <typename T>
+class is_tuple_like_ {
+  template <typename U>
+  static auto check(U *p) ->
+    decltype(std::tuple_size<U>::value,
+      internal::declval<typename std::tuple_element<0, U>::type>(), int());
+  template <typename>
+  static void check(...);
 
-public:
-    static FMT_CONSTEXPR_DECL const bool value = !std::is_void<decltype(check<T>(FMT_NULL))>::value;
+ public:
+  static FMT_CONSTEXPR_DECL const bool value =
+    !std::is_void<decltype(check<T>(FMT_NULL))>::value;
 };
 
 // Check for integer_sequence
 #if defined(__cpp_lib_integer_sequence) || FMT_MSC_VER >= 1900
-template<typename T, T... N>
+template <typename T, T... N>
 using integer_sequence = std::integer_sequence<T, N...>;
-template<std::size_t... N>
+template <std::size_t... N>
 using index_sequence = std::index_sequence<N...>;
-template<std::size_t N>
+template <std::size_t N>
 using make_index_sequence = std::make_index_sequence<N>;
 #else
-template<typename T, T... N>
-struct integer_sequence
-{
-    typedef T value_type;
+template <typename T, T... N>
+struct integer_sequence {
+  typedef T value_type;
 
-    static FMT_CONSTEXPR std::size_t size()
-    {
-        return sizeof...(N);
-    }
+  static FMT_CONSTEXPR std::size_t size() {
+    return sizeof...(N);
+  }
 };
 
-template<std::size_t... N>
+template <std::size_t... N>
 using index_sequence = integer_sequence<std::size_t, N...>;
 
-template<typename T, std::size_t N, T... Ns>
-struct make_integer_sequence : make_integer_sequence<T, N - 1, N - 1, Ns...>
-{
-};
-template<typename T, T... Ns>
-struct make_integer_sequence<T, 0, Ns...> : integer_sequence<T, Ns...>
-{
-};
+template <typename T, std::size_t N, T... Ns>
+struct make_integer_sequence : make_integer_sequence<T, N - 1, N - 1, Ns...> {};
+template <typename T, T... Ns>
+struct make_integer_sequence<T, 0, Ns...> : integer_sequence<T, Ns...> {};
 
-template<std::size_t N>
+template <std::size_t N>
 using make_index_sequence = make_integer_sequence<std::size_t, N>;
 #endif
 
-template<class Tuple, class F, size_t... Is>
-void for_each(index_sequence<Is...>, Tuple &&tup, F &&f) noexcept
-{
-    using std::get;
-    // using free function get<I>(T) now.
-    const int _[] = {0, ((void)f(get<Is>(tup)), 0)...};
-    (void)_; // blocks warnings
+template <class Tuple, class F, size_t... Is>
+void for_each(index_sequence<Is...>, Tuple &&tup, F &&f) FMT_NOEXCEPT {
+  using std::get;
+  // using free function get<I>(T) now.
+  const int _[] = {0, ((void)f(get<Is>(tup)), 0)...};
+  (void)_;  // blocks warnings
 }
 
-template<class T>
-FMT_CONSTEXPR make_index_sequence<std::tuple_size<T>::value> get_indexes(T const &)
-{
-    return {};
-}
+template <class T>
+FMT_CONSTEXPR make_index_sequence<std::tuple_size<T>::value> 
+get_indexes(T const &) { return {}; }
 
-template<class Tuple, class F>
-void for_each(Tuple &&tup, F &&f)
-{
-    const auto indexes = get_indexes(tup);
-    for_each(indexes, std::forward<Tuple>(tup), std::forward<F>(f));
+template <class Tuple, class F>
+void for_each(Tuple &&tup, F &&f) {
+  const auto indexes = get_indexes(tup);
+  for_each(indexes, std::forward<Tuple>(tup), std::forward<F>(f));
 }
 
 template<typename Arg>
-FMT_CONSTEXPR const char *format_str_quoted(
-    bool add_space, const Arg &, typename std::enable_if<!is_like_std_string<typename std::decay<Arg>::type>::value>::type * = nullptr)
-{
-    return add_space ? " {}" : "{}";
+FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const Arg&, 
+  typename std::enable_if<
+    !is_like_std_string<typename std::decay<Arg>::type>::value>::type* = nullptr) {
+  return add_space ? " {}" : "{}";
 }
 
 template<typename Arg>
-FMT_CONSTEXPR const char *format_str_quoted(
-    bool add_space, const Arg &, typename std::enable_if<is_like_std_string<typename std::decay<Arg>::type>::value>::type * = nullptr)
-{
-    return add_space ? " \"{}\"" : "\"{}\"";
+FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const Arg&, 
+  typename std::enable_if<
+    is_like_std_string<typename std::decay<Arg>::type>::value>::type* = nullptr) {
+  return add_space ? " \"{}\"" : "\"{}\"";
 }
 
-FMT_CONSTEXPR const char *format_str_quoted(bool add_space, const char *)
-{
-    return add_space ? " \"{}\"" : "\"{}\"";
+FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const char*) {
+  return add_space ? " \"{}\"" : "\"{}\"";
 }
-FMT_CONSTEXPR const wchar_t *format_str_quoted(bool add_space, const wchar_t *)
-{
+FMT_CONSTEXPR const wchar_t* format_str_quoted(bool add_space, const wchar_t*) {
     return add_space ? L" \"{}\"" : L"\"{}\"";
 }
 
-FMT_CONSTEXPR const char *format_str_quoted(bool add_space, const char)
-{
+FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const char) {
     return add_space ? " '{}'" : "'{}'";
 }
-FMT_CONSTEXPR const wchar_t *format_str_quoted(bool add_space, const wchar_t)
-{
+FMT_CONSTEXPR const wchar_t* format_str_quoted(bool add_space, const wchar_t) {
     return add_space ? L" '{}'" : L"'{}'";
 }
 
-} // namespace internal
+}  // namespace internal
 
-template<typename T>
-struct is_tuple_like
-{
-    static FMT_CONSTEXPR_DECL const bool value = internal::is_tuple_like_<T>::value && !internal::is_range_<T>::value;
+template <typename T>
+struct is_tuple_like {
+  static FMT_CONSTEXPR_DECL const bool value =
+    internal::is_tuple_like_<T>::value && !internal::is_range_<T>::value;
 };
 
-template<typename TupleT, typename Char>
-struct formatter<TupleT, Char, typename std::enable_if<fmt::is_tuple_like<TupleT>::value>::type>
-{
+template <typename TupleT, typename Char>
+struct formatter<TupleT, Char, 
+    typename std::enable_if<fmt::is_tuple_like<TupleT>::value>::type> {
 private:
-    // C++11 generic lambda for format()
-    template<typename FormatContext>
-    struct format_each
-    {
-        template<typename T>
-        void operator()(const T &v)
-        {
-            if (i > 0)
-            {
-                if (formatting.add_prepostfix_space)
-                {
-                    *out++ = ' ';
-                }
-                internal::copy(formatting.delimiter, out);
-            }
-            format_to(out, internal::format_str_quoted((formatting.add_delimiter_spaces && i > 0), v), v);
-            ++i;
+  // C++11 generic lambda for format()
+  template <typename FormatContext>
+  struct format_each {
+    template <typename T>
+    void operator()(const T& v) {
+      if (i > 0) {
+        if (formatting.add_prepostfix_space) {
+          *out++ = ' ';
         }
+        internal::copy(formatting.delimiter, out);
+      }
+      format_to(out,
+                internal::format_str_quoted(
+                    (formatting.add_delimiter_spaces && i > 0), v),
+                v);
+      ++i;
+    }
 
-        formatting_tuple<Char> &formatting;
-        std::size_t &i;
-        typename std::add_lvalue_reference<decltype(std::declval<FormatContext>().out())>::type out;
-    };
+    formatting_tuple<Char>& formatting;
+    std::size_t& i;
+    typename std::add_lvalue_reference<decltype(std::declval<FormatContext>().out())>::type out;
+  };
 
 public:
-    formatting_tuple<Char> formatting;
+  formatting_tuple<Char> formatting;
 
-    template<typename ParseContext>
-    FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin())
-    {
-        return formatting.parse(ctx);
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
+    return formatting.parse(ctx);
+  }
+
+  template <typename FormatContext = format_context>
+  auto format(const TupleT &values, FormatContext &ctx) -> decltype(ctx.out()) {
+    auto out = ctx.out();
+    std::size_t i = 0;
+    internal::copy(formatting.prefix, out);
+
+    internal::for_each(values, format_each<FormatContext>{formatting, i, out});
+    if (formatting.add_prepostfix_space) {
+      *out++ = ' ';
     }
+    internal::copy(formatting.postfix, out);
 
-    template<typename FormatContext = format_context>
-    auto format(const TupleT &values, FormatContext &ctx) -> decltype(ctx.out())
-    {
-        auto out = ctx.out();
-        std::size_t i = 0;
-        internal::copy(formatting.prefix, out);
-
-        internal::for_each(values, format_each<FormatContext>{formatting, i, out});
-        if (formatting.add_prepostfix_space)
-        {
-            *out++ = ' ';
-        }
-        internal::copy(formatting.postfix, out);
-
-        return ctx.out();
-    }
+    return ctx.out();
+  }
 };
 
-template<typename T>
-struct is_range
-{
-    static FMT_CONSTEXPR_DECL const bool value = internal::is_range_<T>::value && !internal::is_like_std_string<T>::value;
+template <typename T>
+struct is_range {
+  static FMT_CONSTEXPR_DECL const bool value =
+    internal::is_range_<T>::value && !internal::is_like_std_string<T>::value;
 };
 
-template<typename RangeT, typename Char>
-struct formatter<RangeT, Char, typename std::enable_if<fmt::is_range<RangeT>::value>::type>
-{
+template <typename RangeT, typename Char>
+struct formatter<RangeT, Char,
+    typename std::enable_if<fmt::is_range<RangeT>::value>::type> {
 
-    formatting_range<Char> formatting;
+  formatting_range<Char> formatting;
 
-    template<typename ParseContext>
-    FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin())
-    {
-        return formatting.parse(ctx);
-    }
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
+    return formatting.parse(ctx);
+  }
 
-    template<typename FormatContext>
-    typename FormatContext::iterator format(const RangeT &values, FormatContext &ctx)
-    {
-        auto out = ctx.out();
-        internal::copy(formatting.prefix, out);
-        std::size_t i = 0;
-        for (auto it = values.begin(), end = values.end(); it != end; ++it)
-        {
-            if (i > 0)
-            {
-                if (formatting.add_prepostfix_space)
-                {
-                    *out++ = ' ';
-                }
-                internal::copy(formatting.delimiter, out);
-            }
-            format_to(out, internal::format_str_quoted((formatting.add_delimiter_spaces && i > 0), *it), *it);
-            if (++i > formatting.range_length_limit)
-            {
-                format_to(out, " ... <other elements>");
-                break;
-            }
+  template <typename FormatContext>
+  typename FormatContext::iterator format(
+      const RangeT &values, FormatContext &ctx) {
+    auto out = ctx.out();
+    internal::copy(formatting.prefix, out);
+    std::size_t i = 0;
+    for (auto it = values.begin(), end = values.end(); it != end; ++it) {
+      if (i > 0) {
+        if (formatting.add_prepostfix_space) {
+          *out++ = ' ';
         }
-        if (formatting.add_prepostfix_space)
-        {
-            *out++ = ' ';
-        }
-        internal::copy(formatting.postfix, out);
-        return ctx.out();
+        internal::copy(formatting.delimiter, out);
+      }
+      format_to(out,
+                internal::format_str_quoted(
+                    (formatting.add_delimiter_spaces && i > 0), *it),
+                *it);
+      if (++i > formatting.range_length_limit) {
+        format_to(out, " ... <other elements>");
+        break;
+      }
     }
+    if (formatting.add_prepostfix_space) {
+      *out++ = ' ';
+    }
+    internal::copy(formatting.postfix, out);
+    return ctx.out();
+  }
 };
 
 FMT_END_NAMESPACE
 
 #endif // FMT_RANGES_H_
+
diff --git a/include/spdlog/fmt/bundled/time.h b/include/spdlog/fmt/bundled/time.h
index 3e1443b8..515452a4 100644
--- a/include/spdlog/fmt/bundled/time.h
+++ b/include/spdlog/fmt/bundled/time.h
@@ -13,187 +13,140 @@
 
 FMT_BEGIN_NAMESPACE
 
-namespace internal {
-inline null<> localtime_r(...)
-{
-    return null<>();
+namespace internal{
+inline null<> localtime_r(...) { return null<>(); }
+inline null<> localtime_s(...) { return null<>(); }
+inline null<> gmtime_r(...) { return null<>(); }
+inline null<> gmtime_s(...) { return null<>(); }
 }
-inline null<> localtime_s(...)
-{
-    return null<>();
-}
-inline null<> gmtime_r(...)
-{
-    return null<>();
-}
-inline null<> gmtime_s(...)
-{
-    return null<>();
-}
-} // namespace internal
 
 // Thread-safe replacement for std::localtime
-inline std::tm localtime(std::time_t time)
-{
-    struct dispatcher
-    {
-        std::time_t time_;
-        std::tm tm_;
+inline std::tm localtime(std::time_t time) {
+  struct dispatcher {
+    std::time_t time_;
+    std::tm tm_;
 
-        dispatcher(std::time_t t)
-            : time_(t)
-        {
-        }
+    dispatcher(std::time_t t): time_(t) {}
 
-        bool run()
-        {
-            using namespace fmt::internal;
-            return handle(localtime_r(&time_, &tm_));
-        }
+    bool run() {
+      using namespace fmt::internal;
+      return handle(localtime_r(&time_, &tm_));
+    }
 
-        bool handle(std::tm *tm)
-        {
-            return tm != FMT_NULL;
-        }
+    bool handle(std::tm *tm) { return tm != FMT_NULL; }
 
-        bool handle(internal::null<>)
-        {
-            using namespace fmt::internal;
-            return fallback(localtime_s(&tm_, &time_));
-        }
+    bool handle(internal::null<>) {
+      using namespace fmt::internal;
+      return fallback(localtime_s(&tm_, &time_));
+    }
 
-        bool fallback(int res)
-        {
-            return res == 0;
-        }
+    bool fallback(int res) { return res == 0; }
 
-        bool fallback(internal::null<>)
-        {
-            using namespace fmt::internal;
-            std::tm *tm = std::localtime(&time_);
-            if (tm)
-                tm_ = *tm;
-            return tm != FMT_NULL;
-        }
-    };
-    dispatcher lt(time);
-    if (lt.run())
-        return lt.tm_;
-    // Too big time values may be unsupported.
-    FMT_THROW(format_error("time_t value out of range"));
+    bool fallback(internal::null<>) {
+      using namespace fmt::internal;
+      std::tm *tm = std::localtime(&time_);
+      if (tm) tm_ = *tm;
+      return tm != FMT_NULL;
+    }
+  };
+  dispatcher lt(time);
+  if (lt.run())
+    return lt.tm_;
+  // Too big time values may be unsupported.
+  FMT_THROW(format_error("time_t value out of range"));
 }
 
 // Thread-safe replacement for std::gmtime
-inline std::tm gmtime(std::time_t time)
-{
-    struct dispatcher
-    {
-        std::time_t time_;
-        std::tm tm_;
+inline std::tm gmtime(std::time_t time) {
+  struct dispatcher {
+    std::time_t time_;
+    std::tm tm_;
 
-        dispatcher(std::time_t t)
-            : time_(t)
-        {
-        }
+    dispatcher(std::time_t t): time_(t) {}
 
-        bool run()
-        {
-            using namespace fmt::internal;
-            return handle(gmtime_r(&time_, &tm_));
-        }
+    bool run() {
+      using namespace fmt::internal;
+      return handle(gmtime_r(&time_, &tm_));
+    }
 
-        bool handle(std::tm *tm)
-        {
-            return tm != FMT_NULL;
-        }
+    bool handle(std::tm *tm) { return tm != FMT_NULL; }
 
-        bool handle(internal::null<>)
-        {
-            using namespace fmt::internal;
-            return fallback(gmtime_s(&tm_, &time_));
-        }
+    bool handle(internal::null<>) {
+      using namespace fmt::internal;
+      return fallback(gmtime_s(&tm_, &time_));
+    }
 
-        bool fallback(int res)
-        {
-            return res == 0;
-        }
+    bool fallback(int res) { return res == 0; }
 
-        bool fallback(internal::null<>)
-        {
-            std::tm *tm = std::gmtime(&time_);
-            if (tm)
-                tm_ = *tm;
-            return tm != FMT_NULL;
-        }
-    };
-    dispatcher gt(time);
-    if (gt.run())
-        return gt.tm_;
-    // Too big time values may be unsupported.
-    FMT_THROW(format_error("time_t value out of range"));
+    bool fallback(internal::null<>) {
+      std::tm *tm = std::gmtime(&time_);
+      if (tm) tm_ = *tm;
+      return tm != FMT_NULL;
+    }
+  };
+  dispatcher gt(time);
+  if (gt.run())
+    return gt.tm_;
+  // Too big time values may be unsupported.
+  FMT_THROW(format_error("time_t value out of range"));
 }
 
 namespace internal {
-inline std::size_t strftime(char *str, std::size_t count, const char *format, const std::tm *time)
-{
-    return std::strftime(str, count, format, time);
+inline std::size_t strftime(char *str, std::size_t count, const char *format,
+                            const std::tm *time) {
+  return std::strftime(str, count, format, time);
 }
 
-inline std::size_t strftime(wchar_t *str, std::size_t count, const wchar_t *format, const std::tm *time)
-{
-    return std::wcsftime(str, count, format, time);
+inline std::size_t strftime(wchar_t *str, std::size_t count,
+                            const wchar_t *format, const std::tm *time) {
+  return std::wcsftime(str, count, format, time);
+}
 }
-} // namespace internal
 
-template<typename Char>
-struct formatter<std::tm, Char>
-{
-    template<typename ParseContext>
-    auto parse(ParseContext &ctx) -> decltype(ctx.begin())
-    {
-        auto it = internal::null_terminating_iterator<Char>(ctx);
-        if (*it == ':')
-            ++it;
-        auto end = it;
-        while (*end && *end != '}')
-            ++end;
-        tm_format.reserve(end - it + 1);
-        using internal::pointer_from;
-        tm_format.append(pointer_from(it), pointer_from(end));
-        tm_format.push_back('\0');
-        return pointer_from(end);
+template <typename Char>
+struct formatter<std::tm, Char> {
+  template <typename ParseContext>
+  auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
+    auto it = internal::null_terminating_iterator<Char>(ctx);
+    if (*it == ':')
+      ++it;
+    auto end = it;
+    while (*end && *end != '}')
+      ++end;
+    tm_format.reserve(end - it + 1);
+    using internal::pointer_from;
+    tm_format.append(pointer_from(it), pointer_from(end));
+    tm_format.push_back('\0');
+    return pointer_from(end);
+  }
+
+  template <typename FormatContext>
+  auto format(const std::tm &tm, FormatContext &ctx) -> decltype(ctx.out()) {
+    internal::basic_buffer<Char> &buf = internal::get_container(ctx.out());
+    std::size_t start = buf.size();
+    for (;;) {
+      std::size_t size = buf.capacity() - start;
+      std::size_t count =
+        internal::strftime(&buf[start], size, &tm_format[0], &tm);
+      if (count != 0) {
+        buf.resize(start + count);
+        break;
+      }
+      if (size >= tm_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;
+      buf.reserve(buf.capacity() + (size > MIN_GROWTH ? size : MIN_GROWTH));
     }
+    return ctx.out();
+  }
 
-    template<typename FormatContext>
-    auto format(const std::tm &tm, FormatContext &ctx) -> decltype(ctx.out())
-    {
-        internal::basic_buffer<Char> &buf = internal::get_container(ctx.out());
-        std::size_t start = buf.size();
-        for (;;)
-        {
-            std::size_t size = buf.capacity() - start;
-            std::size_t count = internal::strftime(&buf[start], size, &tm_format[0], &tm);
-            if (count != 0)
-            {
-                buf.resize(start + count);
-                break;
-            }
-            if (size >= tm_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;
-            buf.reserve(buf.capacity() + (size > MIN_GROWTH ? size : MIN_GROWTH));
-        }
-        return ctx.out();
-    }
-
-    basic_memory_buffer<Char> tm_format;
+  basic_memory_buffer<Char> tm_format;
 };
 FMT_END_NAMESPACE
 
-#endif // FMT_TIME_H_
+#endif  // FMT_TIME_H_

From 3c40c5ca5d04dbcab76914178408d3ee87db170d Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Sun, 8 Jul 2018 16:20:28 +0300
Subject: [PATCH 24/50] Added mulitsink example

---
 example/example.cpp | 25 +++++++++++++++++++++++--
 1 file changed, 23 insertions(+), 2 deletions(-)

diff --git a/example/example.cpp b/example/example.cpp
index 113cf454..1ee4c003 100644
--- a/example/example.cpp
+++ b/example/example.cpp
@@ -14,6 +14,7 @@ void basic_example();
 void rotating_example();
 void daily_example();
 void async_example();
+void multi_sink_example();
 void user_defined_example();
 void err_handler_example();
 void syslog_example();
@@ -35,6 +36,9 @@ int main(int, char *[])
         // async logging using a backing thread pool
         async_example();
 
+        // a logger can have multiple targets with different formats
+        multi_sink_example();
+
         // user defined types logging by implementing operator<<
         user_defined_example();
 
@@ -63,7 +67,7 @@ void stdout_example()
     console->info("Welcome to spdlog!");
     console->error("Some error message with arg: {}", 1);
 
-    auto err_logger = spdlog::stderr_color_mt("error_logger");
+    auto err_logger = spdlog::stderr_color_mt("stderr");
     err_logger->error("Some error message");
 
     // Formatting examples
@@ -82,7 +86,7 @@ void stdout_example()
     console->debug("This message should be displayed..");
 
     // Customize msg format for all loggers
-    spdlog::set_pattern("[%H:%M:%S %z] [%^---%L---%$] [thread %t] %v");
+    spdlog::set_pattern("[%H:%M:%S %z] [%n] [%^---%L---%$] [thread %t] %v");
     console->info("This an info message with custom format");
 
     // Compile time log levels
@@ -127,6 +131,23 @@ void async_example()
     }
 }
 
+// create logger with 2 targets with different  log levels and formats
+
+void multi_sink_example()
+{
+
+    auto console_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt >();
+    console_sink->set_level(spdlog::level::warn);
+    console_sink->set_pattern("[multi_sink_example] [%^%l%$] %v");
+
+    auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt >("logs/multisink.txt", true);
+    file_sink->set_level(spdlog::level::info);
+
+    spdlog::logger logger("multi_sink", {console_sink, file_sink});
+    logger.warn("this should appear in both console and file");
+    logger.info("this message should not appear in the console, only in the file");
+
+}
 // user defined types logging by implementing operator<<
 #include "spdlog/fmt/ostr.h" // must be included
 struct my_type

From 5bfeb672f74018da0433ad2b3d28fefd102266db Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Sun, 8 Jul 2018 16:22:04 +0300
Subject: [PATCH 25/50] updated slot size in async queue

---
 include/spdlog/details/thread_pool.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/spdlog/details/thread_pool.h b/include/spdlog/details/thread_pool.h
index 4c4792df..cec47c60 100644
--- a/include/spdlog/details/thread_pool.h
+++ b/include/spdlog/details/thread_pool.h
@@ -29,7 +29,7 @@ struct async_msg
     level::level_enum level;
     log_clock::time_point time;
     size_t thread_id;
-    fmt::basic_memory_buffer<char, 128> raw;
+    fmt::basic_memory_buffer<char, 176> raw;
 
     size_t msg_id;
     async_logger_ptr worker_ptr;

From 1fd166d4173b49638dd51188088407216f6911ad Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Sun, 8 Jul 2018 16:26:14 +0300
Subject: [PATCH 26/50] Updated example

---
 example/example.cpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/example/example.cpp b/example/example.cpp
index 1ee4c003..c848141d 100644
--- a/example/example.cpp
+++ b/example/example.cpp
@@ -131,22 +131,22 @@ void async_example()
     }
 }
 
-// create logger with 2 targets with different  log levels and formats
+// create logger with 2 targets with different log levels and formats
+// the console will show only warnings or errors, while the file will log all
 
 void multi_sink_example()
 {
-
-    auto console_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt >();
+    auto console_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
     console_sink->set_level(spdlog::level::warn);
     console_sink->set_pattern("[multi_sink_example] [%^%l%$] %v");
 
-    auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt >("logs/multisink.txt", true);
-    file_sink->set_level(spdlog::level::info);
+    auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>("logs/multisink.txt", true);
+    file_sink->set_level(spdlog::level::trace);
 
     spdlog::logger logger("multi_sink", {console_sink, file_sink});
+    logger.set_level(spdlog::level::debug);
     logger.warn("this should appear in both console and file");
     logger.info("this message should not appear in the console, only in the file");
-
 }
 // user defined types logging by implementing operator<<
 #include "spdlog/fmt/ostr.h" // must be included

From 81f3cc5575210aa0c315da00524e99a412624433 Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Sun, 8 Jul 2018 16:26:25 +0300
Subject: [PATCH 27/50] clang format

---
 include/spdlog/details/pattern_formatter.h |    4 +-
 include/spdlog/fmt/bundled/core.h          | 1891 +++---
 include/spdlog/fmt/bundled/format-inl.h    |  901 +--
 include/spdlog/fmt/bundled/format.h        | 6726 +++++++++++---------
 include/spdlog/fmt/bundled/ostream.h       |  211 +-
 include/spdlog/fmt/bundled/posix.h         |  569 +-
 include/spdlog/fmt/bundled/printf.h        | 1191 ++--
 include/spdlog/fmt/bundled/ranges.h        |  439 +-
 include/spdlog/fmt/bundled/time.h          |  261 +-
 include/spdlog/sinks/sink.h                |    1 -
 10 files changed, 6734 insertions(+), 5460 deletions(-)

diff --git a/include/spdlog/details/pattern_formatter.h b/include/spdlog/details/pattern_formatter.h
index 02c749f7..f06a29d4 100644
--- a/include/spdlog/details/pattern_formatter.h
+++ b/include/spdlog/details/pattern_formatter.h
@@ -339,9 +339,9 @@ public:
             dest.push_back('+');
         }
 
-        fmt_helper::pad2(total_minutes / 60, dest); //hours
+        fmt_helper::pad2(total_minutes / 60, dest); // hours
         dest.push_back(':');
-        fmt_helper::pad2(total_minutes % 60, dest); //minutes
+        fmt_helper::pad2(total_minutes % 60, dest); // minutes
     }
 
 private:
diff --git a/include/spdlog/fmt/bundled/core.h b/include/spdlog/fmt/bundled/core.h
index 1303f559..4627789a 100644
--- a/include/spdlog/fmt/bundled/core.h
+++ b/include/spdlog/fmt/bundled/core.h
@@ -19,182 +19,179 @@
 #define FMT_VERSION 50100
 
 #ifdef __has_feature
-# define FMT_HAS_FEATURE(x) __has_feature(x)
+#define FMT_HAS_FEATURE(x) __has_feature(x)
 #else
-# define FMT_HAS_FEATURE(x) 0
+#define FMT_HAS_FEATURE(x) 0
 #endif
 
 #ifdef __has_include
-# define FMT_HAS_INCLUDE(x) __has_include(x)
+#define FMT_HAS_INCLUDE(x) __has_include(x)
 #else
-# define FMT_HAS_INCLUDE(x) 0
+#define FMT_HAS_INCLUDE(x) 0
 #endif
 
 #ifdef __has_cpp_attribute
-# define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
+#define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
 #else
-# define FMT_HAS_CPP_ATTRIBUTE(x) 0
+#define FMT_HAS_CPP_ATTRIBUTE(x) 0
 #endif
 
 #if defined(__GNUC__) && !defined(__clang__)
-# define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
+#define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
 #else
-# define FMT_GCC_VERSION 0
+#define FMT_GCC_VERSION 0
 #endif
 
 #if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__)
-# define FMT_HAS_GXX_CXX11 FMT_GCC_VERSION
+#define FMT_HAS_GXX_CXX11 FMT_GCC_VERSION
 #else
-# define FMT_HAS_GXX_CXX11 0
+#define FMT_HAS_GXX_CXX11 0
 #endif
 
 #ifdef _MSC_VER
-# define FMT_MSC_VER _MSC_VER
+#define FMT_MSC_VER _MSC_VER
 #else
-# define FMT_MSC_VER 0
+#define FMT_MSC_VER 0
 #endif
 
 // Check if relaxed c++14 constexpr is supported.
 // GCC doesn't allow throw in constexpr until version 6 (bug 67371).
 #ifndef FMT_USE_CONSTEXPR
-# define FMT_USE_CONSTEXPR \
-  (FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VER >= 1910 || \
-   (FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L))
+#define FMT_USE_CONSTEXPR                                                                                                                  \
+    (FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VER >= 1910 || (FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L))
 #endif
 #if FMT_USE_CONSTEXPR
-# define FMT_CONSTEXPR constexpr
-# define FMT_CONSTEXPR_DECL constexpr
+#define FMT_CONSTEXPR constexpr
+#define FMT_CONSTEXPR_DECL constexpr
 #else
-# define FMT_CONSTEXPR inline
-# define FMT_CONSTEXPR_DECL
+#define FMT_CONSTEXPR inline
+#define FMT_CONSTEXPR_DECL
 #endif
 
 #ifndef FMT_OVERRIDE
-# if 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
+#if 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
 
-#if FMT_HAS_FEATURE(cxx_explicit_conversions) || \
-    FMT_MSC_VER >= 1800
-# define FMT_EXPLICIT explicit
+#if FMT_HAS_FEATURE(cxx_explicit_conversions) || FMT_MSC_VER >= 1800
+#define FMT_EXPLICIT explicit
 #else
-# define FMT_EXPLICIT
+#define FMT_EXPLICIT
 #endif
 
 #ifndef FMT_NULL
-# if FMT_HAS_FEATURE(cxx_nullptr) || \
-   (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || \
-   FMT_MSC_VER >= 1600
-#  define FMT_NULL nullptr
-#  define FMT_USE_NULLPTR 1
-# else
-#  define FMT_NULL NULL
-# endif
+#if FMT_HAS_FEATURE(cxx_nullptr) || (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1600
+#define FMT_NULL nullptr
+#define FMT_USE_NULLPTR 1
+#else
+#define FMT_NULL NULL
+#endif
 #endif
 
 #ifndef FMT_USE_NULLPTR
-# define FMT_USE_NULLPTR 0
+#define FMT_USE_NULLPTR 0
 #endif
 
 #if FMT_HAS_CPP_ATTRIBUTE(noreturn)
-# define FMT_NORETURN [[noreturn]]
+#define FMT_NORETURN [[noreturn]]
 #else
-# define FMT_NORETURN
+#define FMT_NORETURN
 #endif
 
 // Check if exceptions are disabled.
 #if defined(__GNUC__) && !defined(__EXCEPTIONS)
-# define FMT_EXCEPTIONS 0
+#define FMT_EXCEPTIONS 0
 #elif FMT_MSC_VER && !_HAS_EXCEPTIONS
-# define FMT_EXCEPTIONS 0
+#define FMT_EXCEPTIONS 0
 #endif
 #ifndef FMT_EXCEPTIONS
-# define FMT_EXCEPTIONS 1
+#define FMT_EXCEPTIONS 1
 #endif
 
 // Define FMT_USE_NOEXCEPT to make fmt use noexcept (C++11 feature).
 #ifndef FMT_USE_NOEXCEPT
-# define FMT_USE_NOEXCEPT 0
+#define FMT_USE_NOEXCEPT 0
 #endif
 
-#if FMT_USE_NOEXCEPT || FMT_HAS_FEATURE(cxx_noexcept) || \
-    (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || \
-    FMT_MSC_VER >= 1900
-# define FMT_DETECTED_NOEXCEPT noexcept
+#if FMT_USE_NOEXCEPT || FMT_HAS_FEATURE(cxx_noexcept) || (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900
+#define FMT_DETECTED_NOEXCEPT noexcept
 #else
-# define FMT_DETECTED_NOEXCEPT throw()
+#define FMT_DETECTED_NOEXCEPT throw()
 #endif
 
 #ifndef FMT_NOEXCEPT
-# if FMT_EXCEPTIONS
-#  define FMT_NOEXCEPT FMT_DETECTED_NOEXCEPT
-# else
-#  define FMT_NOEXCEPT
-# endif
+#if FMT_EXCEPTIONS
+#define FMT_NOEXCEPT FMT_DETECTED_NOEXCEPT
+#else
+#define FMT_NOEXCEPT
+#endif
 #endif
 
 // This is needed because GCC still uses throw() in its headers when exceptions
 // are disabled.
 #if FMT_GCC_VERSION
-# define FMT_DTOR_NOEXCEPT FMT_DETECTED_NOEXCEPT
+#define FMT_DTOR_NOEXCEPT FMT_DETECTED_NOEXCEPT
 #else
-# define FMT_DTOR_NOEXCEPT FMT_NOEXCEPT
+#define FMT_DTOR_NOEXCEPT FMT_NOEXCEPT
 #endif
 
 #ifndef FMT_BEGIN_NAMESPACE
-# if FMT_HAS_FEATURE(cxx_inline_namespaces) || FMT_GCC_VERSION >= 404 || \
-     FMT_MSC_VER >= 1900
-#  define FMT_INLINE_NAMESPACE inline namespace
-#  define FMT_END_NAMESPACE }}
-# else
-#  define FMT_INLINE_NAMESPACE namespace
-#  define FMT_END_NAMESPACE } using namespace v5; }
-# endif
-# define FMT_BEGIN_NAMESPACE namespace fmt { FMT_INLINE_NAMESPACE v5 {
+#if FMT_HAS_FEATURE(cxx_inline_namespaces) || FMT_GCC_VERSION >= 404 || FMT_MSC_VER >= 1900
+#define FMT_INLINE_NAMESPACE inline namespace
+#define FMT_END_NAMESPACE                                                                                                                  \
+    }                                                                                                                                      \
+    }
+#else
+#define FMT_INLINE_NAMESPACE namespace
+#define FMT_END_NAMESPACE                                                                                                                  \
+    }                                                                                                                                      \
+    using namespace v5;                                                                                                                    \
+    }
+#endif
+#define FMT_BEGIN_NAMESPACE                                                                                                                \
+    namespace fmt {                                                                                                                        \
+    FMT_INLINE_NAMESPACE v5                                                                                                                \
+    {
 #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
+#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
+#define FMT_API
 #endif
 
 #ifndef FMT_ASSERT
-# define FMT_ASSERT(condition, message) assert((condition) && message)
+#define FMT_ASSERT(condition, message) assert((condition) && message)
 #endif
 
 #define FMT_DELETED = delete
 
 // A macro to disallow the copy construction and assignment.
-#define FMT_DISALLOW_COPY_AND_ASSIGN(Type) \
-    Type(const Type &) FMT_DELETED; \
+#define FMT_DISALLOW_COPY_AND_ASSIGN(Type)                                                                                                 \
+    Type(const Type &) FMT_DELETED;                                                                                                        \
     void operator=(const Type &) FMT_DELETED
 
 // libc++ supports string_view in pre-c++17.
-#if (FMT_HAS_INCLUDE(<string_view>) && \
-      (__cplusplus > 201402L || defined(_LIBCPP_VERSION))) || \
+#if (FMT_HAS_INCLUDE(<string_view>) && (__cplusplus > 201402L || defined(_LIBCPP_VERSION))) ||                                             \
     (defined(_MSVC_LANG) && _MSVC_LANG > 201402L && _MSC_VER >= 1910)
-# include <string_view>
-# define FMT_USE_STD_STRING_VIEW
-#elif (FMT_HAS_INCLUDE(<experimental/string_view>) && \
-       __cplusplus >= 201402L)
-# include <experimental/string_view>
-# define FMT_USE_EXPERIMENTAL_STRING_VIEW
+#include <string_view>
+#define FMT_USE_STD_STRING_VIEW
+#elif (FMT_HAS_INCLUDE(<experimental / string_view>) && __cplusplus >= 201402L)
+#include <experimental/string_view>
+#define FMT_USE_EXPERIMENTAL_STRING_VIEW
 #endif
 
 // std::result_of is defined in <functional> in gcc 4.4.
 #if FMT_GCC_VERSION && FMT_GCC_VERSION <= 404
-# include <functional>
+#include <functional>
 #endif
 
 FMT_BEGIN_NAMESPACE
@@ -202,17 +199,18 @@ FMT_BEGIN_NAMESPACE
 namespace internal {
 
 // An implementation of declval for pre-C++11 compilers such as gcc 4.
-template <typename T>
+template<typename T>
 typename std::add_rvalue_reference<T>::type declval() FMT_NOEXCEPT;
 
 // Casts nonnegative integer to unsigned.
-template <typename Int>
-FMT_CONSTEXPR typename std::make_unsigned<Int>::type to_unsigned(Int value) {
-  FMT_ASSERT(value >= 0, "negative value");
-  return static_cast<typename std::make_unsigned<Int>::type>(value);
+template<typename Int>
+FMT_CONSTEXPR typename std::make_unsigned<Int>::type to_unsigned(Int value)
+{
+    FMT_ASSERT(value >= 0, "negative value");
+    return static_cast<typename std::make_unsigned<Int>::type>(value);
 }
 
-}
+} // namespace internal
 
 /**
   An implementation of ``std::basic_string_view`` for pre-C++17. It provides a
@@ -221,361 +219,480 @@ FMT_CONSTEXPR typename std::make_unsigned<Int>::type to_unsigned(Int value) {
   compiled with a different ``-std`` option than the client code (which is not
   recommended).
  */
-template <typename Char>
-class basic_string_view {
- private:
-  const Char *data_;
-  size_t size_;
+template<typename Char>
+class basic_string_view
+{
+private:
+    const Char *data_;
+    size_t size_;
 
- public:
-  typedef Char char_type;
-  typedef const Char *iterator;
+public:
+    typedef Char char_type;
+    typedef const Char *iterator;
 
-  // Standard basic_string_view type.
+    // Standard basic_string_view type.
 #if defined(FMT_USE_STD_STRING_VIEW)
-  typedef std::basic_string_view<Char> type;
+    typedef std::basic_string_view<Char> type;
 #elif defined(FMT_USE_EXPERIMENTAL_STRING_VIEW)
-  typedef std::experimental::basic_string_view<Char> type;
+    typedef std::experimental::basic_string_view<Char> type;
 #else
-  struct type {
-    const char *data() const { return FMT_NULL; }
-    size_t size() const { return 0; }
-  };
+    struct type
+    {
+        const char *data() const
+        {
+            return FMT_NULL;
+        }
+        size_t size() const
+        {
+            return 0;
+        }
+    };
 #endif
 
-  FMT_CONSTEXPR basic_string_view() FMT_NOEXCEPT : data_(FMT_NULL), size_(0) {}
+    FMT_CONSTEXPR basic_string_view() FMT_NOEXCEPT : data_(FMT_NULL), size_(0) {}
 
-  /** Constructs a string reference object from a C string and a size. */
-  FMT_CONSTEXPR basic_string_view(const Char *s, size_t count) FMT_NOEXCEPT
-    : data_(s), size_(count) {}
+    /** Constructs a string reference object from a C string and a size. */
+    FMT_CONSTEXPR basic_string_view(const Char *s, size_t count) FMT_NOEXCEPT : data_(s), size_(count) {}
 
-  /**
-    \rst
-    Constructs a string reference object from a C string computing
-    the size with ``std::char_traits<Char>::length``.
-    \endrst
-   */
-  basic_string_view(const Char *s)
-    : data_(s), size_(std::char_traits<Char>::length(s)) {}
+    /**
+      \rst
+      Constructs a string reference object from a C string computing
+      the size with ``std::char_traits<Char>::length``.
+      \endrst
+     */
+    basic_string_view(const Char *s)
+        : data_(s)
+        , size_(std::char_traits<Char>::length(s))
+    {
+    }
 
-  /** Constructs a string reference from a ``std::basic_string`` object. */
-  template <typename Alloc>
-  FMT_CONSTEXPR basic_string_view(
-      const std::basic_string<Char, Alloc> &s) FMT_NOEXCEPT
-  : data_(s.c_str()), size_(s.size()) {}
+    /** Constructs a string reference from a ``std::basic_string`` object. */
+    template<typename Alloc>
+    FMT_CONSTEXPR basic_string_view(const std::basic_string<Char, Alloc> &s) FMT_NOEXCEPT : data_(s.c_str()), size_(s.size())
+    {
+    }
 
-  FMT_CONSTEXPR basic_string_view(type s) FMT_NOEXCEPT
-  : data_(s.data()), size_(s.size()) {}
+    FMT_CONSTEXPR basic_string_view(type s) FMT_NOEXCEPT : data_(s.data()), size_(s.size()) {}
 
-  /** Returns a pointer to the string data. */
-  const Char *data() const { return data_; }
+    /** Returns a pointer to the string data. */
+    const Char *data() const
+    {
+        return data_;
+    }
 
-  /** Returns the string size. */
-  FMT_CONSTEXPR size_t size() const { return size_; }
+    /** Returns the string size. */
+    FMT_CONSTEXPR size_t size() const
+    {
+        return size_;
+    }
 
-  FMT_CONSTEXPR iterator begin() const { return data_; }
-  FMT_CONSTEXPR iterator end() const { return data_ + size_; }
+    FMT_CONSTEXPR iterator begin() const
+    {
+        return data_;
+    }
+    FMT_CONSTEXPR iterator end() const
+    {
+        return data_ + size_;
+    }
 
-  FMT_CONSTEXPR void remove_prefix(size_t n) {
-    data_ += n;
-    size_ -= n;
-  }
+    FMT_CONSTEXPR void remove_prefix(size_t n)
+    {
+        data_ += n;
+        size_ -= n;
+    }
 
-  // Lexicographically compare this string reference to other.
-  int compare(basic_string_view other) const {
-    size_t str_size = size_ < other.size_ ? size_ : other.size_;
-    int result = std::char_traits<Char>::compare(data_, other.data_, str_size);
-    if (result == 0)
-      result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);
-    return result;
-  }
+    // Lexicographically compare this string reference to other.
+    int compare(basic_string_view other) const
+    {
+        size_t str_size = size_ < other.size_ ? size_ : other.size_;
+        int result = std::char_traits<Char>::compare(data_, other.data_, str_size);
+        if (result == 0)
+            result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);
+        return result;
+    }
 
-  friend bool operator==(basic_string_view lhs, basic_string_view rhs) {
-    return lhs.compare(rhs) == 0;
-  }
-  friend bool operator!=(basic_string_view lhs, basic_string_view rhs) {
-    return lhs.compare(rhs) != 0;
-  }
-  friend bool operator<(basic_string_view lhs, basic_string_view rhs) {
-    return lhs.compare(rhs) < 0;
-  }
-  friend bool operator<=(basic_string_view lhs, basic_string_view rhs) {
-    return lhs.compare(rhs) <= 0;
-  }
-  friend bool operator>(basic_string_view lhs, basic_string_view rhs) {
-    return lhs.compare(rhs) > 0;
-  }
-  friend bool operator>=(basic_string_view lhs, basic_string_view rhs) {
-    return lhs.compare(rhs) >= 0;
-  }
+    friend bool operator==(basic_string_view lhs, basic_string_view rhs)
+    {
+        return lhs.compare(rhs) == 0;
+    }
+    friend bool operator!=(basic_string_view lhs, basic_string_view rhs)
+    {
+        return lhs.compare(rhs) != 0;
+    }
+    friend bool operator<(basic_string_view lhs, basic_string_view rhs)
+    {
+        return lhs.compare(rhs) < 0;
+    }
+    friend bool operator<=(basic_string_view lhs, basic_string_view rhs)
+    {
+        return lhs.compare(rhs) <= 0;
+    }
+    friend bool operator>(basic_string_view lhs, basic_string_view rhs)
+    {
+        return lhs.compare(rhs) > 0;
+    }
+    friend bool operator>=(basic_string_view lhs, basic_string_view rhs)
+    {
+        return lhs.compare(rhs) >= 0;
+    }
 };
 
 typedef basic_string_view<char> string_view;
 typedef basic_string_view<wchar_t> wstring_view;
 
-template <typename Context>
+template<typename Context>
 class basic_format_arg;
 
-template <typename Context>
+template<typename Context>
 class basic_format_args;
 
 // A formatter for objects of type T.
-template <typename T, typename Char = char, typename Enable = void>
+template<typename T, typename Char = char, typename Enable = void>
 struct formatter;
 
 namespace internal {
 
 /** A contiguous memory buffer with an optional growing ability. */
-template <typename T>
-class basic_buffer {
- private:
-  FMT_DISALLOW_COPY_AND_ASSIGN(basic_buffer);
+template<typename T>
+class basic_buffer
+{
+private:
+    FMT_DISALLOW_COPY_AND_ASSIGN(basic_buffer);
 
-  T *ptr_;
-  std::size_t size_;
-  std::size_t capacity_;
+    T *ptr_;
+    std::size_t size_;
+    std::size_t capacity_;
 
- protected:
-  basic_buffer(T *p = FMT_NULL, std::size_t sz = 0, std::size_t cap = 0)
-    FMT_NOEXCEPT: ptr_(p), size_(sz), capacity_(cap) {}
+protected:
+    basic_buffer(T *p = FMT_NULL, std::size_t sz = 0, std::size_t cap = 0) FMT_NOEXCEPT : ptr_(p), size_(sz), capacity_(cap) {}
 
-  /** Sets the buffer data and capacity. */
-  void set(T *buf_data, std::size_t buf_capacity) FMT_NOEXCEPT {
-    ptr_ = buf_data;
-    capacity_ = buf_capacity;
-  }
+    /** Sets the buffer data and capacity. */
+    void set(T *buf_data, std::size_t buf_capacity) FMT_NOEXCEPT
+    {
+        ptr_ = buf_data;
+        capacity_ = buf_capacity;
+    }
 
-  /** Increases the buffer capacity to hold at least *capacity* elements. */
-  virtual void grow(std::size_t capacity) = 0;
+    /** Increases the buffer capacity to hold at least *capacity* elements. */
+    virtual void grow(std::size_t capacity) = 0;
 
- public:
-  typedef T value_type;
-  typedef const T &const_reference;
+public:
+    typedef T value_type;
+    typedef const T &const_reference;
 
-  virtual ~basic_buffer() {}
+    virtual ~basic_buffer() {}
 
-  T *begin() FMT_NOEXCEPT { return ptr_; }
-  T *end() FMT_NOEXCEPT { return ptr_ + size_; }
+    T *begin() FMT_NOEXCEPT
+    {
+        return ptr_;
+    }
+    T *end() FMT_NOEXCEPT
+    {
+        return ptr_ + size_;
+    }
 
-  /** Returns the size of this buffer. */
-  std::size_t size() const FMT_NOEXCEPT { return size_; }
+    /** Returns the size of this buffer. */
+    std::size_t size() const FMT_NOEXCEPT
+    {
+        return size_;
+    }
 
-  /** Returns the capacity of this buffer. */
-  std::size_t capacity() const FMT_NOEXCEPT { return capacity_; }
+    /** Returns the capacity of this buffer. */
+    std::size_t capacity() const FMT_NOEXCEPT
+    {
+        return capacity_;
+    }
 
-  /** Returns a pointer to the buffer data. */
-  T *data() FMT_NOEXCEPT { return ptr_; }
+    /** Returns a pointer to the buffer data. */
+    T *data() FMT_NOEXCEPT
+    {
+        return ptr_;
+    }
 
-  /** Returns a pointer to the buffer data. */
-  const T *data() const FMT_NOEXCEPT { return ptr_; }
+    /** Returns a pointer to the buffer data. */
+    const T *data() const FMT_NOEXCEPT
+    {
+        return ptr_;
+    }
 
-  /**
-    Resizes the buffer. If T is a POD type new elements may not be initialized.
-   */
-  void resize(std::size_t new_size) {
-    reserve(new_size);
-    size_ = new_size;
-  }
+    /**
+      Resizes the buffer. If T is a POD type new elements may not be initialized.
+     */
+    void resize(std::size_t new_size)
+    {
+        reserve(new_size);
+        size_ = new_size;
+    }
 
-  /** Reserves space to store at least *capacity* elements. */
-  void reserve(std::size_t new_capacity) {
-    if (new_capacity > capacity_)
-      grow(new_capacity);
-  }
+    /** Reserves space to store at least *capacity* elements. */
+    void reserve(std::size_t new_capacity)
+    {
+        if (new_capacity > capacity_)
+            grow(new_capacity);
+    }
 
-  void push_back(const T &value) {
-    reserve(size_ + 1);
-    ptr_[size_++] = value;
-  }
+    void push_back(const T &value)
+    {
+        reserve(size_ + 1);
+        ptr_[size_++] = value;
+    }
 
-  /** Appends data to the end of the buffer. */
-  template <typename U>
-  void append(const U *begin, const U *end);
+    /** 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]; }
+    T &operator[](std::size_t index)
+    {
+        return ptr_[index];
+    }
+    const T &operator[](std::size_t index) const
+    {
+        return ptr_[index];
+    }
 };
 
 typedef basic_buffer<char> buffer;
 typedef basic_buffer<wchar_t> wbuffer;
 
 // A container-backed buffer.
-template <typename Container>
-class container_buffer : public basic_buffer<typename Container::value_type> {
- private:
-  Container &container_;
+template<typename Container>
+class container_buffer : public basic_buffer<typename Container::value_type>
+{
+private:
+    Container &container_;
 
- protected:
-  void grow(std::size_t capacity) FMT_OVERRIDE {
-    container_.resize(capacity);
-    this->set(&container_[0], capacity);
-  }
+protected:
+    void grow(std::size_t capacity) FMT_OVERRIDE
+    {
+        container_.resize(capacity);
+        this->set(&container_[0], capacity);
+    }
 
- public:
-  explicit container_buffer(Container &c)
-    : basic_buffer<typename Container::value_type>(&c[0], c.size(), c.size()),
-      container_(c) {}
+public:
+    explicit container_buffer(Container &c)
+        : basic_buffer<typename Container::value_type>(&c[0], c.size(), c.size())
+        , container_(c)
+    {
+    }
 };
 
-struct error_handler {
-  FMT_CONSTEXPR error_handler() {}
-  FMT_CONSTEXPR error_handler(const error_handler &) {}
+struct error_handler
+{
+    FMT_CONSTEXPR error_handler() {}
+    FMT_CONSTEXPR error_handler(const error_handler &) {}
 
-  // This function is intentionally not constexpr to give a compile-time error.
-  FMT_API void on_error(const char *message);
+    // This function is intentionally not constexpr to give a compile-time error.
+    FMT_API void on_error(const char *message);
 };
 
 // Formatting of wide characters and strings into a narrow output is disallowed:
 //   fmt::format("{}", L"test"); // error
 // To fix this, use a wide format string:
 //   fmt::format(L"{}", L"test");
-template <typename Char>
-inline void require_wchar() {
-  static_assert(
-      std::is_same<wchar_t, Char>::value,
-      "formatting of wide characters into a narrow output is disallowed");
+template<typename Char>
+inline void require_wchar()
+{
+    static_assert(std::is_same<wchar_t, Char>::value, "formatting of wide characters into a narrow output is disallowed");
 }
 
-template <typename Char>
+template<typename Char>
 struct named_arg_base;
 
-template <typename T, typename Char>
+template<typename T, typename Char>
 struct named_arg;
 
-template <typename T>
-struct is_named_arg : std::false_type {};
-
-template <typename T, typename Char>
-struct is_named_arg<named_arg<T, Char>> : std::true_type {};
-
-enum type {
-  none_type, named_arg_type,
-  // Integer types should go first,
-  int_type, uint_type, long_long_type, ulong_long_type, bool_type, char_type,
-  last_integer_type = char_type,
-  // followed by floating-point types.
-  double_type, long_double_type, last_numeric_type = long_double_type,
-  cstring_type, string_type, pointer_type, custom_type
+template<typename T>
+struct is_named_arg : std::false_type
+{
 };
 
-FMT_CONSTEXPR bool is_integral(type t) {
-  FMT_ASSERT(t != internal::named_arg_type, "invalid argument type");
-  return t > internal::none_type && t <= internal::last_integer_type;
+template<typename T, typename Char>
+struct is_named_arg<named_arg<T, Char>> : std::true_type
+{
+};
+
+enum type
+{
+    none_type,
+    named_arg_type,
+    // Integer types should go first,
+    int_type,
+    uint_type,
+    long_long_type,
+    ulong_long_type,
+    bool_type,
+    char_type,
+    last_integer_type = char_type,
+    // followed by floating-point types.
+    double_type,
+    long_double_type,
+    last_numeric_type = long_double_type,
+    cstring_type,
+    string_type,
+    pointer_type,
+    custom_type
+};
+
+FMT_CONSTEXPR bool is_integral(type t)
+{
+    FMT_ASSERT(t != internal::named_arg_type, "invalid argument type");
+    return t > internal::none_type && t <= internal::last_integer_type;
 }
 
-FMT_CONSTEXPR bool is_arithmetic(type t) {
-  FMT_ASSERT(t != internal::named_arg_type, "invalid argument type");
-  return t > internal::none_type && t <= internal::last_numeric_type;
+FMT_CONSTEXPR bool is_arithmetic(type t)
+{
+    FMT_ASSERT(t != internal::named_arg_type, "invalid argument type");
+    return t > internal::none_type && t <= internal::last_numeric_type;
 }
 
-template <typename T, typename Char, bool ENABLE = true>
-struct convert_to_int {
-  enum {
-    value = !std::is_arithmetic<T>::value && std::is_convertible<T, int>::value
-  };
+template<typename T, typename Char, bool ENABLE = true>
+struct convert_to_int
+{
+    enum
+    {
+        value = !std::is_arithmetic<T>::value && std::is_convertible<T, int>::value
+    };
 };
 
-template <typename Char>
-struct string_value {
-  const Char *value;
-  std::size_t size;
+template<typename Char>
+struct string_value
+{
+    const Char *value;
+    std::size_t size;
 };
 
-template <typename Context>
-struct custom_value {
-  const void *value;
-  void (*format)(const void *arg, Context &ctx);
+template<typename Context>
+struct custom_value
+{
+    const void *value;
+    void (*format)(const void *arg, Context &ctx);
 };
 
 // A formatting argument value.
-template <typename Context>
-class value {
- public:
-  typedef typename Context::char_type char_type;
+template<typename Context>
+class value
+{
+public:
+    typedef typename Context::char_type char_type;
 
-  union {
-    int int_value;
-    unsigned uint_value;
-    long long long_long_value;
-    unsigned long long ulong_long_value;
-    double double_value;
-    long double long_double_value;
-    const void *pointer;
-    string_value<char_type> string;
-    string_value<signed char> sstring;
-    string_value<unsigned char> ustring;
-    custom_value<Context> custom;
-  };
+    union
+    {
+        int int_value;
+        unsigned uint_value;
+        long long long_long_value;
+        unsigned long long ulong_long_value;
+        double double_value;
+        long double long_double_value;
+        const void *pointer;
+        string_value<char_type> string;
+        string_value<signed char> sstring;
+        string_value<unsigned char> ustring;
+        custom_value<Context> custom;
+    };
 
-  FMT_CONSTEXPR value(int val = 0) : int_value(val) {}
-  value(unsigned val) { uint_value = val; }
-  value(long long val) { long_long_value = val; }
-  value(unsigned long long val) { ulong_long_value = val; }
-  value(double val) { double_value = val; }
-  value(long double val) { long_double_value = val; }
-  value(const char_type *val) { string.value = val; }
-  value(const signed char *val) {
-    static_assert(std::is_same<char, char_type>::value,
-                  "incompatible string types");
-    sstring.value = val;
-  }
-  value(const unsigned char *val) {
-    static_assert(std::is_same<char, char_type>::value,
-                  "incompatible string types");
-    ustring.value = val;
-  }
-  value(basic_string_view<char_type> val) {
-    string.value = val.data();
-    string.size = val.size();
-  }
-  value(const void *val) { pointer = val; }
+    FMT_CONSTEXPR value(int val = 0)
+        : int_value(val)
+    {
+    }
+    value(unsigned val)
+    {
+        uint_value = val;
+    }
+    value(long long val)
+    {
+        long_long_value = val;
+    }
+    value(unsigned long long val)
+    {
+        ulong_long_value = val;
+    }
+    value(double val)
+    {
+        double_value = val;
+    }
+    value(long double val)
+    {
+        long_double_value = val;
+    }
+    value(const char_type *val)
+    {
+        string.value = val;
+    }
+    value(const signed char *val)
+    {
+        static_assert(std::is_same<char, char_type>::value, "incompatible string types");
+        sstring.value = val;
+    }
+    value(const unsigned char *val)
+    {
+        static_assert(std::is_same<char, char_type>::value, "incompatible string types");
+        ustring.value = val;
+    }
+    value(basic_string_view<char_type> val)
+    {
+        string.value = val.data();
+        string.size = val.size();
+    }
+    value(const void *val)
+    {
+        pointer = val;
+    }
 
-  template <typename T>
-  explicit value(const T &val) {
-    custom.value = &val;
-    custom.format = &format_custom_arg<T>;
-  }
+    template<typename T>
+    explicit value(const T &val)
+    {
+        custom.value = &val;
+        custom.format = &format_custom_arg<T>;
+    }
 
-  const named_arg_base<char_type> &as_named_arg() {
-    return *static_cast<const named_arg_base<char_type>*>(pointer);
-  }
+    const named_arg_base<char_type> &as_named_arg()
+    {
+        return *static_cast<const named_arg_base<char_type> *>(pointer);
+    }
 
- private:
-  // Formats an argument of a custom type, such as a user-defined class.
-  template <typename T>
-  static void format_custom_arg(const void *arg, Context &ctx) {
-    // Get the formatter type through the context to allow different contexts
-    // have different extension points, e.g. `formatter<T>` for `format` and
-    // `printf_formatter<T>` for `printf`.
-    typename Context::template formatter_type<T>::type f;
-    auto &&parse_ctx = ctx.parse_context();
-    parse_ctx.advance_to(f.parse(parse_ctx));
-    ctx.advance_to(f.format(*static_cast<const T*>(arg), ctx));
-  }
+private:
+    // Formats an argument of a custom type, such as a user-defined class.
+    template<typename T>
+    static void format_custom_arg(const void *arg, Context &ctx)
+    {
+        // Get the formatter type through the context to allow different contexts
+        // have different extension points, e.g. `formatter<T>` for `format` and
+        // `printf_formatter<T>` for `printf`.
+        typename Context::template formatter_type<T>::type f;
+        auto &&parse_ctx = ctx.parse_context();
+        parse_ctx.advance_to(f.parse(parse_ctx));
+        ctx.advance_to(f.format(*static_cast<const T *>(arg), ctx));
+    }
 };
 
-template <typename Context, type TYPE>
-struct typed_value : value<Context> {
-  static const type type_tag = TYPE;
+template<typename Context, type TYPE>
+struct typed_value : value<Context>
+{
+    static const type type_tag = TYPE;
 
-  template <typename T>
-  FMT_CONSTEXPR typed_value(const T &val) : value<Context>(val) {}
+    template<typename T>
+    FMT_CONSTEXPR typed_value(const T &val)
+        : value<Context>(val)
+    {
+    }
 };
 
-template <typename Context, typename T>
+template<typename Context, typename T>
 FMT_CONSTEXPR basic_format_arg<Context> make_arg(const T &value);
 
-#define FMT_MAKE_VALUE(TAG, ArgType, ValueType) \
-  template <typename C> \
-  FMT_CONSTEXPR typed_value<C, TAG> make_value(ArgType val) { \
-    return static_cast<ValueType>(val); \
-  }
+#define FMT_MAKE_VALUE(TAG, ArgType, ValueType)                                                                                            \
+    template<typename C>                                                                                                                   \
+    FMT_CONSTEXPR typed_value<C, TAG> make_value(ArgType val)                                                                              \
+    {                                                                                                                                      \
+        return static_cast<ValueType>(val);                                                                                                \
+    }
 
-#define FMT_MAKE_VALUE_SAME(TAG, Type) \
-  template <typename C> \
-  FMT_CONSTEXPR typed_value<C, TAG> make_value(Type val) { \
-    return val; \
-  }
+#define FMT_MAKE_VALUE_SAME(TAG, Type)                                                                                                     \
+    template<typename C>                                                                                                                   \
+    FMT_CONSTEXPR typed_value<C, TAG> make_value(Type val)                                                                                 \
+    {                                                                                                                                      \
+        return val;                                                                                                                        \
+    }
 
 FMT_MAKE_VALUE(bool_type, bool, int)
 FMT_MAKE_VALUE(int_type, short, int)
@@ -585,15 +702,10 @@ FMT_MAKE_VALUE_SAME(uint_type, unsigned)
 
 // 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.
-typedef std::conditional<sizeof(long) == sizeof(int), int, long long>::type
-        long_type;
-FMT_MAKE_VALUE(
-    (sizeof(long) == sizeof(int) ? int_type : long_long_type), long, long_type)
-typedef std::conditional<sizeof(unsigned long) == sizeof(unsigned),
-                         unsigned, unsigned long long>::type ulong_type;
-FMT_MAKE_VALUE(
-    (sizeof(unsigned long) == sizeof(unsigned) ? uint_type : ulong_long_type),
-    unsigned long, ulong_type)
+typedef std::conditional<sizeof(long) == sizeof(int), int, long long>::type long_type;
+FMT_MAKE_VALUE((sizeof(long) == sizeof(int) ? int_type : long_long_type), long, long_type)
+typedef std::conditional<sizeof(unsigned long) == sizeof(unsigned), unsigned, unsigned long long>::type ulong_type;
+FMT_MAKE_VALUE((sizeof(unsigned long) == sizeof(unsigned) ? uint_type : ulong_long_type), unsigned long, ulong_type)
 
 FMT_MAKE_VALUE_SAME(long_long_type, long long)
 FMT_MAKE_VALUE_SAME(ulong_long_type, unsigned long long)
@@ -602,10 +714,11 @@ FMT_MAKE_VALUE(uint_type, unsigned char, unsigned)
 FMT_MAKE_VALUE(char_type, char, int)
 
 #if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
-template <typename C>
-inline typed_value<C, char_type> make_value(wchar_t val) {
-  require_wchar<typename C::char_type>();
-  return static_cast<int>(val);
+template<typename C>
+inline typed_value<C, char_type> make_value(wchar_t val)
+{
+    require_wchar<typename C::char_type>();
+    return static_cast<int>(val);
 }
 #endif
 
@@ -615,170 +728,204 @@ FMT_MAKE_VALUE_SAME(long_double_type, long double)
 
 // Formatting of wide strings into a narrow buffer and multibyte strings
 // into a wide buffer is disallowed (https://github.com/fmtlib/fmt/pull/606).
-FMT_MAKE_VALUE(cstring_type, typename C::char_type*,
-               const typename C::char_type*)
-FMT_MAKE_VALUE(cstring_type, const typename C::char_type*,
-               const typename C::char_type*)
+FMT_MAKE_VALUE(cstring_type, typename C::char_type *, const typename C::char_type *)
+FMT_MAKE_VALUE(cstring_type, const typename C::char_type *, const typename C::char_type *)
 
-FMT_MAKE_VALUE(cstring_type, signed char*, const signed char*)
-FMT_MAKE_VALUE_SAME(cstring_type, const signed char*)
-FMT_MAKE_VALUE(cstring_type, unsigned char*, const unsigned char*)
-FMT_MAKE_VALUE_SAME(cstring_type, const unsigned char*)
+FMT_MAKE_VALUE(cstring_type, signed char *, const signed char *)
+FMT_MAKE_VALUE_SAME(cstring_type, const signed char *)
+FMT_MAKE_VALUE(cstring_type, unsigned char *, const unsigned char *)
+FMT_MAKE_VALUE_SAME(cstring_type, const unsigned char *)
 FMT_MAKE_VALUE_SAME(string_type, basic_string_view<typename C::char_type>)
-FMT_MAKE_VALUE(string_type,
-               typename basic_string_view<typename C::char_type>::type,
-               basic_string_view<typename C::char_type>)
-FMT_MAKE_VALUE(string_type, const std::basic_string<typename C::char_type>&,
-               basic_string_view<typename C::char_type>)
-FMT_MAKE_VALUE(pointer_type, void*, const void*)
-FMT_MAKE_VALUE_SAME(pointer_type, const void*)
+FMT_MAKE_VALUE(string_type, typename basic_string_view<typename C::char_type>::type, basic_string_view<typename C::char_type>)
+FMT_MAKE_VALUE(string_type, const std::basic_string<typename C::char_type> &, basic_string_view<typename C::char_type>)
+FMT_MAKE_VALUE(pointer_type, void *, const void *)
+FMT_MAKE_VALUE_SAME(pointer_type, const void *)
 
 #if FMT_USE_NULLPTR
-FMT_MAKE_VALUE(pointer_type, std::nullptr_t, const void*)
+FMT_MAKE_VALUE(pointer_type, std::nullptr_t, const void *)
 #endif
 
 // Formatting of arbitrary pointers is disallowed. 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.
-template <typename C, typename T>
-typename std::enable_if<!std::is_same<T, typename C::char_type>::value>::type
-    make_value(const T *) {
-  static_assert(!sizeof(T), "formatting of non-void pointers is disallowed");
+template<typename C, typename T>
+typename std::enable_if<!std::is_same<T, typename C::char_type>::value>::type make_value(const T *)
+{
+    static_assert(!sizeof(T), "formatting of non-void pointers is disallowed");
 }
 
-template <typename C, typename T>
-inline typename std::enable_if<
-    std::is_enum<T>::value && convert_to_int<T, typename C::char_type>::value,
-    typed_value<C, int_type>>::type
-  make_value(const T &val) { return static_cast<int>(val); }
+template<typename C, typename T>
+inline typename std::enable_if<std::is_enum<T>::value && convert_to_int<T, typename C::char_type>::value, typed_value<C, int_type>>::type
+make_value(const T &val)
+{
+    return static_cast<int>(val);
+}
 
-template <typename C, typename T, typename Char = typename C::char_type>
-inline typename std::enable_if<
-    !convert_to_int<T, Char>::value &&
-    !std::is_convertible<T, basic_string_view<Char>>::value,
+template<typename C, typename T, typename Char = typename C::char_type>
+inline typename std::enable_if<!convert_to_int<T, Char>::value && !std::is_convertible<T, basic_string_view<Char>>::value,
     // Implicit conversion to std::string is not handled here because it's
     // unsafe: https://github.com/fmtlib/fmt/issues/729
     typed_value<C, custom_type>>::type
-  make_value(const T &val) { return val; }
+make_value(const T &val)
+{
+    return val;
+}
 
-template <typename C, typename T>
-typed_value<C, named_arg_type>
-    make_value(const named_arg<T, typename C::char_type> &val) {
-  basic_format_arg<C> arg = make_arg<C>(val.value);
-  std::memcpy(val.data, &arg, sizeof(arg));
-  return static_cast<const void*>(&val);
+template<typename C, typename T>
+typed_value<C, named_arg_type> make_value(const named_arg<T, typename C::char_type> &val)
+{
+    basic_format_arg<C> arg = make_arg<C>(val.value);
+    std::memcpy(val.data, &arg, sizeof(arg));
+    return static_cast<const void *>(&val);
 }
 
 // Maximum number of arguments with packed types.
-enum { max_packed_args = 15 };
+enum
+{
+    max_packed_args = 15
+};
 
-template <typename Context>
+template<typename Context>
 class arg_map;
 
-template <typename>
+template<typename>
 struct result_of;
 
-template <typename F, typename... Args>
-struct result_of<F(Args...)> {
-  // A workaround for gcc 4.4 that doesn't allow F to be a reference.
-  typedef typename std::result_of<
-    typename std::remove_reference<F>::type(Args...)>::type type;
+template<typename F, typename... Args>
+struct result_of<F(Args...)>
+{
+    // A workaround for gcc 4.4 that doesn't allow F to be a reference.
+    typedef typename std::result_of<typename std::remove_reference<F>::type(Args...)>::type type;
 };
-}
+} // namespace internal
 
 // A formatting argument. It is a trivially copyable/constructible type to
 // allow storage in basic_memory_buffer.
-template <typename Context>
-class basic_format_arg {
- private:
-  internal::value<Context> value_;
-  internal::type type_;
+template<typename Context>
+class basic_format_arg
+{
+private:
+    internal::value<Context> value_;
+    internal::type type_;
 
-  template <typename ContextType, typename T>
-  friend FMT_CONSTEXPR basic_format_arg<ContextType>
-    internal::make_arg(const T &value);
+    template<typename ContextType, typename T>
+    friend FMT_CONSTEXPR basic_format_arg<ContextType> internal::make_arg(const T &value);
 
-  template <typename Visitor, typename Ctx>
-  friend FMT_CONSTEXPR typename internal::result_of<Visitor(int)>::type
-    visit(Visitor &&vis, basic_format_arg<Ctx> arg);
+    template<typename Visitor, typename Ctx>
+    friend FMT_CONSTEXPR typename internal::result_of<Visitor(int)>::type visit(Visitor &&vis, basic_format_arg<Ctx> arg);
 
-  friend class basic_format_args<Context>;
-  friend class internal::arg_map<Context>;
+    friend class basic_format_args<Context>;
+    friend class internal::arg_map<Context>;
 
-  typedef typename Context::char_type char_type;
+    typedef typename Context::char_type char_type;
 
- public:
-  class handle {
-   public:
-    explicit handle(internal::custom_value<Context> custom): custom_(custom) {}
+public:
+    class handle
+    {
+    public:
+        explicit handle(internal::custom_value<Context> custom)
+            : custom_(custom)
+        {
+        }
 
-    void format(Context &ctx) const { custom_.format(custom_.value, ctx); }
+        void format(Context &ctx) const
+        {
+            custom_.format(custom_.value, ctx);
+        }
 
-   private:
-    internal::custom_value<Context> custom_;
-  };
+    private:
+        internal::custom_value<Context> custom_;
+    };
 
-  FMT_CONSTEXPR basic_format_arg() : type_(internal::none_type) {}
+    FMT_CONSTEXPR basic_format_arg()
+        : type_(internal::none_type)
+    {
+    }
 
-  FMT_EXPLICIT operator bool() const FMT_NOEXCEPT {
-    return type_ != internal::none_type;
-  }
+    FMT_EXPLICIT operator bool() const FMT_NOEXCEPT
+    {
+        return type_ != internal::none_type;
+    }
 
-  internal::type type() const { return type_; }
+    internal::type type() const
+    {
+        return type_;
+    }
 
-  bool is_integral() const { return internal::is_integral(type_); }
-  bool is_arithmetic() const { return internal::is_arithmetic(type_); }
+    bool is_integral() const
+    {
+        return internal::is_integral(type_);
+    }
+    bool is_arithmetic() const
+    {
+        return internal::is_arithmetic(type_);
+    }
 };
 
 // Parsing context consisting of a format string range being parsed and an
 // argument counter for automatic indexing.
-template <typename Char, typename ErrorHandler = internal::error_handler>
-class basic_parse_context : private ErrorHandler {
- private:
-  basic_string_view<Char> format_str_;
-  int next_arg_id_;
+template<typename Char, typename ErrorHandler = internal::error_handler>
+class basic_parse_context : private ErrorHandler
+{
+private:
+    basic_string_view<Char> format_str_;
+    int next_arg_id_;
 
- public:
-  typedef Char char_type;
-  typedef typename basic_string_view<Char>::iterator iterator;
+public:
+    typedef Char char_type;
+    typedef typename basic_string_view<Char>::iterator iterator;
 
-  explicit FMT_CONSTEXPR basic_parse_context(
-      basic_string_view<Char> format_str, ErrorHandler eh = ErrorHandler())
-    : ErrorHandler(eh), format_str_(format_str), next_arg_id_(0) {}
-
-  // Returns an iterator to the beginning of the format string range being
-  // parsed.
-  FMT_CONSTEXPR iterator begin() const FMT_NOEXCEPT {
-    return format_str_.begin();
-  }
-
-  // Returns an iterator past the end of the format string range being parsed.
-  FMT_CONSTEXPR iterator end() const FMT_NOEXCEPT { return format_str_.end(); }
-
-  // Advances the begin iterator to ``it``.
-  FMT_CONSTEXPR void advance_to(iterator it) {
-    format_str_.remove_prefix(internal::to_unsigned(it - begin()));
-  }
-
-  // Returns the next argument index.
-  FMT_CONSTEXPR unsigned next_arg_id();
-
-  FMT_CONSTEXPR bool check_arg_id(unsigned) {
-    if (next_arg_id_ > 0) {
-      on_error("cannot switch from automatic to manual argument indexing");
-      return false;
+    explicit FMT_CONSTEXPR basic_parse_context(basic_string_view<Char> format_str, ErrorHandler eh = ErrorHandler())
+        : ErrorHandler(eh)
+        , format_str_(format_str)
+        , next_arg_id_(0)
+    {
     }
-    next_arg_id_ = -1;
-    return true;
-  }
-  void check_arg_id(basic_string_view<Char>) {}
 
-  FMT_CONSTEXPR void on_error(const char *message) {
-    ErrorHandler::on_error(message);
-  }
+    // Returns an iterator to the beginning of the format string range being
+    // parsed.
+    FMT_CONSTEXPR iterator begin() const FMT_NOEXCEPT
+    {
+        return format_str_.begin();
+    }
 
-  FMT_CONSTEXPR ErrorHandler error_handler() const { return *this; }
+    // Returns an iterator past the end of the format string range being parsed.
+    FMT_CONSTEXPR iterator end() const FMT_NOEXCEPT
+    {
+        return format_str_.end();
+    }
+
+    // Advances the begin iterator to ``it``.
+    FMT_CONSTEXPR void advance_to(iterator it)
+    {
+        format_str_.remove_prefix(internal::to_unsigned(it - begin()));
+    }
+
+    // Returns the next argument index.
+    FMT_CONSTEXPR unsigned next_arg_id();
+
+    FMT_CONSTEXPR bool check_arg_id(unsigned)
+    {
+        if (next_arg_id_ > 0)
+        {
+            on_error("cannot switch from automatic to manual argument indexing");
+            return false;
+        }
+        next_arg_id_ = -1;
+        return true;
+    }
+    void check_arg_id(basic_string_view<Char>) {}
+
+    FMT_CONSTEXPR void on_error(const char *message)
+    {
+        ErrorHandler::on_error(message);
+    }
+
+    FMT_CONSTEXPR ErrorHandler error_handler() const
+    {
+        return *this;
+    }
 };
 
 typedef basic_parse_context<char> parse_context;
@@ -786,195 +933,246 @@ typedef basic_parse_context<wchar_t> wparse_context;
 
 namespace internal {
 // A map from argument names to their values for named arguments.
-template <typename Context>
-class arg_map {
- private:
-  FMT_DISALLOW_COPY_AND_ASSIGN(arg_map);
+template<typename Context>
+class arg_map
+{
+private:
+    FMT_DISALLOW_COPY_AND_ASSIGN(arg_map);
 
-  typedef typename Context::char_type char_type;
+    typedef typename Context::char_type char_type;
 
-  struct entry {
-    basic_string_view<char_type> name;
-    basic_format_arg<Context> arg;
-  };
+    struct entry
+    {
+        basic_string_view<char_type> name;
+        basic_format_arg<Context> arg;
+    };
 
-  entry *map_;
-  unsigned size_;
+    entry *map_;
+    unsigned size_;
 
-  void push_back(value<Context> val) {
-    const internal::named_arg_base<char_type> &named = val.as_named_arg();
-    map_[size_] = entry{named.name, named.template deserialize<Context>()};
-    ++size_;
-  }
-
- public:
-  arg_map() : map_(FMT_NULL), size_(0) {}
-  void init(const basic_format_args<Context> &args);
-  ~arg_map() { delete [] map_; }
-
-  basic_format_arg<Context> find(basic_string_view<char_type> name) const {
-    // The list is unsorted, so just return the first matching name.
-    for (entry *it = map_, *end = map_ + size_; it != end; ++it) {
-      if (it->name == name)
-        return it->arg;
+    void push_back(value<Context> val)
+    {
+        const internal::named_arg_base<char_type> &named = val.as_named_arg();
+        map_[size_] = entry{named.name, named.template deserialize<Context>()};
+        ++size_;
+    }
+
+public:
+    arg_map()
+        : map_(FMT_NULL)
+        , size_(0)
+    {
+    }
+    void init(const basic_format_args<Context> &args);
+    ~arg_map()
+    {
+        delete[] map_;
+    }
+
+    basic_format_arg<Context> find(basic_string_view<char_type> name) const
+    {
+        // The list is unsorted, so just return the first matching name.
+        for (entry *it = map_, *end = map_ + size_; it != end; ++it)
+        {
+            if (it->name == name)
+                return it->arg;
+        }
+        return basic_format_arg<Context>();
     }
-    return basic_format_arg<Context>();
-  }
 };
 
-template <typename OutputIt, typename Context, typename Char>
-class context_base {
- public:
-  typedef OutputIt iterator;
+template<typename OutputIt, typename Context, typename Char>
+class context_base
+{
+public:
+    typedef OutputIt iterator;
 
- private:
-  basic_parse_context<Char> parse_context_;
-  iterator out_;
-  basic_format_args<Context> args_;
+private:
+    basic_parse_context<Char> parse_context_;
+    iterator out_;
+    basic_format_args<Context> args_;
 
- protected:
-  typedef Char char_type;
-  typedef basic_format_arg<Context> format_arg;
+protected:
+    typedef Char char_type;
+    typedef basic_format_arg<Context> format_arg;
 
-  context_base(OutputIt out, basic_string_view<char_type> format_str,
-               basic_format_args<Context> ctx_args)
-  : parse_context_(format_str), out_(out), args_(ctx_args) {}
+    context_base(OutputIt out, basic_string_view<char_type> format_str, basic_format_args<Context> ctx_args)
+        : parse_context_(format_str)
+        , out_(out)
+        , args_(ctx_args)
+    {
+    }
 
-  // Returns the argument with specified index.
-  format_arg do_get_arg(unsigned arg_id) {
-    format_arg arg = args_.get(arg_id);
-    if (!arg)
-      parse_context_.on_error("argument index out of range");
-    return arg;
-  }
+    // Returns the argument with specified index.
+    format_arg do_get_arg(unsigned arg_id)
+    {
+        format_arg arg = args_.get(arg_id);
+        if (!arg)
+            parse_context_.on_error("argument index out of range");
+        return arg;
+    }
 
-  // Checks if manual indexing is used and returns the argument with
-  // specified index.
-  format_arg get_arg(unsigned arg_id) {
-    return this->parse_context().check_arg_id(arg_id) ?
-      this->do_get_arg(arg_id) : format_arg();
-  }
+    // Checks if manual indexing is used and returns the argument with
+    // specified index.
+    format_arg get_arg(unsigned arg_id)
+    {
+        return this->parse_context().check_arg_id(arg_id) ? this->do_get_arg(arg_id) : format_arg();
+    }
 
- public:
-  basic_parse_context<char_type> &parse_context() {
-    return parse_context_;
-  }
+public:
+    basic_parse_context<char_type> &parse_context()
+    {
+        return parse_context_;
+    }
 
-  internal::error_handler error_handler() {
-    return parse_context_.error_handler();
-  }
+    internal::error_handler error_handler()
+    {
+        return parse_context_.error_handler();
+    }
 
-  void on_error(const char *message) { parse_context_.on_error(message); }
+    void on_error(const char *message)
+    {
+        parse_context_.on_error(message);
+    }
 
-  // Returns an iterator to the beginning of the output range.
-  iterator out() { return out_; }
-  iterator begin() { return out_; }  // deprecated
+    // Returns an iterator to the beginning of the output range.
+    iterator out()
+    {
+        return out_;
+    }
+    iterator begin()
+    {
+        return out_;
+    } // deprecated
 
-  // Advances the begin iterator to ``it``.
-  void advance_to(iterator it) { out_ = it; }
+    // Advances the begin iterator to ``it``.
+    void advance_to(iterator it)
+    {
+        out_ = it;
+    }
 
-  basic_format_args<Context> args() const { return args_; }
+    basic_format_args<Context> args() const
+    {
+        return args_;
+    }
 };
 
 // Extracts a reference to the container from back_insert_iterator.
-template <typename Container>
-inline Container &get_container(std::back_insert_iterator<Container> it) {
-  typedef std::back_insert_iterator<Container> bi_iterator;
-  struct accessor: bi_iterator {
-    accessor(bi_iterator iter) : bi_iterator(iter) {}
-    using bi_iterator::container;
-  };
-  return *accessor(it).container;
+template<typename Container>
+inline Container &get_container(std::back_insert_iterator<Container> it)
+{
+    typedef std::back_insert_iterator<Container> bi_iterator;
+    struct accessor : bi_iterator
+    {
+        accessor(bi_iterator iter)
+            : bi_iterator(iter)
+        {
+        }
+        using bi_iterator::container;
+    };
+    return *accessor(it).container;
 }
-}  // namespace internal
+} // namespace internal
 
 // Formatting context.
-template <typename OutputIt, typename Char>
-class basic_format_context :
-  public internal::context_base<
-    OutputIt, basic_format_context<OutputIt, Char>, Char> {
- public:
-  /** The character type for the output. */
-  typedef Char char_type;
+template<typename OutputIt, typename Char>
+class basic_format_context : public internal::context_base<OutputIt, basic_format_context<OutputIt, Char>, Char>
+{
+public:
+    /** The character type for the output. */
+    typedef Char char_type;
 
-  // using formatter_type = formatter<T, char_type>;
-  template <typename T>
-  struct formatter_type { typedef formatter<T, char_type> type; };
+    // using formatter_type = formatter<T, char_type>;
+    template<typename T>
+    struct formatter_type
+    {
+        typedef formatter<T, char_type> type;
+    };
 
- private:
-  internal::arg_map<basic_format_context> map_;
+private:
+    internal::arg_map<basic_format_context> map_;
 
-  FMT_DISALLOW_COPY_AND_ASSIGN(basic_format_context);
+    FMT_DISALLOW_COPY_AND_ASSIGN(basic_format_context);
 
-  typedef internal::context_base<OutputIt, basic_format_context, Char> base;
-  typedef typename base::format_arg format_arg;
-  using base::get_arg;
+    typedef internal::context_base<OutputIt, basic_format_context, Char> base;
+    typedef typename base::format_arg format_arg;
+    using base::get_arg;
 
- public:
-  using typename base::iterator;
+public:
+    using typename base::iterator;
 
-  /**
-   Constructs a ``basic_format_context`` object. References to the arguments are
-   stored in the object so make sure they have appropriate lifetimes.
-   */
-  basic_format_context(OutputIt out, basic_string_view<char_type> format_str,
-                basic_format_args<basic_format_context> ctx_args)
-    : base(out, format_str, ctx_args) {}
+    /**
+     Constructs a ``basic_format_context`` object. References to the arguments are
+     stored in the object so make sure they have appropriate lifetimes.
+     */
+    basic_format_context(OutputIt out, basic_string_view<char_type> format_str, basic_format_args<basic_format_context> ctx_args)
+        : base(out, format_str, ctx_args)
+    {
+    }
 
-  format_arg next_arg() {
-    return this->do_get_arg(this->parse_context().next_arg_id());
-  }
-  format_arg get_arg(unsigned arg_id) { return this->do_get_arg(arg_id); }
+    format_arg next_arg()
+    {
+        return this->do_get_arg(this->parse_context().next_arg_id());
+    }
+    format_arg get_arg(unsigned arg_id)
+    {
+        return this->do_get_arg(arg_id);
+    }
 
-  // Checks if manual indexing is used and returns the argument with the
-  // specified name.
-  format_arg get_arg(basic_string_view<char_type> name);
+    // Checks if manual indexing is used and returns the argument with the
+    // specified name.
+    format_arg get_arg(basic_string_view<char_type> name);
 };
 
-template <typename Char>
-struct buffer_context {
-  typedef basic_format_context<
-    std::back_insert_iterator<internal::basic_buffer<Char>>, Char> type;
+template<typename Char>
+struct buffer_context
+{
+    typedef basic_format_context<std::back_insert_iterator<internal::basic_buffer<Char>>, Char> type;
 };
 typedef buffer_context<char>::type format_context;
 typedef buffer_context<wchar_t>::type wformat_context;
 
 namespace internal {
-template <typename Context, typename T>
-struct get_type {
-  typedef decltype(make_value<Context>(
-        declval<typename std::decay<T>::type&>())) value_type;
-  static const type value = value_type::type_tag;
+template<typename Context, typename T>
+struct get_type
+{
+    typedef decltype(make_value<Context>(declval<typename std::decay<T>::type &>())) value_type;
+    static const type value = value_type::type_tag;
 };
 
-template <typename Context>
-FMT_CONSTEXPR unsigned long long get_types() { return 0; }
-
-template <typename Context, typename Arg, typename... Args>
-FMT_CONSTEXPR unsigned long long get_types() {
-  return get_type<Context, Arg>::value | (get_types<Context, Args...>() << 4);
+template<typename Context>
+FMT_CONSTEXPR unsigned long long get_types()
+{
+    return 0;
 }
 
-template <typename Context, typename T>
-FMT_CONSTEXPR basic_format_arg<Context> make_arg(const T &value) {
-  basic_format_arg<Context> arg;
-  arg.type_ = get_type<Context, T>::value;
-  arg.value_ = make_value<Context>(value);
-  return arg;
+template<typename Context, typename Arg, typename... Args>
+FMT_CONSTEXPR unsigned long long get_types()
+{
+    return get_type<Context, Arg>::value | (get_types<Context, Args...>() << 4);
 }
 
-template <bool IS_PACKED, typename Context, typename T>
-inline typename std::enable_if<IS_PACKED, value<Context>>::type
-    make_arg(const T &value) {
-  return make_value<Context>(value);
+template<typename Context, typename T>
+FMT_CONSTEXPR basic_format_arg<Context> make_arg(const T &value)
+{
+    basic_format_arg<Context> arg;
+    arg.type_ = get_type<Context, T>::value;
+    arg.value_ = make_value<Context>(value);
+    return arg;
 }
 
-template <bool IS_PACKED, typename Context, typename T>
-inline typename std::enable_if<!IS_PACKED, basic_format_arg<Context>>::type
-    make_arg(const T &value) {
-  return make_arg<Context>(value);
+template<bool IS_PACKED, typename Context, typename T>
+inline typename std::enable_if<IS_PACKED, value<Context>>::type make_arg(const T &value)
+{
+    return make_value<Context>(value);
 }
+
+template<bool IS_PACKED, typename Context, typename T>
+inline typename std::enable_if<!IS_PACKED, basic_format_arg<Context>>::type make_arg(const T &value)
+{
+    return make_arg<Context>(value);
 }
+} // namespace internal
 
 /**
   \rst
@@ -983,53 +1181,52 @@ inline typename std::enable_if<!IS_PACKED, basic_format_arg<Context>>::type
   such as `~fmt::vformat`.
   \endrst
  */
-template <typename Context, typename ...Args>
-class format_arg_store {
- private:
-  static const size_t NUM_ARGS = sizeof...(Args);
+template<typename Context, typename... Args>
+class format_arg_store
+{
+private:
+    static const size_t NUM_ARGS = sizeof...(Args);
 
-  // Packed is a macro on MinGW so use IS_PACKED instead.
-  static const bool IS_PACKED = NUM_ARGS < internal::max_packed_args;
+    // Packed is a macro on MinGW so use IS_PACKED instead.
+    static const bool IS_PACKED = NUM_ARGS < internal::max_packed_args;
 
-  typedef typename std::conditional<IS_PACKED,
-    internal::value<Context>, basic_format_arg<Context>>::type value_type;
+    typedef typename std::conditional<IS_PACKED, internal::value<Context>, basic_format_arg<Context>>::type value_type;
 
-  // If the arguments are not packed, add one more element to mark the end.
-  static const size_t DATA_SIZE =
-          NUM_ARGS + (IS_PACKED && NUM_ARGS != 0 ? 0 : 1);
-  value_type data_[DATA_SIZE];
+    // If the arguments are not packed, add one more element to mark the end.
+    static const size_t DATA_SIZE = NUM_ARGS + (IS_PACKED && NUM_ARGS != 0 ? 0 : 1);
+    value_type data_[DATA_SIZE];
 
-  friend class basic_format_args<Context>;
+    friend class basic_format_args<Context>;
 
-  static FMT_CONSTEXPR long long get_types() {
-    return IS_PACKED ?
-      static_cast<long long>(internal::get_types<Context, Args...>()) :
-      -static_cast<long long>(NUM_ARGS);
-  }
+    static FMT_CONSTEXPR long long get_types()
+    {
+        return IS_PACKED ? static_cast<long long>(internal::get_types<Context, Args...>()) : -static_cast<long long>(NUM_ARGS);
+    }
 
- public:
+public:
 #if FMT_USE_CONSTEXPR
-  static constexpr long long TYPES = get_types();
+    static constexpr long long TYPES = get_types();
 #else
-  static const long long TYPES;
+    static const long long TYPES;
 #endif
 
-#if (FMT_GCC_VERSION && FMT_GCC_VERSION <= 405) || \
-    (FMT_MSC_VER && FMT_MSC_VER <= 1800)
-  // Workaround array initialization issues in gcc <= 4.5 and MSVC <= 2013.
-  format_arg_store(const Args &... args) {
-    value_type init[DATA_SIZE] =
-      {internal::make_arg<IS_PACKED, Context>(args)...};
-    std::memcpy(data_, init, sizeof(init));
-  }
+#if (FMT_GCC_VERSION && FMT_GCC_VERSION <= 405) || (FMT_MSC_VER && FMT_MSC_VER <= 1800)
+    // Workaround array initialization issues in gcc <= 4.5 and MSVC <= 2013.
+    format_arg_store(const Args &... args)
+    {
+        value_type init[DATA_SIZE] = {internal::make_arg<IS_PACKED, Context>(args)...};
+        std::memcpy(data_, init, sizeof(init));
+    }
 #else
-  format_arg_store(const Args &... args)
-    : data_{internal::make_arg<IS_PACKED, Context>(args)...} {}
+    format_arg_store(const Args &... args)
+        : data_{internal::make_arg<IS_PACKED, Context>(args)...}
+    {
+    }
 #endif
 };
 
 #if !FMT_USE_CONSTEXPR
-template <typename Context, typename ...Args>
+template<typename Context, typename... Args>
 const long long format_arg_store<Context, Args...>::TYPES = get_types();
 #endif
 
@@ -1040,136 +1237,164 @@ const long long format_arg_store<Context, Args...>::TYPES = get_types();
   be omitted in which case it defaults to `~fmt::context`.
   \endrst
  */
-template <typename Context, typename ...Args>
-inline format_arg_store<Context, Args...>
-    make_format_args(const Args & ... args) {
-  return format_arg_store<Context, Args...>(args...);
+template<typename Context, typename... Args>
+inline format_arg_store<Context, Args...> make_format_args(const Args &... args)
+{
+    return format_arg_store<Context, Args...>(args...);
 }
 
-template <typename ...Args>
-inline format_arg_store<format_context, Args...>
-    make_format_args(const Args & ... args) {
-  return format_arg_store<format_context, Args...>(args...);
+template<typename... Args>
+inline format_arg_store<format_context, Args...> make_format_args(const Args &... args)
+{
+    return format_arg_store<format_context, Args...>(args...);
 }
 
 /** Formatting arguments. */
-template <typename Context>
-class basic_format_args {
- public:
-  typedef unsigned size_type;
-  typedef basic_format_arg<Context>  format_arg;
+template<typename Context>
+class basic_format_args
+{
+public:
+    typedef unsigned size_type;
+    typedef basic_format_arg<Context> format_arg;
 
- private:
-  // To reduce compiled code size per formatting function call, types of first
-  // max_packed_args arguments are passed in the types_ field.
-  unsigned long long 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<Context> *values_;
-    const format_arg *args_;
-  };
+private:
+    // To reduce compiled code size per formatting function call, types of first
+    // max_packed_args arguments are passed in the types_ field.
+    unsigned long long 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<Context> *values_;
+        const format_arg *args_;
+    };
 
-  typename internal::type type(unsigned index) const {
-    unsigned shift = index * 4;
-    unsigned long long mask = 0xf;
-    return static_cast<typename internal::type>(
-      (types_ & (mask << shift)) >> shift);
-  }
-
-  friend class internal::arg_map<Context>;
-
-  void set_data(const internal::value<Context> *values) { values_ = values; }
-  void set_data(const format_arg *args) { args_ = args; }
-
-  format_arg do_get(size_type index) const {
-    long long signed_types = static_cast<long long>(types_);
-    if (signed_types < 0) {
-      unsigned long long num_args = static_cast<unsigned long long>(-signed_types);
-      return index < num_args ? args_[index] : format_arg();
+    typename internal::type type(unsigned index) const
+    {
+        unsigned shift = index * 4;
+        unsigned long long mask = 0xf;
+        return static_cast<typename internal::type>((types_ & (mask << shift)) >> shift);
     }
-    format_arg arg;
-    if (index > internal::max_packed_args)
-      return arg;
-    arg.type_ = type(index);
-    if (arg.type_ == internal::none_type)
-      return arg;
-    internal::value<Context> &val = arg.value_;
-    val = values_[index];
-    return arg;
-  }
 
- public:
-  basic_format_args() : types_(0) {}
+    friend class internal::arg_map<Context>;
 
-  /**
-   \rst
-   Constructs a `basic_format_args` object from `~fmt::format_arg_store`.
-   \endrst
-   */
-  template <typename... Args>
-  basic_format_args(const format_arg_store<Context, Args...> &store)
-  : types_(static_cast<unsigned long long>(store.TYPES)) {
-    set_data(store.data_);
-  }
+    void set_data(const internal::value<Context> *values)
+    {
+        values_ = values;
+    }
+    void set_data(const format_arg *args)
+    {
+        args_ = args;
+    }
 
-  /** Returns the argument at specified index. */
-  format_arg get(size_type index) const {
-    format_arg arg = do_get(index);
-    return arg.type_ == internal::named_arg_type ?
-          arg.value_.as_named_arg().template deserialize<Context>() : arg;
-  }
+    format_arg do_get(size_type index) const
+    {
+        long long signed_types = static_cast<long long>(types_);
+        if (signed_types < 0)
+        {
+            unsigned long long num_args = static_cast<unsigned long long>(-signed_types);
+            return index < num_args ? args_[index] : format_arg();
+        }
+        format_arg arg;
+        if (index > internal::max_packed_args)
+            return arg;
+        arg.type_ = type(index);
+        if (arg.type_ == internal::none_type)
+            return arg;
+        internal::value<Context> &val = arg.value_;
+        val = values_[index];
+        return arg;
+    }
 
-  unsigned max_size() const {
-    long long signed_types = static_cast<long long>(types_);
-    return static_cast<unsigned>(
-        signed_types < 0 ?
-        -signed_types : static_cast<long long>(internal::max_packed_args));
-  }
+public:
+    basic_format_args()
+        : types_(0)
+    {
+    }
+
+    /**
+     \rst
+     Constructs a `basic_format_args` object from `~fmt::format_arg_store`.
+     \endrst
+     */
+    template<typename... Args>
+    basic_format_args(const format_arg_store<Context, Args...> &store)
+        : types_(static_cast<unsigned long long>(store.TYPES))
+    {
+        set_data(store.data_);
+    }
+
+    /** Returns the argument at specified index. */
+    format_arg get(size_type index) const
+    {
+        format_arg arg = do_get(index);
+        return arg.type_ == internal::named_arg_type ? arg.value_.as_named_arg().template deserialize<Context>() : arg;
+    }
+
+    unsigned max_size() const
+    {
+        long long signed_types = static_cast<long long>(types_);
+        return static_cast<unsigned>(signed_types < 0 ? -signed_types : static_cast<long long>(internal::max_packed_args));
+    }
 };
 
 /** An alias to ``basic_format_args<context>``. */
 // It is a separate type rather than a typedef to make symbols readable.
-struct format_args: basic_format_args<format_context> {
-  template <typename ...Args>
-  format_args(Args && ... arg)
-  : basic_format_args<format_context>(std::forward<Args>(arg)...) {}
+struct format_args : basic_format_args<format_context>
+{
+    template<typename... Args>
+    format_args(Args &&... arg)
+        : basic_format_args<format_context>(std::forward<Args>(arg)...)
+    {
+    }
 };
-struct wformat_args : basic_format_args<wformat_context> {
-  template <typename ...Args>
-  wformat_args(Args && ... arg)
-  : basic_format_args<wformat_context>(std::forward<Args>(arg)...) {}
+struct wformat_args : basic_format_args<wformat_context>
+{
+    template<typename... Args>
+    wformat_args(Args &&... arg)
+        : basic_format_args<wformat_context>(std::forward<Args>(arg)...)
+    {
+    }
 };
 
 namespace internal {
-template <typename Char>
-struct named_arg_base {
-  basic_string_view<Char> name;
+template<typename Char>
+struct named_arg_base
+{
+    basic_string_view<Char> name;
 
-  // Serialized value<context>.
-  mutable char data[sizeof(basic_format_arg<format_context>)];
+    // Serialized value<context>.
+    mutable char data[sizeof(basic_format_arg<format_context>)];
 
-  named_arg_base(basic_string_view<Char> nm) : name(nm) {}
+    named_arg_base(basic_string_view<Char> nm)
+        : name(nm)
+    {
+    }
 
-  template <typename Context>
-  basic_format_arg<Context> deserialize() const {
-    basic_format_arg<Context> arg;
-    std::memcpy(&arg, data, sizeof(basic_format_arg<Context>));
-    return arg;
-  }
+    template<typename Context>
+    basic_format_arg<Context> deserialize() const
+    {
+        basic_format_arg<Context> arg;
+        std::memcpy(&arg, data, sizeof(basic_format_arg<Context>));
+        return arg;
+    }
 };
 
-template <typename T, typename Char>
-struct named_arg : named_arg_base<Char> {
-  const T &value;
+template<typename T, typename Char>
+struct named_arg : named_arg_base<Char>
+{
+    const T &value;
 
-  named_arg(basic_string_view<Char> name, const T &val)
-    : named_arg_base<Char>(name), value(val) {}
+    named_arg(basic_string_view<Char> name, const T &val)
+        : named_arg_base<Char>(name)
+        , value(val)
+    {
+    }
 };
-}
+} // namespace internal
 
 /**
   \rst
@@ -1180,73 +1405,87 @@ struct named_arg : named_arg_base<Char> {
     fmt::print("Elapsed time: {s:.2f} seconds", fmt::arg("s", 1.23));
   \endrst
  */
-template <typename T>
-inline internal::named_arg<T, char> arg(string_view name, const T &arg) {
-  return internal::named_arg<T, char>(name, arg);
+template<typename T>
+inline internal::named_arg<T, char> arg(string_view name, const T &arg)
+{
+    return internal::named_arg<T, char>(name, arg);
 }
 
-template <typename T>
-inline internal::named_arg<T, wchar_t> arg(wstring_view name, const T &arg) {
-  return internal::named_arg<T, wchar_t>(name, arg);
+template<typename T>
+inline internal::named_arg<T, wchar_t> arg(wstring_view name, const T &arg)
+{
+    return internal::named_arg<T, wchar_t>(name, arg);
 }
 
 // This function template is deleted intentionally to disable nested named
 // arguments as in ``format("{}", arg("a", arg("b", 42)))``.
-template <typename S, typename T, typename Char>
+template<typename S, typename T, typename Char>
 void arg(S, internal::named_arg<T, Char>) FMT_DELETED;
 
 #ifndef FMT_EXTENDED_COLORS
 // color and (v)print_colored are deprecated.
-enum color { black, red, green, yellow, blue, magenta, cyan, white };
+enum color
+{
+    black,
+    red,
+    green,
+    yellow,
+    blue,
+    magenta,
+    cyan,
+    white
+};
 FMT_API void vprint_colored(color c, string_view format, format_args args);
 FMT_API void vprint_colored(color c, wstring_view format, wformat_args args);
-template <typename... Args>
-inline void print_colored(color c, string_view format_str,
-                          const Args & ... args) {
-  vprint_colored(c, format_str, make_format_args(args...));
+template<typename... Args>
+inline void print_colored(color c, string_view format_str, const Args &... args)
+{
+    vprint_colored(c, format_str, make_format_args(args...));
 }
-template <typename... Args>
-inline void print_colored(color c, wstring_view format_str,
-                          const Args & ... args) {
-  vprint_colored(c, format_str, make_format_args<wformat_context>(args...));
+template<typename... Args>
+inline void print_colored(color c, wstring_view format_str, const Args &... args)
+{
+    vprint_colored(c, format_str, make_format_args<wformat_context>(args...));
 }
 #endif
 
-format_context::iterator vformat_to(
-    internal::buffer &buf, string_view format_str, format_args args);
-wformat_context::iterator vformat_to(
-    internal::wbuffer &buf, wstring_view format_str, wformat_args args);
+format_context::iterator vformat_to(internal::buffer &buf, string_view format_str, format_args args);
+wformat_context::iterator vformat_to(internal::wbuffer &buf, wstring_view format_str, wformat_args args);
 
-template <typename Container>
-struct is_contiguous : std::false_type {};
+template<typename Container>
+struct is_contiguous : std::false_type
+{
+};
 
-template <typename Char>
-struct is_contiguous<std::basic_string<Char>> : std::true_type {};
+template<typename Char>
+struct is_contiguous<std::basic_string<Char>> : std::true_type
+{
+};
 
-template <typename Char>
-struct is_contiguous<internal::basic_buffer<Char>> : std::true_type {};
+template<typename Char>
+struct is_contiguous<internal::basic_buffer<Char>> : std::true_type
+{
+};
 
 /** Formats a string and writes the output to ``out``. */
-template <typename Container>
-typename std::enable_if<
-  is_contiguous<Container>::value, std::back_insert_iterator<Container>>::type
-    vformat_to(std::back_insert_iterator<Container> out,
-               string_view format_str, format_args args) {
-  auto& container = internal::get_container(out);
-  internal::container_buffer<Container> buf(container);
-  vformat_to(buf, format_str, args);
-  return std::back_inserter(container);
+template<typename Container>
+typename std::enable_if<is_contiguous<Container>::value, std::back_insert_iterator<Container>>::type vformat_to(
+    std::back_insert_iterator<Container> out, string_view format_str, format_args args)
+{
+    auto &container = internal::get_container(out);
+    internal::container_buffer<Container> buf(container);
+    vformat_to(buf, format_str, args);
+    return std::back_inserter(container);
 }
 
-template <typename Container>
-typename std::enable_if<
-  is_contiguous<Container>::value, std::back_insert_iterator<Container>>::type
-  vformat_to(std::back_insert_iterator<Container> out,
-             wstring_view format_str, wformat_args args) {
-  auto& container = internal::get_container(out);
-  internal::container_buffer<Container> buf(container);
-  vformat_to(buf, format_str, args);
-  return std::back_inserter(container);
+template<typename Container>
+typename std::enable_if<is_contiguous<Container>::value, std::back_insert_iterator<Container>>::type vformat_to(
+    std::back_insert_iterator<Container> out, wstring_view format_str, wformat_args args)
+{
+    auto &container = internal::get_container(out);
+    internal::container_buffer<Container> buf(container);
+    vformat_to(buf, format_str, args);
+    return std::back_inserter(container);
 }
 
 std::string vformat(string_view format_str, format_args args);
@@ -1262,18 +1501,20 @@ std::wstring vformat(wstring_view format_str, wformat_args args);
     std::string message = fmt::format("The answer is {}", 42);
   \endrst
 */
-template <typename... Args>
-inline std::string format(string_view format_str, const Args & ... args) {
-  // This should be just
-  // return vformat(format_str, make_format_args(args...));
-  // but gcc has trouble optimizing the latter, so break it down.
-  format_arg_store<format_context, Args...> as{args...};
-  return vformat(format_str, as);
+template<typename... Args>
+inline std::string format(string_view format_str, const Args &... args)
+{
+    // This should be just
+    // return vformat(format_str, make_format_args(args...));
+    // but gcc has trouble optimizing the latter, so break it down.
+    format_arg_store<format_context, Args...> as{args...};
+    return vformat(format_str, as);
 }
-template <typename... Args>
-inline std::wstring format(wstring_view format_str, const Args & ... args) {
-  format_arg_store<wformat_context, Args...> as{args...};
-  return vformat(format_str, as);
+template<typename... Args>
+inline std::wstring format(wstring_view format_str, const Args &... args)
+{
+    format_arg_store<wformat_context, Args...> as{args...};
+    return vformat(format_str, as);
 }
 
 FMT_API void vprint(std::FILE *f, string_view format_str, format_args args);
@@ -1288,19 +1529,21 @@ FMT_API void vprint(std::FILE *f, wstring_view format_str, wformat_args args);
     fmt::print(stderr, "Don't {}!", "panic");
   \endrst
  */
-template <typename... Args>
-inline void print(std::FILE *f, string_view format_str, const Args & ... args) {
-  format_arg_store<format_context, Args...> as(args...);
-  vprint(f, format_str, as);
+template<typename... Args>
+inline void print(std::FILE *f, string_view format_str, const Args &... args)
+{
+    format_arg_store<format_context, Args...> as(args...);
+    vprint(f, format_str, as);
 }
 /**
   Prints formatted data to the file *f* which should be in wide-oriented mode set
   via ``fwide(f, 1)`` or ``_setmode(_fileno(f), _O_U8TEXT)`` on Windows.
  */
-template <typename... Args>
-inline void print(std::FILE *f, wstring_view format_str, const Args & ... args) {
-  format_arg_store<wformat_context, Args...> as(args...);
-  vprint(f, format_str, as);
+template<typename... Args>
+inline void print(std::FILE *f, wstring_view format_str, const Args &... args)
+{
+    format_arg_store<wformat_context, Args...> as(args...);
+    vprint(f, format_str, as);
 }
 
 FMT_API void vprint(string_view format_str, format_args args);
@@ -1315,17 +1558,19 @@ FMT_API void vprint(wstring_view format_str, wformat_args args);
     fmt::print("Elapsed time: {0:.2f} seconds", 1.23);
   \endrst
  */
-template <typename... Args>
-inline void print(string_view format_str, const Args & ... args) {
-  format_arg_store<format_context, Args...> as{args...};
-  vprint(format_str, as);
+template<typename... Args>
+inline void print(string_view format_str, const Args &... args)
+{
+    format_arg_store<format_context, Args...> as{args...};
+    vprint(format_str, as);
 }
 
-template <typename... Args>
-inline void print(wstring_view format_str, const Args & ... args) {
-  format_arg_store<wformat_context, Args...> as(args...);
-  vprint(format_str, as);
+template<typename... Args>
+inline void print(wstring_view format_str, const Args &... args)
+{
+    format_arg_store<wformat_context, Args...> as(args...);
+    vprint(format_str, as);
 }
 FMT_END_NAMESPACE
 
-#endif  // FMT_CORE_H_
+#endif // FMT_CORE_H_
diff --git a/include/spdlog/fmt/bundled/format-inl.h b/include/spdlog/fmt/bundled/format-inl.h
index e66bbb7a..76e27225 100644
--- a/include/spdlog/fmt/bundled/format-inl.h
+++ b/include/spdlog/fmt/bundled/format-inl.h
@@ -17,50 +17,52 @@
 #include <climits>
 #include <cmath>
 #include <cstdarg>
-#include <cstddef>  // for std::ptrdiff_t
+#include <cstddef> // for std::ptrdiff_t
 #include <locale>
 
 #if defined(_WIN32) && defined(__MINGW32__)
-# include <cstring>
+#include <cstring>
 #endif
 
 #if FMT_USE_WINDOWS_H
-# if !defined(FMT_HEADER_ONLY) && !defined(WIN32_LEAN_AND_MEAN)
-#  define WIN32_LEAN_AND_MEAN
-# endif
-# if defined(NOMINMAX) || defined(FMT_WIN_MINMAX)
-#  include <windows.h>
-# else
-#  define NOMINMAX
-#  include <windows.h>
-#  undef NOMINMAX
-# endif
+#if !defined(FMT_HEADER_ONLY) && !defined(WIN32_LEAN_AND_MEAN)
+#define WIN32_LEAN_AND_MEAN
+#endif
+#if defined(NOMINMAX) || defined(FMT_WIN_MINMAX)
+#include <windows.h>
+#else
+#define NOMINMAX
+#include <windows.h>
+#undef NOMINMAX
+#endif
 #endif
 
 #if FMT_EXCEPTIONS
-# define FMT_TRY try
-# define FMT_CATCH(x) catch (x)
+#define FMT_TRY try
+#define FMT_CATCH(x) catch (x)
 #else
-# define FMT_TRY if (true)
-# define FMT_CATCH(x) if (false)
+#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
+#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)
+#pragma warning(disable : 4996)
 #endif
 
 // Dummy implementations of strerror_r and strerror_s called if corresponding
 // system functions are not available.
-inline fmt::internal::null<> strerror_r(int, char *, ...) {
-  return fmt::internal::null<>();
+inline fmt::internal::null<> strerror_r(int, char *, ...)
+{
+    return fmt::internal::null<>();
 }
-inline fmt::internal::null<> strerror_s(char *, std::size_t, ...) {
-  return fmt::internal::null<>();
+inline fmt::internal::null<> strerror_s(char *, std::size_t, ...)
+{
+    return fmt::internal::null<>();
 }
 
 FMT_BEGIN_NAMESPACE
@@ -68,22 +70,23 @@ FMT_BEGIN_NAMESPACE
 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 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
+#define FMT_SNPRINTF fmt_snprintf
+#endif // _MSC_VER
 
 #if defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT)
-# define FMT_SWPRINTF snwprintf
+#define FMT_SWPRINTF snwprintf
 #else
-# define FMT_SWPRINTF swprintf
+#define FMT_SWPRINTF swprintf
 #endif // defined(_WIN32) && defined(__MINGW32__) && !defined(__NO_ISOCEXT)
 
 typedef void (*FormatFunc)(internal::buffer &, int, string_view);
@@ -97,468 +100,478 @@ typedef void (*FormatFunc)(internal::buffer &, int, string_view);
 //   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 != FMT_NULL && buffer_size != 0, "invalid buffer");
+int safe_strerror(int error_code, char *&buffer, std::size_t buffer_size) FMT_NOEXCEPT
+{
+    FMT_ASSERT(buffer != FMT_NULL && buffer_size != 0, "invalid buffer");
 
-  class dispatcher {
-   private:
-    int error_code_;
-    char *&buffer_;
-    std::size_t buffer_size_;
+    class dispatcher
+    {
+    private:
+        int error_code_;
+        char *&buffer_;
+        std::size_t buffer_size_;
 
-    // A noop assignment operator to avoid bogus warnings.
-    void operator=(const dispatcher &) {}
+        // A noop assignment operator to avoid bogus warnings.
+        void operator=(const dispatcher &) {}
 
-    // 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 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 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_));
-    }
+        // 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_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;
-    }
+        // 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:
-    dispatcher(int err_code, char *&buf, std::size_t buf_size)
-      : error_code_(err_code), buffer_(buf), buffer_size_(buf_size) {}
+    public:
+        dispatcher(int err_code, char *&buf, std::size_t buf_size)
+            : error_code_(err_code)
+            , buffer_(buf)
+            , buffer_size_(buf_size)
+        {
+        }
 
-    int run() {
-      return handle(strerror_r(error_code_, buffer_, buffer_size_));
-    }
-  };
-  return dispatcher(error_code, buffer, buffer_size).run();
+        int run()
+        {
+            return handle(strerror_r(error_code_, buffer_, buffer_size_));
+        }
+    };
+    return dispatcher(error_code, buffer, buffer_size).run();
 }
 
-void format_error_code(internal::buffer &out, int error_code,
-                       string_view 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.resize(0);
-  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::int_traits<int>::main_type main_type;
-  main_type abs_value = static_cast<main_type>(error_code);
-  if (internal::is_negative(error_code)) {
-    abs_value = 0 - abs_value;
-    ++error_code_size;
-  }
-  error_code_size += internal::count_digits(abs_value);
-  writer w(out);
-  if (message.size() <= inline_buffer_size - error_code_size) {
-    w.write(message);
-    w.write(SEP);
-  }
-  w.write(ERROR_STR);
-  w.write(error_code);
-  assert(out.size() <= inline_buffer_size);
+void format_error_code(internal::buffer &out, int error_code, string_view 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.resize(0);
+    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::int_traits<int>::main_type main_type;
+    main_type abs_value = static_cast<main_type>(error_code);
+    if (internal::is_negative(error_code))
+    {
+        abs_value = 0 - abs_value;
+        ++error_code_size;
+    }
+    error_code_size += internal::count_digits(abs_value);
+    writer w(out);
+    if (message.size() <= inline_buffer_size - error_code_size)
+    {
+        w.write(message);
+        w.write(SEP);
+    }
+    w.write(ERROR_STR);
+    w.write(error_code);
+    assert(out.size() <= inline_buffer_size);
 }
 
-void report_error(FormatFunc func, int error_code,
-                  string_view message) FMT_NOEXCEPT {
-  memory_buffer 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);
+void report_error(FormatFunc func, int error_code, string_view message) FMT_NOEXCEPT
+{
+    memory_buffer 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);
 }
-}  // namespace
+} // namespace
 
-class locale {
- private:
-  std::locale locale_;
+class locale
+{
+private:
+    std::locale locale_;
 
- public:
-  explicit locale(std::locale loc = std::locale()) : locale_(loc) {}
-  std::locale get() { return locale_; }
+public:
+    explicit locale(std::locale loc = std::locale())
+        : locale_(loc)
+    {
+    }
+    std::locale get()
+    {
+        return locale_;
+    }
 };
 
-template <typename Char>
-FMT_FUNC Char internal::thousands_sep(locale_provider *lp) {
-  std::locale loc = lp ? lp->locale().get() : std::locale();
-  return std::use_facet<std::numpunct<Char>>(loc).thousands_sep();
+template<typename Char>
+FMT_FUNC Char internal::thousands_sep(locale_provider *lp)
+{
+    std::locale loc = lp ? lp->locale().get() : std::locale();
+    return std::use_facet<std::numpunct<Char>>(loc).thousands_sep();
 }
 
-FMT_FUNC void system_error::init(
-    int err_code, string_view format_str, format_args args) {
-  error_code_ = err_code;
-  memory_buffer buffer;
-  format_system_error(buffer, err_code, vformat(format_str, args));
-  std::runtime_error &base = *this;
-  base = std::runtime_error(to_string(buffer));
+FMT_FUNC void system_error::init(int err_code, string_view format_str, format_args args)
+{
+    error_code_ = err_code;
+    memory_buffer buffer;
+    format_system_error(buffer, err_code, vformat(format_str, args));
+    std::runtime_error &base = *this;
+    base = std::runtime_error(to_string(buffer));
 }
 
 namespace internal {
-template <typename T>
-int char_traits<char>::format_float(
-    char *buffer, std::size_t size, const char *format, int precision, T value) {
-  return precision < 0 ?
-      FMT_SNPRINTF(buffer, size, format, value) :
-      FMT_SNPRINTF(buffer, size, format, precision, value);
+template<typename T>
+int char_traits<char>::format_float(char *buffer, std::size_t size, const char *format, int precision, T value)
+{
+    return precision < 0 ? FMT_SNPRINTF(buffer, size, format, value) : FMT_SNPRINTF(buffer, size, format, precision, value);
 }
 
-template <typename T>
-int char_traits<wchar_t>::format_float(
-    wchar_t *buffer, std::size_t size, const wchar_t *format, int precision,
-    T value) {
-  return precision < 0 ?
-      FMT_SWPRINTF(buffer, size, format, value) :
-      FMT_SWPRINTF(buffer, size, format, precision, value);
+template<typename T>
+int char_traits<wchar_t>::format_float(wchar_t *buffer, std::size_t size, const wchar_t *format, int precision, T value)
+{
+    return precision < 0 ? FMT_SWPRINTF(buffer, size, format, value) : FMT_SWPRINTF(buffer, size, format, precision, value);
 }
 
-template <typename T>
-const char basic_data<T>::DIGITS[] =
-    "0001020304050607080910111213141516171819"
-    "2021222324252627282930313233343536373839"
-    "4041424344454647484950515253545556575859"
-    "6061626364656667686970717273747576777879"
-    "8081828384858687888990919293949596979899";
+template<typename T>
+const char basic_data<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
+#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 basic_data<T>::POWERS_OF_10_32[] = {
-  0, FMT_POWERS_OF_10(1)
-};
+template<typename T>
+const uint32_t basic_data<T>::POWERS_OF_10_32[] = {0, FMT_POWERS_OF_10(1)};
 
-template <typename T>
-const uint64_t basic_data<T>::POWERS_OF_10_64[] = {
-  0,
-  FMT_POWERS_OF_10(1),
-  FMT_POWERS_OF_10(1000000000ull),
-  10000000000000000000ull
-};
+template<typename T>
+const uint64_t basic_data<T>::POWERS_OF_10_64[] = {0, FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1000000000ull), 10000000000000000000ull};
 
 // Normalized 64-bit significands of pow(10, k), for k = -348, -340, ..., 340.
 // These are generated by support/compute-powers.py.
-template <typename T>
-const uint64_t basic_data<T>::POW10_SIGNIFICANDS[] = {
-  0xfa8fd5a0081c0288, 0xbaaee17fa23ebf76, 0x8b16fb203055ac76, 0xcf42894a5dce35ea,
-  0x9a6bb0aa55653b2d, 0xe61acf033d1a45df, 0xab70fe17c79ac6ca, 0xff77b1fcbebcdc4f,
-  0xbe5691ef416bd60c, 0x8dd01fad907ffc3c, 0xd3515c2831559a83, 0x9d71ac8fada6c9b5,
-  0xea9c227723ee8bcb, 0xaecc49914078536d, 0x823c12795db6ce57, 0xc21094364dfb5637,
-  0x9096ea6f3848984f, 0xd77485cb25823ac7, 0xa086cfcd97bf97f4, 0xef340a98172aace5,
-  0xb23867fb2a35b28e, 0x84c8d4dfd2c63f3b, 0xc5dd44271ad3cdba, 0x936b9fcebb25c996,
-  0xdbac6c247d62a584, 0xa3ab66580d5fdaf6, 0xf3e2f893dec3f126, 0xb5b5ada8aaff80b8,
-  0x87625f056c7c4a8b, 0xc9bcff6034c13053, 0x964e858c91ba2655, 0xdff9772470297ebd,
-  0xa6dfbd9fb8e5b88f, 0xf8a95fcf88747d94, 0xb94470938fa89bcf, 0x8a08f0f8bf0f156b,
-  0xcdb02555653131b6, 0x993fe2c6d07b7fac, 0xe45c10c42a2b3b06, 0xaa242499697392d3,
-  0xfd87b5f28300ca0e, 0xbce5086492111aeb, 0x8cbccc096f5088cc, 0xd1b71758e219652c,
-  0x9c40000000000000, 0xe8d4a51000000000, 0xad78ebc5ac620000, 0x813f3978f8940984,
-  0xc097ce7bc90715b3, 0x8f7e32ce7bea5c70, 0xd5d238a4abe98068, 0x9f4f2726179a2245,
-  0xed63a231d4c4fb27, 0xb0de65388cc8ada8, 0x83c7088e1aab65db, 0xc45d1df942711d9a,
-  0x924d692ca61be758, 0xda01ee641a708dea, 0xa26da3999aef774a, 0xf209787bb47d6b85,
-  0xb454e4a179dd1877, 0x865b86925b9bc5c2, 0xc83553c5c8965d3d, 0x952ab45cfa97a0b3,
-  0xde469fbd99a05fe3, 0xa59bc234db398c25, 0xf6c69a72a3989f5c, 0xb7dcbf5354e9bece,
-  0x88fcf317f22241e2, 0xcc20ce9bd35c78a5, 0x98165af37b2153df, 0xe2a0b5dc971f303a,
-  0xa8d9d1535ce3b396, 0xfb9b7cd9a4a7443c, 0xbb764c4ca7a44410, 0x8bab8eefb6409c1a,
-  0xd01fef10a657842c, 0x9b10a4e5e9913129, 0xe7109bfba19c0c9d, 0xac2820d9623bf429,
-  0x80444b5e7aa7cf85, 0xbf21e44003acdd2d, 0x8e679c2f5e44ff8f, 0xd433179d9c8cb841,
-  0x9e19db92b4e31ba9, 0xeb96bf6ebadf77d9, 0xaf87023b9bf0ee6b
-};
+template<typename T>
+const uint64_t basic_data<T>::POW10_SIGNIFICANDS[] = {0xfa8fd5a0081c0288, 0xbaaee17fa23ebf76, 0x8b16fb203055ac76, 0xcf42894a5dce35ea,
+    0x9a6bb0aa55653b2d, 0xe61acf033d1a45df, 0xab70fe17c79ac6ca, 0xff77b1fcbebcdc4f, 0xbe5691ef416bd60c, 0x8dd01fad907ffc3c,
+    0xd3515c2831559a83, 0x9d71ac8fada6c9b5, 0xea9c227723ee8bcb, 0xaecc49914078536d, 0x823c12795db6ce57, 0xc21094364dfb5637,
+    0x9096ea6f3848984f, 0xd77485cb25823ac7, 0xa086cfcd97bf97f4, 0xef340a98172aace5, 0xb23867fb2a35b28e, 0x84c8d4dfd2c63f3b,
+    0xc5dd44271ad3cdba, 0x936b9fcebb25c996, 0xdbac6c247d62a584, 0xa3ab66580d5fdaf6, 0xf3e2f893dec3f126, 0xb5b5ada8aaff80b8,
+    0x87625f056c7c4a8b, 0xc9bcff6034c13053, 0x964e858c91ba2655, 0xdff9772470297ebd, 0xa6dfbd9fb8e5b88f, 0xf8a95fcf88747d94,
+    0xb94470938fa89bcf, 0x8a08f0f8bf0f156b, 0xcdb02555653131b6, 0x993fe2c6d07b7fac, 0xe45c10c42a2b3b06, 0xaa242499697392d3,
+    0xfd87b5f28300ca0e, 0xbce5086492111aeb, 0x8cbccc096f5088cc, 0xd1b71758e219652c, 0x9c40000000000000, 0xe8d4a51000000000,
+    0xad78ebc5ac620000, 0x813f3978f8940984, 0xc097ce7bc90715b3, 0x8f7e32ce7bea5c70, 0xd5d238a4abe98068, 0x9f4f2726179a2245,
+    0xed63a231d4c4fb27, 0xb0de65388cc8ada8, 0x83c7088e1aab65db, 0xc45d1df942711d9a, 0x924d692ca61be758, 0xda01ee641a708dea,
+    0xa26da3999aef774a, 0xf209787bb47d6b85, 0xb454e4a179dd1877, 0x865b86925b9bc5c2, 0xc83553c5c8965d3d, 0x952ab45cfa97a0b3,
+    0xde469fbd99a05fe3, 0xa59bc234db398c25, 0xf6c69a72a3989f5c, 0xb7dcbf5354e9bece, 0x88fcf317f22241e2, 0xcc20ce9bd35c78a5,
+    0x98165af37b2153df, 0xe2a0b5dc971f303a, 0xa8d9d1535ce3b396, 0xfb9b7cd9a4a7443c, 0xbb764c4ca7a44410, 0x8bab8eefb6409c1a,
+    0xd01fef10a657842c, 0x9b10a4e5e9913129, 0xe7109bfba19c0c9d, 0xac2820d9623bf429, 0x80444b5e7aa7cf85, 0xbf21e44003acdd2d,
+    0x8e679c2f5e44ff8f, 0xd433179d9c8cb841, 0x9e19db92b4e31ba9, 0xeb96bf6ebadf77d9, 0xaf87023b9bf0ee6b};
 
 // Binary exponents of pow(10, k), for k = -348, -340, ..., 340, corresponding
 // to significands above.
-template <typename T>
-const int16_t basic_data<T>::POW10_EXPONENTS[] = {
-  -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007,  -980,  -954,
-   -927,  -901,  -874,  -847,  -821,  -794,  -768,  -741,  -715,  -688,  -661,
-   -635,  -608,  -582,  -555,  -529,  -502,  -475,  -449,  -422,  -396,  -369,
-   -343,  -316,  -289,  -263,  -236,  -210,  -183,  -157,  -130,  -103,   -77,
-    -50,   -24,     3,    30,    56,    83,   109,   136,   162,   189,   216,
-    242,   269,   295,   322,   348,   375,   402,   428,   455,   481,   508,
-    534,   561,   588,   614,   641,   667,   694,   720,   747,   774,   800,
-    827,   853,   880,   907,   933,   960,   986,  1013,  1039,  1066
-};
+template<typename T>
+const int16_t basic_data<T>::POW10_EXPONENTS[] = {-1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980, -954, -927, -901,
+    -874, -847, -821, -794, -768, -741, -715, -688, -661, -635, -608, -582, -555, -529, -502, -475, -449, -422, -396, -369, -343, -316,
+    -289, -263, -236, -210, -183, -157, -130, -103, -77, -50, -24, 3, 30, 56, 83, 109, 136, 162, 189, 216, 242, 269, 295, 322, 348, 375,
+    402, 428, 455, 481, 508, 534, 561, 588, 614, 641, 667, 694, 720, 747, 774, 800, 827, 853, 880, 907, 933, 960, 986, 1013, 1039, 1066};
 
-template <typename T> const char basic_data<T>::RESET_COLOR[] = "\x1b[0m";
-template <typename T> const wchar_t basic_data<T>::WRESET_COLOR[] = L"\x1b[0m";
+template<typename T>
+const char basic_data<T>::RESET_COLOR[] = "\x1b[0m";
+template<typename T>
+const wchar_t basic_data<T>::WRESET_COLOR[] = L"\x1b[0m";
 
-FMT_FUNC fp operator*(fp x, fp y) {
-  // Multiply 32-bit parts of significands.
-  uint64_t mask = (1ULL << 32) - 1;
-  uint64_t a = x.f >> 32, b = x.f & mask;
-  uint64_t c = y.f >> 32, d = y.f & mask;
-  uint64_t ac = a * c, bc = b * c, ad = a * d, bd = b * d;
-  // Compute mid 64-bit of result and round.
-  uint64_t mid = (bd >> 32) + (ad & mask) + (bc & mask) + (1U << 31);
-  return fp(ac + (ad >> 32) + (bc >> 32) + (mid >> 32), x.e + y.e + 64);
+FMT_FUNC fp operator*(fp x, fp y)
+{
+    // Multiply 32-bit parts of significands.
+    uint64_t mask = (1ULL << 32) - 1;
+    uint64_t a = x.f >> 32, b = x.f & mask;
+    uint64_t c = y.f >> 32, d = y.f & mask;
+    uint64_t ac = a * c, bc = b * c, ad = a * d, bd = b * d;
+    // Compute mid 64-bit of result and round.
+    uint64_t mid = (bd >> 32) + (ad & mask) + (bc & mask) + (1U << 31);
+    return fp(ac + (ad >> 32) + (bc >> 32) + (mid >> 32), x.e + y.e + 64);
 }
 
-FMT_FUNC fp get_cached_power(int min_exponent, int &pow10_exponent) {
-  const double one_over_log2_10 = 0.30102999566398114;  // 1 / log2(10)
-  int index = static_cast<int>(std::ceil(
-        (min_exponent + fp::significand_size - 1) * one_over_log2_10));
-  // Decimal exponent of the first (smallest) cached power of 10.
-  const int first_dec_exp = -348;
-  // Difference between two consecutive decimal exponents in cached powers of 10.
-  const int dec_exp_step = 8;
-  index = (index - first_dec_exp - 1) / dec_exp_step + 1;
-  pow10_exponent = first_dec_exp + index * dec_exp_step;
-  return fp(data::POW10_SIGNIFICANDS[index], data::POW10_EXPONENTS[index]);
-}
-}  // namespace internal
-
-#if FMT_USE_WINDOWS_H
-
-FMT_FUNC internal::utf8_to_utf16::utf8_to_utf16(string_view s) {
-  static const char ERROR_MSG[] = "cannot convert string from UTF-8 to UTF-16";
-  if (s.size() > INT_MAX)
-    FMT_THROW(windows_error(ERROR_INVALID_PARAMETER, ERROR_MSG));
-  int s_size = static_cast<int>(s.size());
-  if (s_size == 0) {
-    // MultiByteToWideChar does not support zero length, handle separately.
-    buffer_.resize(1);
-    buffer_[0] = 0;
-    return;
-  }
-
-  int length = MultiByteToWideChar(
-      CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, FMT_NULL, 0);
-  if (length == 0)
-    FMT_THROW(windows_error(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(windows_error(GetLastError(), ERROR_MSG));
-  buffer_[length] = 0;
-}
-
-FMT_FUNC internal::utf16_to_utf8::utf16_to_utf8(wstring_view s) {
-  if (int error_code = convert(s)) {
-    FMT_THROW(windows_error(error_code,
-        "cannot convert string from UTF-16 to UTF-8"));
-  }
-}
-
-FMT_FUNC int internal::utf16_to_utf8::convert(wstring_view s) {
-  if (s.size() > INT_MAX)
-    return ERROR_INVALID_PARAMETER;
-  int s_size = static_cast<int>(s.size());
-  if (s_size == 0) {
-    // WideCharToMultiByte does not support zero length, handle separately.
-    buffer_.resize(1);
-    buffer_[0] = 0;
-    return 0;
-  }
-
-  int length = WideCharToMultiByte(
-        CP_UTF8, 0, s.data(), s_size, FMT_NULL, 0, FMT_NULL, FMT_NULL);
-  if (length == 0)
-    return GetLastError();
-  buffer_.resize(length + 1);
-  length = WideCharToMultiByte(
-    CP_UTF8, 0, s.data(), s_size, &buffer_[0], length, FMT_NULL, FMT_NULL);
-  if (length == 0)
-    return GetLastError();
-  buffer_[length] = 0;
-  return 0;
-}
-
-FMT_FUNC void windows_error::init(
-    int err_code, string_view format_str, format_args args) {
-  error_code_ = err_code;
-  memory_buffer buffer;
-  internal::format_windows_error(buffer, err_code, vformat(format_str, args));
-  std::runtime_error &base = *this;
-  base = std::runtime_error(to_string(buffer));
-}
-
-FMT_FUNC void internal::format_windows_error(
-    internal::buffer &out, int error_code, string_view message) FMT_NOEXCEPT {
-  FMT_TRY {
-    wmemory_buffer buf;
-    buf.resize(inline_buffer_size);
-    for (;;) {
-      wchar_t *system_message = &buf[0];
-      int result = FormatMessageW(
-          FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
-          FMT_NULL, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-          system_message, static_cast<uint32_t>(buf.size()), FMT_NULL);
-      if (result != 0) {
-        utf16_to_utf8 utf8_message;
-        if (utf8_message.convert(system_message) == ERROR_SUCCESS) {
-          writer w(out);
-          w.write(message);
-          w.write(": ");
-          w.write(utf8_message);
-          return;
-        }
-        break;
-      }
-      if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
-        break;  // Can't get error message, report error code instead.
-      buf.resize(buf.size() * 2);
-    }
-  } FMT_CATCH(...) {}
-  format_error_code(out, error_code, message);
-}
-
-#endif  // FMT_USE_WINDOWS_H
-
-FMT_FUNC void format_system_error(
-    internal::buffer &out, int error_code, string_view message) FMT_NOEXCEPT {
-  FMT_TRY {
-    memory_buffer buf;
-    buf.resize(inline_buffer_size);
-    for (;;) {
-      char *system_message = &buf[0];
-      int result = safe_strerror(error_code, system_message, buf.size());
-      if (result == 0) {
-        writer w(out);
-        w.write(message);
-        w.write(": ");
-        w.write(system_message);
-        return;
-      }
-      if (result != ERANGE)
-        break;  // Can't get error message, report error code instead.
-      buf.resize(buf.size() * 2);
-    }
-  } FMT_CATCH(...) {}
-  format_error_code(out, error_code, message);
-}
-
-template <typename Char>
-void basic_fixed_buffer<Char>::grow(std::size_t) {
-  FMT_THROW(std::runtime_error("buffer overflow"));
-}
-
-FMT_FUNC void internal::error_handler::on_error(const char *message) {
-  FMT_THROW(format_error(message));
-}
-
-FMT_FUNC void report_system_error(
-    int error_code, fmt::string_view message) FMT_NOEXCEPT {
-  report_error(format_system_error, error_code, message);
-}
-
-#if FMT_USE_WINDOWS_H
-FMT_FUNC void report_windows_error(
-    int error_code, fmt::string_view message) FMT_NOEXCEPT {
-  report_error(internal::format_windows_error, error_code, message);
-}
-#endif
-
-FMT_FUNC void vprint(std::FILE *f, string_view format_str, format_args args) {
-  memory_buffer buffer;
-  vformat_to(buffer, format_str, args);
-  std::fwrite(buffer.data(), 1, buffer.size(), f);
-}
-
-FMT_FUNC void vprint(std::FILE *f, wstring_view format_str, wformat_args args) {
-  wmemory_buffer buffer;
-  vformat_to(buffer, format_str, args);
-  std::fwrite(buffer.data(), sizeof(wchar_t), buffer.size(), f);
-}
-
-FMT_FUNC void vprint(string_view format_str, format_args args) {
-  vprint(stdout, format_str, args);
-}
-
-FMT_FUNC void vprint(wstring_view format_str, wformat_args args) {
-  vprint(stdout, format_str, args);
-}
-
-#ifndef FMT_EXTENDED_COLORS
-FMT_FUNC void vprint_colored(color c, string_view format, format_args args) {
-  char escape[] = "\x1b[30m";
-  escape[3] = static_cast<char>('0' + c);
-  std::fputs(escape, stdout);
-  vprint(format, args);
-  std::fputs(internal::data::RESET_COLOR, stdout);
-}
-
-FMT_FUNC void vprint_colored(color c, wstring_view format, wformat_args args) {
-  wchar_t escape[] = L"\x1b[30m";
-  escape[3] = static_cast<wchar_t>('0' + c);
-  std::fputws(escape, stdout);
-  vprint(format, args);
-  std::fputws(internal::data::WRESET_COLOR, stdout);
-}
-#else
-namespace internal {
-FMT_CONSTEXPR void to_esc(uint8_t c, char out[], int offset) {
-  out[offset + 0] = static_cast<char>('0' + c / 100);
-  out[offset + 1] = static_cast<char>('0' + c / 10 % 10);
-  out[offset + 2] = static_cast<char>('0' + c % 10);
+FMT_FUNC fp get_cached_power(int min_exponent, int &pow10_exponent)
+{
+    const double one_over_log2_10 = 0.30102999566398114; // 1 / log2(10)
+    int index = static_cast<int>(std::ceil((min_exponent + fp::significand_size - 1) * one_over_log2_10));
+    // Decimal exponent of the first (smallest) cached power of 10.
+    const int first_dec_exp = -348;
+    // Difference between two consecutive decimal exponents in cached powers of 10.
+    const int dec_exp_step = 8;
+    index = (index - first_dec_exp - 1) / dec_exp_step + 1;
+    pow10_exponent = first_dec_exp + index * dec_exp_step;
+    return fp(data::POW10_SIGNIFICANDS[index], data::POW10_EXPONENTS[index]);
 }
 } // namespace internal
 
-FMT_FUNC void vprint_rgb(rgb fd, string_view format, format_args args) {
-  char escape_fd[] = "\x1b[38;2;000;000;000m";
-  internal::to_esc(fd.r, escape_fd, 7);
-  internal::to_esc(fd.g, escape_fd, 11);
-  internal::to_esc(fd.b, escape_fd, 15);
+#if FMT_USE_WINDOWS_H
 
-  std::fputs(escape_fd, stdout);
-  vprint(format, args);
-  std::fputs(internal::data::RESET_COLOR, stdout);
+FMT_FUNC internal::utf8_to_utf16::utf8_to_utf16(string_view s)
+{
+    static const char ERROR_MSG[] = "cannot convert string from UTF-8 to UTF-16";
+    if (s.size() > INT_MAX)
+        FMT_THROW(windows_error(ERROR_INVALID_PARAMETER, ERROR_MSG));
+    int s_size = static_cast<int>(s.size());
+    if (s_size == 0)
+    {
+        // MultiByteToWideChar does not support zero length, handle separately.
+        buffer_.resize(1);
+        buffer_[0] = 0;
+        return;
+    }
+
+    int length = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, s.data(), s_size, FMT_NULL, 0);
+    if (length == 0)
+        FMT_THROW(windows_error(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(windows_error(GetLastError(), ERROR_MSG));
+    buffer_[length] = 0;
 }
 
-FMT_FUNC void vprint_rgb(rgb fd, rgb bg, string_view format, format_args args) {
-  char escape_fd[] = "\x1b[38;2;000;000;000m"; // foreground color
-  char escape_bg[] = "\x1b[48;2;000;000;000m"; // background color
-  internal::to_esc(fd.r, escape_fd, 7);
-  internal::to_esc(fd.g, escape_fd, 11);
-  internal::to_esc(fd.b, escape_fd, 15);
+FMT_FUNC internal::utf16_to_utf8::utf16_to_utf8(wstring_view s)
+{
+    if (int error_code = convert(s))
+    {
+        FMT_THROW(windows_error(error_code, "cannot convert string from UTF-16 to UTF-8"));
+    }
+}
 
-  internal::to_esc(bg.r, escape_bg, 7);
-  internal::to_esc(bg.g, escape_bg, 11);
-  internal::to_esc(bg.b, escape_bg, 15);
+FMT_FUNC int internal::utf16_to_utf8::convert(wstring_view s)
+{
+    if (s.size() > INT_MAX)
+        return ERROR_INVALID_PARAMETER;
+    int s_size = static_cast<int>(s.size());
+    if (s_size == 0)
+    {
+        // WideCharToMultiByte does not support zero length, handle separately.
+        buffer_.resize(1);
+        buffer_[0] = 0;
+        return 0;
+    }
 
-  std::fputs(escape_fd, stdout);
-  std::fputs(escape_bg, stdout);
-  vprint(format, args);
-  std::fputs(internal::data::RESET_COLOR, stdout);
+    int length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, FMT_NULL, 0, FMT_NULL, FMT_NULL);
+    if (length == 0)
+        return GetLastError();
+    buffer_.resize(length + 1);
+    length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, &buffer_[0], length, FMT_NULL, FMT_NULL);
+    if (length == 0)
+        return GetLastError();
+    buffer_[length] = 0;
+    return 0;
+}
+
+FMT_FUNC void windows_error::init(int err_code, string_view format_str, format_args args)
+{
+    error_code_ = err_code;
+    memory_buffer buffer;
+    internal::format_windows_error(buffer, err_code, vformat(format_str, args));
+    std::runtime_error &base = *this;
+    base = std::runtime_error(to_string(buffer));
+}
+
+FMT_FUNC void internal::format_windows_error(internal::buffer &out, int error_code, string_view message) FMT_NOEXCEPT
+{
+    FMT_TRY
+    {
+        wmemory_buffer buf;
+        buf.resize(inline_buffer_size);
+        for (;;)
+        {
+            wchar_t *system_message = &buf[0];
+            int result = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, FMT_NULL, error_code,
+                MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), system_message, static_cast<uint32_t>(buf.size()), FMT_NULL);
+            if (result != 0)
+            {
+                utf16_to_utf8 utf8_message;
+                if (utf8_message.convert(system_message) == ERROR_SUCCESS)
+                {
+                    writer w(out);
+                    w.write(message);
+                    w.write(": ");
+                    w.write(utf8_message);
+                    return;
+                }
+                break;
+            }
+            if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
+                break; // Can't get error message, report error code instead.
+            buf.resize(buf.size() * 2);
+        }
+    }
+    FMT_CATCH(...) {}
+    format_error_code(out, error_code, message);
+}
+
+#endif // FMT_USE_WINDOWS_H
+
+FMT_FUNC void format_system_error(internal::buffer &out, int error_code, string_view message) FMT_NOEXCEPT
+{
+    FMT_TRY
+    {
+        memory_buffer buf;
+        buf.resize(inline_buffer_size);
+        for (;;)
+        {
+            char *system_message = &buf[0];
+            int result = safe_strerror(error_code, system_message, buf.size());
+            if (result == 0)
+            {
+                writer w(out);
+                w.write(message);
+                w.write(": ");
+                w.write(system_message);
+                return;
+            }
+            if (result != ERANGE)
+                break; // Can't get error message, report error code instead.
+            buf.resize(buf.size() * 2);
+        }
+    }
+    FMT_CATCH(...) {}
+    format_error_code(out, error_code, message);
+}
+
+template<typename Char>
+void basic_fixed_buffer<Char>::grow(std::size_t)
+{
+    FMT_THROW(std::runtime_error("buffer overflow"));
+}
+
+FMT_FUNC void internal::error_handler::on_error(const char *message)
+{
+    FMT_THROW(format_error(message));
+}
+
+FMT_FUNC void report_system_error(int error_code, fmt::string_view message) FMT_NOEXCEPT
+{
+    report_error(format_system_error, error_code, message);
+}
+
+#if FMT_USE_WINDOWS_H
+FMT_FUNC void report_windows_error(int error_code, fmt::string_view message) FMT_NOEXCEPT
+{
+    report_error(internal::format_windows_error, error_code, message);
 }
 #endif
 
-FMT_FUNC locale locale_provider::locale() { return fmt::locale(); }
+FMT_FUNC void vprint(std::FILE *f, string_view format_str, format_args args)
+{
+    memory_buffer buffer;
+    vformat_to(buffer, format_str, args);
+    std::fwrite(buffer.data(), 1, buffer.size(), f);
+}
+
+FMT_FUNC void vprint(std::FILE *f, wstring_view format_str, wformat_args args)
+{
+    wmemory_buffer buffer;
+    vformat_to(buffer, format_str, args);
+    std::fwrite(buffer.data(), sizeof(wchar_t), buffer.size(), f);
+}
+
+FMT_FUNC void vprint(string_view format_str, format_args args)
+{
+    vprint(stdout, format_str, args);
+}
+
+FMT_FUNC void vprint(wstring_view format_str, wformat_args args)
+{
+    vprint(stdout, format_str, args);
+}
+
+#ifndef FMT_EXTENDED_COLORS
+FMT_FUNC void vprint_colored(color c, string_view format, format_args args)
+{
+    char escape[] = "\x1b[30m";
+    escape[3] = static_cast<char>('0' + c);
+    std::fputs(escape, stdout);
+    vprint(format, args);
+    std::fputs(internal::data::RESET_COLOR, stdout);
+}
+
+FMT_FUNC void vprint_colored(color c, wstring_view format, wformat_args args)
+{
+    wchar_t escape[] = L"\x1b[30m";
+    escape[3] = static_cast<wchar_t>('0' + c);
+    std::fputws(escape, stdout);
+    vprint(format, args);
+    std::fputws(internal::data::WRESET_COLOR, stdout);
+}
+#else
+namespace internal {
+FMT_CONSTEXPR void to_esc(uint8_t c, char out[], int offset)
+{
+    out[offset + 0] = static_cast<char>('0' + c / 100);
+    out[offset + 1] = static_cast<char>('0' + c / 10 % 10);
+    out[offset + 2] = static_cast<char>('0' + c % 10);
+}
+} // namespace internal
+
+FMT_FUNC void vprint_rgb(rgb fd, string_view format, format_args args)
+{
+    char escape_fd[] = "\x1b[38;2;000;000;000m";
+    internal::to_esc(fd.r, escape_fd, 7);
+    internal::to_esc(fd.g, escape_fd, 11);
+    internal::to_esc(fd.b, escape_fd, 15);
+
+    std::fputs(escape_fd, stdout);
+    vprint(format, args);
+    std::fputs(internal::data::RESET_COLOR, stdout);
+}
+
+FMT_FUNC void vprint_rgb(rgb fd, rgb bg, string_view format, format_args args)
+{
+    char escape_fd[] = "\x1b[38;2;000;000;000m"; // foreground color
+    char escape_bg[] = "\x1b[48;2;000;000;000m"; // background color
+    internal::to_esc(fd.r, escape_fd, 7);
+    internal::to_esc(fd.g, escape_fd, 11);
+    internal::to_esc(fd.b, escape_fd, 15);
+
+    internal::to_esc(bg.r, escape_bg, 7);
+    internal::to_esc(bg.g, escape_bg, 11);
+    internal::to_esc(bg.b, escape_bg, 15);
+
+    std::fputs(escape_fd, stdout);
+    std::fputs(escape_bg, stdout);
+    vprint(format, args);
+    std::fputs(internal::data::RESET_COLOR, stdout);
+}
+#endif
+
+FMT_FUNC locale locale_provider::locale()
+{
+    return fmt::locale();
+}
 
 FMT_END_NAMESPACE
 
 #ifdef _MSC_VER
-# pragma warning(pop)
+#pragma warning(pop)
 #endif
 
-#endif  // FMT_FORMAT_INL_H_
+#endif // FMT_FORMAT_INL_H_
diff --git a/include/spdlog/fmt/bundled/format.h b/include/spdlog/fmt/bundled/format.h
index 8b6fadd3..2e26f907 100644
--- a/include/spdlog/fmt/bundled/format.h
+++ b/include/spdlog/fmt/bundled/format.h
@@ -38,195 +38,195 @@
 #include <stdint.h>
 
 #ifdef __clang__
-# define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__)
+#define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__)
 #else
-# define FMT_CLANG_VERSION 0
+#define FMT_CLANG_VERSION 0
 #endif
 
 #ifdef __INTEL_COMPILER
-# define FMT_ICC_VERSION __INTEL_COMPILER
+#define FMT_ICC_VERSION __INTEL_COMPILER
 #elif defined(__ICL)
-# define FMT_ICC_VERSION __ICL
+#define FMT_ICC_VERSION __ICL
 #else
-# define FMT_ICC_VERSION 0
+#define FMT_ICC_VERSION 0
 #endif
 
 #include "core.h"
 
 #if FMT_GCC_VERSION >= 406 || FMT_CLANG_VERSION
-# pragma GCC diagnostic push
+#pragma GCC diagnostic push
 
 // Disable the warning about declaration shadowing because it affects too
 // many valid cases.
-# pragma GCC diagnostic ignored "-Wshadow"
+#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"
+#pragma GCC diagnostic ignored "-Wsign-conversion"
 #endif
 
 #ifdef _SECURE_SCL
-# define FMT_SECURE_SCL _SECURE_SCL
+#define FMT_SECURE_SCL _SECURE_SCL
 #else
-# define FMT_SECURE_SCL 0
+#define FMT_SECURE_SCL 0
 #endif
 
 #if FMT_SECURE_SCL
-# include <iterator>
+#include <iterator>
 #endif
 
 #ifdef __has_builtin
-# define FMT_HAS_BUILTIN(x) __has_builtin(x)
+#define FMT_HAS_BUILTIN(x) __has_builtin(x)
 #else
-# define FMT_HAS_BUILTIN(x) 0
+#define FMT_HAS_BUILTIN(x) 0
 #endif
 
 #ifdef __GNUC_LIBSTD__
-# define FMT_GNUC_LIBSTD_VERSION (__GNUC_LIBSTD__ * 100 + __GNUC_LIBSTD_MINOR__)
+#define FMT_GNUC_LIBSTD_VERSION (__GNUC_LIBSTD__ * 100 + __GNUC_LIBSTD_MINOR__)
 #endif
 
 #ifndef FMT_THROW
-# if FMT_EXCEPTIONS
-#  if FMT_MSC_VER
+#if FMT_EXCEPTIONS
+#if FMT_MSC_VER
 FMT_BEGIN_NAMESPACE
 namespace internal {
-template <typename Exception>
-inline void do_throw(const Exception &x) {
-  // Silence unreachable code warnings in MSVC because these are nearly
-  // impossible to fix in a generic code.
-  volatile bool b = true;
-  if (b)
-    throw x;
-}
+template<typename Exception>
+inline void do_throw(const Exception &x)
+{
+    // Silence unreachable code warnings in MSVC because these are nearly
+    // impossible to fix in a generic code.
+    volatile bool b = true;
+    if (b)
+        throw x;
 }
+} // namespace internal
 FMT_END_NAMESPACE
-#   define FMT_THROW(x) fmt::internal::do_throw(x)
-#  else
-#   define FMT_THROW(x) throw x
-#  endif
-# else
-#  define FMT_THROW(x) do { static_cast<void>(sizeof(x)); assert(false); } while(false);
-# endif
+#define FMT_THROW(x) fmt::internal::do_throw(x)
+#else
+#define FMT_THROW(x) throw x
+#endif
+#else
+#define FMT_THROW(x)                                                                                                                       \
+    do                                                                                                                                     \
+    {                                                                                                                                      \
+        static_cast<void>(sizeof(x));                                                                                                      \
+        assert(false);                                                                                                                     \
+    } while (false);
+#endif
 #endif
 
 #ifndef FMT_USE_USER_DEFINED_LITERALS
 // For Intel's compiler both it and the system gcc/msc must support UDLs.
-# if (FMT_HAS_FEATURE(cxx_user_literals) || \
-      FMT_GCC_VERSION >= 407 || FMT_MSC_VER >= 1900) && \
-      (!FMT_ICC_VERSION || FMT_ICC_VERSION >= 1500)
-#  define FMT_USE_USER_DEFINED_LITERALS 1
-# else
-#  define FMT_USE_USER_DEFINED_LITERALS 0
-# endif
+#if (FMT_HAS_FEATURE(cxx_user_literals) || FMT_GCC_VERSION >= 407 || FMT_MSC_VER >= 1900) && (!FMT_ICC_VERSION || FMT_ICC_VERSION >= 1500)
+#define FMT_USE_USER_DEFINED_LITERALS 1
+#else
+#define FMT_USE_USER_DEFINED_LITERALS 0
+#endif
 #endif
 
-#if FMT_USE_USER_DEFINED_LITERALS && !defined(FMT_ICC_VERSION) && \
-    ((FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L) || \
-    (defined(FMT_CLANG_VERSION) && FMT_CLANG_VERSION >= 304))
-# define FMT_UDL_TEMPLATE 1
+#if FMT_USE_USER_DEFINED_LITERALS && !defined(FMT_ICC_VERSION) &&                                                                          \
+    ((FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L) || (defined(FMT_CLANG_VERSION) && FMT_CLANG_VERSION >= 304))
+#define FMT_UDL_TEMPLATE 1
 #else
-# define FMT_UDL_TEMPLATE 0
+#define FMT_UDL_TEMPLATE 0
 #endif
 
 #ifndef FMT_USE_EXTERN_TEMPLATES
-# ifndef FMT_HEADER_ONLY
-#  define FMT_USE_EXTERN_TEMPLATES \
-     ((FMT_CLANG_VERSION >= 209 && __cplusplus >= 201103L) || \
-      (FMT_GCC_VERSION >= 303 && FMT_HAS_GXX_CXX11))
-# else
-#  define FMT_USE_EXTERN_TEMPLATES 0
-# endif
+#ifndef FMT_HEADER_ONLY
+#define FMT_USE_EXTERN_TEMPLATES ((FMT_CLANG_VERSION >= 209 && __cplusplus >= 201103L) || (FMT_GCC_VERSION >= 303 && FMT_HAS_GXX_CXX11))
+#else
+#define FMT_USE_EXTERN_TEMPLATES 0
+#endif
 #endif
 
-#if FMT_HAS_GXX_CXX11 || FMT_HAS_FEATURE(cxx_trailing_return) || \
-    FMT_MSC_VER >= 1600
-# define FMT_USE_TRAILING_RETURN 1
+#if FMT_HAS_GXX_CXX11 || FMT_HAS_FEATURE(cxx_trailing_return) || FMT_MSC_VER >= 1600
+#define FMT_USE_TRAILING_RETURN 1
 #else
-# define FMT_USE_TRAILING_RETURN 0
+#define FMT_USE_TRAILING_RETURN 0
 #endif
 
-#if FMT_HAS_GXX_CXX11 || FMT_HAS_FEATURE(cxx_rvalue_references) || \
-    FMT_MSC_VER >= 1600
-# define FMT_USE_RVALUE_REFERENCES 1
+#if FMT_HAS_GXX_CXX11 || FMT_HAS_FEATURE(cxx_rvalue_references) || FMT_MSC_VER >= 1600
+#define FMT_USE_RVALUE_REFERENCES 1
 #else
-# define FMT_USE_RVALUE_REFERENCES 0
+#define FMT_USE_RVALUE_REFERENCES 0
 #endif
 
 #ifndef FMT_USE_GRISU
-# define FMT_USE_GRISU 0
+#define FMT_USE_GRISU 0
 #endif
 
 // __builtin_clz is broken in clang with Microsoft CodeGen:
 // https://github.com/fmtlib/fmt/issues/519
 #ifndef _MSC_VER
-# 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_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
+#if FMT_GCC_VERSION >= 400 || FMT_HAS_BUILTIN(__builtin_clzll)
+#define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n)
+#endif
 #endif
 
 // A workaround for gcc 4.4 that doesn't support union members with ctors.
-#if (FMT_GCC_VERSION && FMT_GCC_VERSION <= 404) || \
-    (FMT_MSC_VER && FMT_MSC_VER <= 1800)
-# define FMT_UNION struct
+#if (FMT_GCC_VERSION && FMT_GCC_VERSION <= 404) || (FMT_MSC_VER && FMT_MSC_VER <= 1800)
+#define FMT_UNION struct
 #else
-# define FMT_UNION union
+#define FMT_UNION union
 #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) && !defined(_MANAGED)
-# include <intrin.h>  // _BitScanReverse, _BitScanReverse64
+#include <intrin.h> // _BitScanReverse, _BitScanReverse64
 
 FMT_BEGIN_NAMESPACE
 namespace internal {
 // Avoid Clang with Microsoft CodeGen's -Wunknown-pragmas warning.
-# ifndef __clang__
-#  pragma intrinsic(_BitScanReverse)
-# endif
-inline uint32_t clz(uint32_t x) {
-  unsigned long r = 0;
-  _BitScanReverse(&r, x);
+#ifndef __clang__
+#pragma intrinsic(_BitScanReverse)
+#endif
+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;
+    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)
+#define FMT_BUILTIN_CLZ(n) fmt::internal::clz(n)
 
-# if defined(_WIN64) && !defined(__clang__)
-#  pragma intrinsic(_BitScanReverse64)
-# endif
+#if defined(_WIN64) && !defined(__clang__)
+#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);
+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
+    // 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)
+    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)
+} // namespace internal
 FMT_END_NAMESPACE
 #endif
 
@@ -236,114 +236,155 @@ namespace internal {
 // An equivalent of `*reinterpret_cast<Dest*>(&source)` that doesn't produce
 // undefined behavior (e.g. due to type aliasing).
 // Example: uint64_t d = bit_cast<uint64_t>(2.718);
-template <typename Dest, typename Source>
-inline Dest bit_cast(const Source& source) {
-  static_assert(sizeof(Dest) == sizeof(Source), "size mismatch");
-  Dest dest;
-  std::memcpy(&dest, &source, sizeof(dest));
-  return dest;
+template<typename Dest, typename Source>
+inline Dest bit_cast(const Source &source)
+{
+    static_assert(sizeof(Dest) == sizeof(Source), "size mismatch");
+    Dest dest;
+    std::memcpy(&dest, &source, sizeof(dest));
+    return dest;
 }
 
 // An implementation of begin and end for pre-C++11 compilers such as gcc 4.
-template <typename C>
-FMT_CONSTEXPR auto begin(const C &c) -> decltype(c.begin()) {
-  return c.begin();
+template<typename C>
+FMT_CONSTEXPR auto begin(const C &c) -> decltype(c.begin())
+{
+    return c.begin();
+}
+template<typename T, std::size_t N>
+FMT_CONSTEXPR T *begin(T (&array)[N]) FMT_NOEXCEPT
+{
+    return array;
+}
+template<typename C>
+FMT_CONSTEXPR auto end(const C &c) -> decltype(c.end())
+{
+    return c.end();
+}
+template<typename T, std::size_t N>
+FMT_CONSTEXPR T *end(T (&array)[N]) FMT_NOEXCEPT
+{
+    return array + N;
 }
-template <typename T, std::size_t N>
-FMT_CONSTEXPR T *begin(T (&array)[N]) FMT_NOEXCEPT { return array; }
-template <typename C>
-FMT_CONSTEXPR auto end(const C &c) -> decltype(c.end()) { return c.end(); }
-template <typename T, std::size_t N>
-FMT_CONSTEXPR T *end(T (&array)[N]) FMT_NOEXCEPT { return array + N; }
 
 // For std::result_of in gcc 4.4.
-template <typename Result>
-struct function {
-  template <typename T>
-  struct result { typedef Result type; };
+template<typename Result>
+struct function
+{
+    template<typename T>
+    struct result
+    {
+        typedef Result type;
+    };
 };
 
-struct dummy_int {
-  int data[2];
-  operator int() const { return 0; }
+struct dummy_int
+{
+    int data[2];
+    operator int() const
+    {
+        return 0;
+    }
 };
 typedef std::numeric_limits<internal::dummy_int> fputil;
 
 // Dummy implementations of system functions such as signbit and ecvt called
 // if the latter are not available.
-inline dummy_int signbit(...) { return dummy_int(); }
-inline dummy_int _ecvt_s(...) { return dummy_int(); }
-inline dummy_int isinf(...) { return dummy_int(); }
-inline dummy_int _finite(...) { return dummy_int(); }
-inline dummy_int isnan(...) { return dummy_int(); }
-inline dummy_int _isnan(...) { return dummy_int(); }
+inline dummy_int signbit(...)
+{
+    return dummy_int();
+}
+inline dummy_int _ecvt_s(...)
+{
+    return dummy_int();
+}
+inline dummy_int isinf(...)
+{
+    return dummy_int();
+}
+inline dummy_int _finite(...)
+{
+    return dummy_int();
+}
+inline dummy_int isnan(...)
+{
+    return dummy_int();
+}
+inline dummy_int _isnan(...)
+{
+    return dummy_int();
+}
 
 // A handmade floating-point number f * pow(2, e).
-class fp {
- private:
-  typedef uint64_t significand_type;
+class fp
+{
+private:
+    typedef uint64_t significand_type;
 
-  // All sizes are in bits.
-  static FMT_CONSTEXPR_DECL const int char_size =
-    std::numeric_limits<unsigned char>::digits;
-  // Subtract 1 to account for an implicit most significant bit in the
-  // normalized form.
-  static FMT_CONSTEXPR_DECL const int double_significand_size =
-    std::numeric_limits<double>::digits - 1;
-  static FMT_CONSTEXPR_DECL const uint64_t implicit_bit =
-    1ull << double_significand_size;
+    // All sizes are in bits.
+    static FMT_CONSTEXPR_DECL const int char_size = std::numeric_limits<unsigned char>::digits;
+    // Subtract 1 to account for an implicit most significant bit in the
+    // normalized form.
+    static FMT_CONSTEXPR_DECL const int double_significand_size = std::numeric_limits<double>::digits - 1;
+    static FMT_CONSTEXPR_DECL const uint64_t implicit_bit = 1ull << double_significand_size;
 
- public:
-  significand_type f;
-  int e;
+public:
+    significand_type f;
+    int e;
 
-  static FMT_CONSTEXPR_DECL const int significand_size =
-    sizeof(significand_type) * char_size;
+    static FMT_CONSTEXPR_DECL const int significand_size = sizeof(significand_type) * char_size;
 
-  fp(uint64_t f, int e): f(f), e(e) {}
-
-  // Constructs fp from an IEEE754 double. It is a template to prevent compile
-  // errors on platforms where double is not IEEE754.
-  template <typename Double>
-  explicit fp(Double d) {
-    // Assume double is in the format [sign][exponent][significand].
-    typedef std::numeric_limits<Double> limits;
-    const int double_size = sizeof(Double) * char_size;
-    const int exponent_size =
-      double_size - double_significand_size - 1;  // -1 for sign
-    const uint64_t significand_mask = implicit_bit - 1;
-    const uint64_t exponent_mask = (~0ull >> 1) & ~significand_mask;
-    const int exponent_bias = (1 << exponent_size) - limits::max_exponent - 1;
-    auto u = bit_cast<uint64_t>(d);
-    auto biased_e = (u & exponent_mask) >> double_significand_size;
-    f = u & significand_mask;
-    if (biased_e != 0)
-      f += implicit_bit;
-    else
-      biased_e = 1;  // Subnormals use biased exponent 1 (min exponent).
-    e = static_cast<int>(biased_e - exponent_bias - double_significand_size);
-  }
-
-  // Normalizes the value converted from double and multiplied by (1 << SHIFT).
-  template <int SHIFT = 0>
-  void normalize() {
-    // Handle subnormals.
-    auto shifted_implicit_bit = implicit_bit << SHIFT;
-    while ((f & shifted_implicit_bit) == 0) {
-      f <<= 1;
-      --e;
+    fp(uint64_t f, int e)
+        : f(f)
+        , e(e)
+    {
+    }
+
+    // Constructs fp from an IEEE754 double. It is a template to prevent compile
+    // errors on platforms where double is not IEEE754.
+    template<typename Double>
+    explicit fp(Double d)
+    {
+        // Assume double is in the format [sign][exponent][significand].
+        typedef std::numeric_limits<Double> limits;
+        const int double_size = sizeof(Double) * char_size;
+        const int exponent_size = double_size - double_significand_size - 1; // -1 for sign
+        const uint64_t significand_mask = implicit_bit - 1;
+        const uint64_t exponent_mask = (~0ull >> 1) & ~significand_mask;
+        const int exponent_bias = (1 << exponent_size) - limits::max_exponent - 1;
+        auto u = bit_cast<uint64_t>(d);
+        auto biased_e = (u & exponent_mask) >> double_significand_size;
+        f = u & significand_mask;
+        if (biased_e != 0)
+            f += implicit_bit;
+        else
+            biased_e = 1; // Subnormals use biased exponent 1 (min exponent).
+        e = static_cast<int>(biased_e - exponent_bias - double_significand_size);
+    }
+
+    // Normalizes the value converted from double and multiplied by (1 << SHIFT).
+    template<int SHIFT = 0>
+    void normalize()
+    {
+        // Handle subnormals.
+        auto shifted_implicit_bit = implicit_bit << SHIFT;
+        while ((f & shifted_implicit_bit) == 0)
+        {
+            f <<= 1;
+            --e;
+        }
+        // Subtract 1 to account for hidden bit.
+        auto offset = significand_size - double_significand_size - SHIFT - 1;
+        f <<= offset;
+        e -= offset;
     }
-    // Subtract 1 to account for hidden bit.
-    auto offset = significand_size - double_significand_size - SHIFT - 1;
-    f <<= offset;
-    e -= offset;
-  }
 };
 
 // Returns an fp number representing x - y. Result may not be normalized.
-inline fp operator-(fp x, fp y) {
-  FMT_ASSERT(x.f >= y.f && x.e == y.e, "invalid operands");
-  return fp(x.f - y.f, x.e);
+inline fp operator-(fp x, fp y)
+{
+    FMT_ASSERT(x.f >= y.f && x.e == y.e, "invalid operands");
+    return fp(x.f - y.f, x.e);
 }
 
 // Computes an fp number r with r.f = x.f * y.f / pow(2, 64) rounded to nearest
@@ -354,20 +395,24 @@ fp operator*(fp x, fp y);
 // (binary) exponent satisfies min_exponent <= c_k.e <= min_exponent + 3.
 fp get_cached_power(int min_exponent, int &pow10_exponent);
 
-template <typename Allocator>
-typename Allocator::value_type *allocate(Allocator& alloc, std::size_t n) {
+template<typename Allocator>
+typename Allocator::value_type *allocate(Allocator &alloc, std::size_t n)
+{
 #if __cplusplus >= 201103L || FMT_MSC_VER >= 1700
-  return std::allocator_traits<Allocator>::allocate(alloc, n);
+    return std::allocator_traits<Allocator>::allocate(alloc, n);
 #else
-  return alloc.allocate(n);
+    return alloc.allocate(n);
 #endif
 }
 
 // A helper function to suppress bogus "conditional expression is constant"
 // warnings.
-template <typename T>
-inline T const_check(T value) { return value; }
-}  // namespace internal
+template<typename T>
+inline T const_check(T value)
+{
+    return value;
+}
+} // namespace internal
 FMT_END_NAMESPACE
 
 namespace std {
@@ -375,133 +420,171 @@ namespace std {
 // 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::dummy_int> :
-    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(dummy_int)))
-      return isinf(x) != 0;
-    return !_finite(static_cast<double>(x));
-  }
+template<>
+class numeric_limits<fmt::internal::dummy_int> : 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(dummy_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(fmt::internal::dummy_int)))
-      return isnan(x) != 0;
-    return _isnan(static_cast<double>(x)) != 0;
-  }
+    // Portable version of isnan.
+    template<typename T>
+    static bool isnotanumber(T x)
+    {
+        using namespace fmt::internal;
+        if (const_check(sizeof(isnan(x)) != sizeof(fmt::internal::dummy_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(fmt::internal::dummy_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;
-  }
+    // Portable version of signbit.
+    static bool isnegative(double x)
+    {
+        using namespace fmt::internal;
+        if (const_check(sizeof(signbit(x)) != sizeof(fmt::internal::dummy_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 std
 
 FMT_BEGIN_NAMESPACE
-template <typename Range>
+template<typename Range>
 class basic_writer;
 
-template <typename OutputIt, typename T = typename OutputIt::value_type>
-class output_range {
- private:
-  OutputIt it_;
+template<typename OutputIt, typename T = typename OutputIt::value_type>
+class output_range
+{
+private:
+    OutputIt it_;
 
-  // Unused yet.
-  typedef void sentinel;
-  sentinel end() const;
+    // Unused yet.
+    typedef void sentinel;
+    sentinel end() const;
 
- public:
-  typedef OutputIt iterator;
-  typedef T value_type;
+public:
+    typedef OutputIt iterator;
+    typedef T value_type;
 
-  explicit output_range(OutputIt it): it_(it) {}
-  OutputIt begin() const { return it_; }
+    explicit output_range(OutputIt it)
+        : it_(it)
+    {
+    }
+    OutputIt begin() const
+    {
+        return it_;
+    }
 };
 
 // A range where begin() returns back_insert_iterator.
-template <typename Container>
-class back_insert_range:
-    public output_range<std::back_insert_iterator<Container>> {
-  typedef output_range<std::back_insert_iterator<Container>> base;
- public:
-  typedef typename Container::value_type value_type;
+template<typename Container>
+class back_insert_range : public output_range<std::back_insert_iterator<Container>>
+{
+    typedef output_range<std::back_insert_iterator<Container>> base;
 
-  back_insert_range(Container &c): base(std::back_inserter(c)) {}
-  back_insert_range(typename base::iterator it): base(it) {}
+public:
+    typedef typename Container::value_type value_type;
+
+    back_insert_range(Container &c)
+        : base(std::back_inserter(c))
+    {
+    }
+    back_insert_range(typename base::iterator it)
+        : base(it)
+    {
+    }
 };
 
 typedef basic_writer<back_insert_range<internal::buffer>> writer;
 typedef basic_writer<back_insert_range<internal::wbuffer>> wwriter;
 
 /** A formatting error such as invalid format string. */
-class format_error : public std::runtime_error {
- public:
-  explicit format_error(const char *message)
-  : std::runtime_error(message) {}
+class format_error : public std::runtime_error
+{
+public:
+    explicit format_error(const char *message)
+        : std::runtime_error(message)
+    {
+    }
 
-  explicit format_error(const std::string &message)
-  : std::runtime_error(message) {}
+    explicit format_error(const std::string &message)
+        : std::runtime_error(message)
+    {
+    }
 };
 
 namespace internal {
 
 #if FMT_SECURE_SCL
-template <typename T>
-struct checked { typedef stdext::checked_array_iterator<T*> type; };
+template<typename T>
+struct checked
+{
+    typedef stdext::checked_array_iterator<T *> type;
+};
 
 // Make a checked iterator to avoid warnings on MSVC.
-template <typename T>
-inline stdext::checked_array_iterator<T*> make_checked(T *p, std::size_t size) {
-  return {p, size};
+template<typename T>
+inline stdext::checked_array_iterator<T *> make_checked(T *p, std::size_t size)
+{
+    return {p, size};
 }
 #else
-template <typename T>
-struct checked { typedef T *type; };
-template <typename T>
-inline T *make_checked(T *p, std::size_t) { return p; }
+template<typename T>
+struct checked
+{
+    typedef T *type;
+};
+template<typename T>
+inline T *make_checked(T *p, std::size_t)
+{
+    return p;
+}
 #endif
 
-template <typename T>
-template <typename U>
-void basic_buffer<T>::append(const U *begin, const U *end) {
-  std::size_t new_size = size_ + internal::to_unsigned(end - begin);
-  reserve(new_size);
-  std::uninitialized_copy(begin, end,
-                          internal::make_checked(ptr_, capacity_) + size_);
-  size_ = new_size;
+template<typename T>
+template<typename U>
+void basic_buffer<T>::append(const U *begin, const U *end)
+{
+    std::size_t new_size = size_ + internal::to_unsigned(end - begin);
+    reserve(new_size);
+    std::uninitialized_copy(begin, end, internal::make_checked(ptr_, capacity_) + size_);
+    size_ = new_size;
 }
-}  // namespace internal
+} // namespace internal
 
 // A wrapper around std::locale used to reduce compile times since <locale>
 // is very heavy.
 class locale;
 
-class locale_provider {
- public:
-  virtual ~locale_provider() {}
-  virtual fmt::locale locale();
+class locale_provider
+{
+public:
+    virtual ~locale_provider() {}
+    virtual fmt::locale locale();
 };
 
 // The number of characters to store in the basic_memory_buffer object itself
 // to avoid dynamic memory allocation.
-enum { inline_buffer_size = 500 };
+enum
+{
+    inline_buffer_size = 500
+};
 
 /**
   \rst
@@ -532,92 +615,106 @@ enum { inline_buffer_size = 500 };
   The output can be converted to an ``std::string`` with ``to_string(out)``.
   \endrst
  */
-template <typename T, std::size_t SIZE = inline_buffer_size,
-          typename Allocator = std::allocator<T> >
-class basic_memory_buffer: private Allocator, public internal::basic_buffer<T> {
- private:
-  T store_[SIZE];
+template<typename T, std::size_t SIZE = inline_buffer_size, typename Allocator = std::allocator<T>>
+class basic_memory_buffer : private Allocator, public internal::basic_buffer<T>
+{
+private:
+    T store_[SIZE];
 
-  // Deallocate memory allocated by the buffer.
-  void deallocate() {
-    T* data = this->data();
-    if (data != store_) Allocator::deallocate(data, this->capacity());
-  }
-
- protected:
-  void grow(std::size_t size) FMT_OVERRIDE;
-
- public:
-  explicit basic_memory_buffer(const Allocator &alloc = Allocator())
-      : Allocator(alloc) {
-    this->set(store_, SIZE);
-  }
-  ~basic_memory_buffer() { deallocate(); }
-
- private:
-  // Move data from other to this buffer.
-  void move(basic_memory_buffer &other) {
-    Allocator &this_alloc = *this, &other_alloc = other;
-    this_alloc = std::move(other_alloc);
-    T* data = other.data();
-    std::size_t size = other.size(), capacity = other.capacity();
-    if (data == other.store_) {
-      this->set(store_, capacity);
-      std::uninitialized_copy(other.store_, other.store_ + size,
-                              internal::make_checked(store_, capacity));
-    } else {
-      this->set(data, capacity);
-      // Set pointer to the inline array so that delete is not called
-      // when deallocating.
-      other.set(other.store_, 0);
+    // Deallocate memory allocated by the buffer.
+    void deallocate()
+    {
+        T *data = this->data();
+        if (data != store_)
+            Allocator::deallocate(data, this->capacity());
     }
-    this->resize(size);
-  }
 
- public:
-  /**
-    \rst
-    Constructs a :class:`fmt::basic_memory_buffer` object moving the content
-    of the other object to it.
-    \endrst
-   */
-  basic_memory_buffer(basic_memory_buffer &&other) {
-    move(other);
-  }
+protected:
+    void grow(std::size_t size) FMT_OVERRIDE;
 
-  /**
-    \rst
-    Moves the content of the other ``basic_memory_buffer`` object to this one.
-    \endrst
-   */
-  basic_memory_buffer &operator=(basic_memory_buffer &&other) {
-    assert(this != &other);
-    deallocate();
-    move(other);
-    return *this;
-  }
+public:
+    explicit basic_memory_buffer(const Allocator &alloc = Allocator())
+        : Allocator(alloc)
+    {
+        this->set(store_, SIZE);
+    }
+    ~basic_memory_buffer()
+    {
+        deallocate();
+    }
 
-  // Returns a copy of the allocator associated with this buffer.
-  Allocator get_allocator() const { return *this; }
+private:
+    // Move data from other to this buffer.
+    void move(basic_memory_buffer &other)
+    {
+        Allocator &this_alloc = *this, &other_alloc = other;
+        this_alloc = std::move(other_alloc);
+        T *data = other.data();
+        std::size_t size = other.size(), capacity = other.capacity();
+        if (data == other.store_)
+        {
+            this->set(store_, capacity);
+            std::uninitialized_copy(other.store_, other.store_ + size, internal::make_checked(store_, capacity));
+        }
+        else
+        {
+            this->set(data, capacity);
+            // Set pointer to the inline array so that delete is not called
+            // when deallocating.
+            other.set(other.store_, 0);
+        }
+        this->resize(size);
+    }
+
+public:
+    /**
+      \rst
+      Constructs a :class:`fmt::basic_memory_buffer` object moving the content
+      of the other object to it.
+      \endrst
+     */
+    basic_memory_buffer(basic_memory_buffer &&other)
+    {
+        move(other);
+    }
+
+    /**
+      \rst
+      Moves the content of the other ``basic_memory_buffer`` object to this one.
+      \endrst
+     */
+    basic_memory_buffer &operator=(basic_memory_buffer &&other)
+    {
+        assert(this != &other);
+        deallocate();
+        move(other);
+        return *this;
+    }
+
+    // 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 basic_memory_buffer<T, SIZE, Allocator>::grow(std::size_t size) {
-  std::size_t old_capacity = this->capacity();
-  std::size_t new_capacity = old_capacity + old_capacity / 2;
-  if (size > new_capacity)
-      new_capacity = size;
-  T *old_data = this->data();
-  T *new_data = internal::allocate<Allocator>(*this, new_capacity);
-  // The following code doesn't throw, so the raw pointer above doesn't leak.
-  std::uninitialized_copy(old_data, old_data + this->size(),
-                          internal::make_checked(new_data, new_capacity));
-  this->set(new_data, new_capacity);
-  // deallocate must not throw according to the standard, but even if it does,
-  // the buffer already uses the new storage and will deallocate it in
-  // destructor.
-  if (old_data != store_)
-    Allocator::deallocate(old_data, old_capacity);
+template<typename T, std::size_t SIZE, typename Allocator>
+void basic_memory_buffer<T, SIZE, Allocator>::grow(std::size_t size)
+{
+    std::size_t old_capacity = this->capacity();
+    std::size_t new_capacity = old_capacity + old_capacity / 2;
+    if (size > new_capacity)
+        new_capacity = size;
+    T *old_data = this->data();
+    T *new_data = internal::allocate<Allocator>(*this, new_capacity);
+    // The following code doesn't throw, so the raw pointer above doesn't leak.
+    std::uninitialized_copy(old_data, old_data + this->size(), internal::make_checked(new_data, new_capacity));
+    this->set(new_data, new_capacity);
+    // deallocate must not throw according to the standard, but even if it does,
+    // the buffer already uses the new storage and will deallocate it in
+    // destructor.
+    if (old_data != store_)
+        Allocator::deallocate(old_data, old_capacity);
 }
 
 typedef basic_memory_buffer<char> memory_buffer;
@@ -632,289 +729,343 @@ typedef basic_memory_buffer<wchar_t> wmemory_buffer;
   ``std::runtime_error``.
   \endrst
  */
-template <typename Char>
-class basic_fixed_buffer : public internal::basic_buffer<Char> {
- public:
-  /**
-   \rst
-   Constructs a :class:`fmt::basic_fixed_buffer` object for *array* of the
-   given size.
-   \endrst
-   */
-  basic_fixed_buffer(Char *array, std::size_t size) {
-    this->set(array, size);
-  }
+template<typename Char>
+class basic_fixed_buffer : public internal::basic_buffer<Char>
+{
+public:
+    /**
+     \rst
+     Constructs a :class:`fmt::basic_fixed_buffer` object for *array* of the
+     given size.
+     \endrst
+     */
+    basic_fixed_buffer(Char *array, std::size_t size)
+    {
+        this->set(array, size);
+    }
 
-  /**
-   \rst
-   Constructs a :class:`fmt::basic_fixed_buffer` object for *array* of the
-   size known at compile time.
-   \endrst
-   */
-  template <std::size_t SIZE>
-  explicit basic_fixed_buffer(Char (&array)[SIZE]) {
-    this->set(array, SIZE);
-  }
+    /**
+     \rst
+     Constructs a :class:`fmt::basic_fixed_buffer` object for *array* of the
+     size known at compile time.
+     \endrst
+     */
+    template<std::size_t SIZE>
+    explicit basic_fixed_buffer(Char (&array)[SIZE])
+    {
+        this->set(array, SIZE);
+    }
 
- protected:
-  FMT_API void grow(std::size_t size) FMT_OVERRIDE;
+protected:
+    FMT_API void grow(std::size_t size) FMT_OVERRIDE;
 };
 
 namespace internal {
 
-template <typename Char>
+template<typename Char>
 struct char_traits;
 
-template <>
-struct char_traits<char> {
-  // Formats a floating-point number.
-  template <typename T>
-  FMT_API static int format_float(char *buffer, std::size_t size,
-      const char *format, int precision, T value);
+template<>
+struct char_traits<char>
+{
+    // Formats a floating-point number.
+    template<typename T>
+    FMT_API static int format_float(char *buffer, std::size_t size, const char *format, int precision, T value);
 };
 
-template <>
-struct char_traits<wchar_t> {
-  template <typename T>
-  FMT_API static int format_float(wchar_t *buffer, std::size_t size,
-      const wchar_t *format, int precision, T value);
+template<>
+struct char_traits<wchar_t>
+{
+    template<typename T>
+    FMT_API static int format_float(wchar_t *buffer, std::size_t size, const wchar_t *format, int precision, T value);
 };
 
 #if FMT_USE_EXTERN_TEMPLATES
 extern template int char_traits<char>::format_float<double>(
-    char *buffer, std::size_t size, const char* format, int precision,
-    double value);
+    char *buffer, std::size_t size, const char *format, int precision, double value);
 extern template int char_traits<char>::format_float<long double>(
-    char *buffer, std::size_t size, const char* format, int precision,
-    long double value);
+    char *buffer, std::size_t size, const char *format, int precision, long double value);
 
 extern template int char_traits<wchar_t>::format_float<double>(
-    wchar_t *buffer, std::size_t size, const wchar_t* format, int precision,
-    double value);
+    wchar_t *buffer, std::size_t size, const wchar_t *format, int precision, double value);
 extern template int char_traits<wchar_t>::format_float<long double>(
-    wchar_t *buffer, std::size_t size, const wchar_t* format, int precision,
-    long double value);
+    wchar_t *buffer, std::size_t size, const wchar_t *format, int precision, long double value);
 #endif
 
-template <typename Container>
-inline typename std::enable_if<
-  is_contiguous<Container>::value,
-  typename checked<typename Container::value_type>::type>::type
-    reserve(std::back_insert_iterator<Container> &it, std::size_t n) {
-  Container &c = internal::get_container(it);
-  std::size_t size = c.size();
-  c.resize(size + n);
-  return make_checked(&c[size], n);
+template<typename Container>
+inline typename std::enable_if<is_contiguous<Container>::value, typename checked<typename Container::value_type>::type>::type reserve(
+    std::back_insert_iterator<Container> &it, std::size_t n)
+{
+    Container &c = internal::get_container(it);
+    std::size_t size = c.size();
+    c.resize(size + n);
+    return make_checked(&c[size], n);
 }
 
-template <typename Iterator>
-inline Iterator &reserve(Iterator &it, std::size_t) { return it; }
+template<typename Iterator>
+inline Iterator &reserve(Iterator &it, std::size_t)
+{
+    return it;
+}
 
-template <typename Char>
+template<typename Char>
 class null_terminating_iterator;
 
-template <typename Char>
+template<typename Char>
 FMT_CONSTEXPR_DECL const Char *pointer_from(null_terminating_iterator<Char> it);
 
 // An iterator that produces a null terminator on *end. This simplifies parsing
 // and allows comparing the performance of processing a null-terminated string
 // vs string_view.
-template <typename Char>
-class null_terminating_iterator {
- public:
-  typedef std::ptrdiff_t difference_type;
-  typedef Char value_type;
-  typedef const Char* pointer;
-  typedef const Char& reference;
-  typedef std::random_access_iterator_tag iterator_category;
+template<typename Char>
+class null_terminating_iterator
+{
+public:
+    typedef std::ptrdiff_t difference_type;
+    typedef Char value_type;
+    typedef const Char *pointer;
+    typedef const Char &reference;
+    typedef std::random_access_iterator_tag iterator_category;
 
-  null_terminating_iterator() : ptr_(0), end_(0) {}
+    null_terminating_iterator()
+        : ptr_(0)
+        , end_(0)
+    {
+    }
 
-  FMT_CONSTEXPR null_terminating_iterator(const Char *ptr, const Char *end)
-    : ptr_(ptr), end_(end) {}
+    FMT_CONSTEXPR null_terminating_iterator(const Char *ptr, const Char *end)
+        : ptr_(ptr)
+        , end_(end)
+    {
+    }
 
-  template <typename Range>
-  FMT_CONSTEXPR explicit null_terminating_iterator(const Range &r)
-    : ptr_(r.begin()), end_(r.end()) {}
+    template<typename Range>
+    FMT_CONSTEXPR explicit null_terminating_iterator(const Range &r)
+        : ptr_(r.begin())
+        , end_(r.end())
+    {
+    }
 
-  null_terminating_iterator &operator=(const Char *ptr) {
-    assert(ptr <= end_);
-    ptr_ = ptr;
-    return *this;
-  }
+    null_terminating_iterator &operator=(const Char *ptr)
+    {
+        assert(ptr <= end_);
+        ptr_ = ptr;
+        return *this;
+    }
 
-  FMT_CONSTEXPR Char operator*() const {
-    return ptr_ != end_ ? *ptr_ : 0;
-  }
+    FMT_CONSTEXPR Char operator*() const
+    {
+        return ptr_ != end_ ? *ptr_ : 0;
+    }
 
-  FMT_CONSTEXPR null_terminating_iterator operator++() {
-    ++ptr_;
-    return *this;
-  }
+    FMT_CONSTEXPR null_terminating_iterator operator++()
+    {
+        ++ptr_;
+        return *this;
+    }
 
-  FMT_CONSTEXPR null_terminating_iterator operator++(int) {
-    null_terminating_iterator result(*this);
-    ++ptr_;
-    return result;
-  }
+    FMT_CONSTEXPR null_terminating_iterator operator++(int)
+    {
+        null_terminating_iterator result(*this);
+        ++ptr_;
+        return result;
+    }
 
-  FMT_CONSTEXPR null_terminating_iterator operator--() {
-    --ptr_;
-    return *this;
-  }
+    FMT_CONSTEXPR null_terminating_iterator operator--()
+    {
+        --ptr_;
+        return *this;
+    }
 
-  FMT_CONSTEXPR null_terminating_iterator operator+(difference_type n) {
-    return null_terminating_iterator(ptr_ + n, end_);
-  }
+    FMT_CONSTEXPR null_terminating_iterator operator+(difference_type n)
+    {
+        return null_terminating_iterator(ptr_ + n, end_);
+    }
 
-  FMT_CONSTEXPR null_terminating_iterator operator-(difference_type n) {
-    return null_terminating_iterator(ptr_ - n, end_);
-  }
+    FMT_CONSTEXPR null_terminating_iterator operator-(difference_type n)
+    {
+        return null_terminating_iterator(ptr_ - n, end_);
+    }
 
-  FMT_CONSTEXPR null_terminating_iterator operator+=(difference_type n) {
-    ptr_ += n;
-    return *this;
-  }
+    FMT_CONSTEXPR null_terminating_iterator operator+=(difference_type n)
+    {
+        ptr_ += n;
+        return *this;
+    }
 
-  FMT_CONSTEXPR difference_type operator-(
-      null_terminating_iterator other) const {
-    return ptr_ - other.ptr_;
-  }
+    FMT_CONSTEXPR difference_type operator-(null_terminating_iterator other) const
+    {
+        return ptr_ - other.ptr_;
+    }
 
-  FMT_CONSTEXPR bool operator!=(null_terminating_iterator other) const {
-    return ptr_ != other.ptr_;
-  }
+    FMT_CONSTEXPR bool operator!=(null_terminating_iterator other) const
+    {
+        return ptr_ != other.ptr_;
+    }
 
-  bool operator>=(null_terminating_iterator other) const {
-    return ptr_ >= other.ptr_;
-  }
+    bool operator>=(null_terminating_iterator other) const
+    {
+        return ptr_ >= other.ptr_;
+    }
 
-  // This should be a friend specialization pointer_from<Char> but the latter
-  // doesn't compile by gcc 5.1 due to a compiler bug.
-  template <typename CharT>
-  friend FMT_CONSTEXPR_DECL const CharT *pointer_from(
-      null_terminating_iterator<CharT> it);
+    // This should be a friend specialization pointer_from<Char> but the latter
+    // doesn't compile by gcc 5.1 due to a compiler bug.
+    template<typename CharT>
+    friend FMT_CONSTEXPR_DECL const CharT *pointer_from(null_terminating_iterator<CharT> it);
 
- private:
-  const Char *ptr_;
-  const Char *end_;
+private:
+    const Char *ptr_;
+    const Char *end_;
 };
 
-template <typename T>
-FMT_CONSTEXPR const T *pointer_from(const T *p) { return p; }
+template<typename T>
+FMT_CONSTEXPR const T *pointer_from(const T *p)
+{
+    return p;
+}
 
-template <typename Char>
-FMT_CONSTEXPR const Char *pointer_from(null_terminating_iterator<Char> it) {
-  return it.ptr_;
+template<typename Char>
+FMT_CONSTEXPR const Char *pointer_from(null_terminating_iterator<Char> it)
+{
+    return it.ptr_;
 }
 
 // An output iterator that counts the number of objects written to it and
 // discards them.
-template <typename T>
-class counting_iterator {
- private:
-  std::size_t count_;
-  mutable T blackhole_;
+template<typename T>
+class counting_iterator
+{
+private:
+    std::size_t count_;
+    mutable T blackhole_;
 
- public:
-  typedef std::output_iterator_tag iterator_category;
-  typedef T value_type;
-  typedef std::ptrdiff_t difference_type;
-  typedef T* pointer;
-  typedef T& reference;
-  typedef counting_iterator _Unchecked_type;  // Mark iterator as checked.
+public:
+    typedef std::output_iterator_tag iterator_category;
+    typedef T value_type;
+    typedef std::ptrdiff_t difference_type;
+    typedef T *pointer;
+    typedef T &reference;
+    typedef counting_iterator _Unchecked_type; // Mark iterator as checked.
 
-  counting_iterator(): count_(0) {}
+    counting_iterator()
+        : count_(0)
+    {
+    }
 
-  std::size_t count() const { return count_; }
+    std::size_t count() const
+    {
+        return count_;
+    }
 
-  counting_iterator& operator++() {
-    ++count_;
-    return *this;
-  }
+    counting_iterator &operator++()
+    {
+        ++count_;
+        return *this;
+    }
 
-  counting_iterator operator++(int) {
-    auto it = *this;
-    ++*this;
-    return it;
-  }
+    counting_iterator operator++(int)
+    {
+        auto it = *this;
+        ++*this;
+        return it;
+    }
 
-  T &operator*() const { return blackhole_; }
+    T &operator*() const
+    {
+        return blackhole_;
+    }
 };
 
 // An output iterator that truncates the output and counts the number of objects
 // written to it.
-template <typename OutputIt>
-class truncating_iterator {
- private:
-  typedef std::iterator_traits<OutputIt> traits;
+template<typename OutputIt>
+class truncating_iterator
+{
+private:
+    typedef std::iterator_traits<OutputIt> traits;
 
-  OutputIt out_;
-  std::size_t limit_;
-  std::size_t count_;
-  mutable typename traits::value_type blackhole_;
+    OutputIt out_;
+    std::size_t limit_;
+    std::size_t count_;
+    mutable typename traits::value_type blackhole_;
 
- public:
-  typedef std::output_iterator_tag iterator_category;
-  typedef typename traits::value_type value_type;
-  typedef typename traits::difference_type difference_type;
-  typedef typename traits::pointer pointer;
-  typedef typename traits::reference reference;
-  typedef truncating_iterator _Unchecked_type;  // Mark iterator as checked.
+public:
+    typedef std::output_iterator_tag iterator_category;
+    typedef typename traits::value_type value_type;
+    typedef typename traits::difference_type difference_type;
+    typedef typename traits::pointer pointer;
+    typedef typename traits::reference reference;
+    typedef truncating_iterator _Unchecked_type; // Mark iterator as checked.
 
-  truncating_iterator(OutputIt out, std::size_t limit)
-    : out_(out), limit_(limit), count_(0) {}
+    truncating_iterator(OutputIt out, std::size_t limit)
+        : out_(out)
+        , limit_(limit)
+        , count_(0)
+    {
+    }
 
-  OutputIt base() const { return out_; }
-  std::size_t count() const { return count_; }
+    OutputIt base() const
+    {
+        return out_;
+    }
+    std::size_t count() const
+    {
+        return count_;
+    }
 
-  truncating_iterator& operator++() {
-    if (count_++ < limit_)
-      ++out_;
-    return *this;
-  }
+    truncating_iterator &operator++()
+    {
+        if (count_++ < limit_)
+            ++out_;
+        return *this;
+    }
 
-  truncating_iterator operator++(int) {
-    auto it = *this;
-    ++*this;
-    return it;
-  }
+    truncating_iterator operator++(int)
+    {
+        auto it = *this;
+        ++*this;
+        return it;
+    }
 
-  reference operator*() const { return count_ < limit_ ? *out_ : blackhole_; }
+    reference operator*() const
+    {
+        return count_ < limit_ ? *out_ : blackhole_;
+    }
 };
 
 // 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>
-FMT_CONSTEXPR typename std::enable_if<
-    std::numeric_limits<T>::is_signed, bool>::type is_negative(T value) {
-  return value < 0;
+template<typename T>
+FMT_CONSTEXPR typename std::enable_if<std::numeric_limits<T>::is_signed, bool>::type is_negative(T value)
+{
+    return value < 0;
 }
-template <typename T>
-FMT_CONSTEXPR typename std::enable_if<
-    !std::numeric_limits<T>::is_signed, bool>::type is_negative(T) {
-  return false;
+template<typename T>
+FMT_CONSTEXPR typename std::enable_if<!std::numeric_limits<T>::is_signed, bool>::type is_negative(T)
+{
+    return false;
 }
 
-template <typename T>
-struct int_traits {
-  // Smallest of uint32_t and uint64_t that is large enough to represent
-  // all values of T.
-  typedef typename std::conditional<
-    std::numeric_limits<T>::digits <= 32, uint32_t, uint64_t>::type main_type;
+template<typename T>
+struct int_traits
+{
+    // Smallest of uint32_t and uint64_t that is large enough to represent
+    // all values of T.
+    typedef typename std::conditional<std::numeric_limits<T>::digits <= 32, uint32_t, uint64_t>::type main_type;
 };
 
 // Static data is placed in this class template to allow header-only
 // configuration.
-template <typename T = void>
-struct FMT_API basic_data {
-  static const uint32_t POWERS_OF_10_32[];
-  static const uint64_t POWERS_OF_10_64[];
-  static const uint64_t POW10_SIGNIFICANDS[];
-  static const int16_t POW10_EXPONENTS[];
-  static const char DIGITS[];
-  static const char RESET_COLOR[];
-  static const wchar_t WRESET_COLOR[];
+template<typename T = void>
+struct FMT_API basic_data
+{
+    static const uint32_t POWERS_OF_10_32[];
+    static const uint64_t POWERS_OF_10_64[];
+    static const uint64_t POW10_SIGNIFICANDS[];
+    static const int16_t POW10_EXPONENTS[];
+    static const char DIGITS[];
+    static const char RESET_COLOR[];
+    static const wchar_t WRESET_COLOR[];
 };
 
 #if FMT_USE_EXTERN_TEMPLATES
@@ -926,220 +1077,254 @@ typedef basic_data<> 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;
+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;
-  }
+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
 
 #if FMT_HAS_CPP_ATTRIBUTE(always_inline)
-# define FMT_ALWAYS_INLINE __attribute__((always_inline))
+#define FMT_ALWAYS_INLINE __attribute__((always_inline))
 #else
-# define FMT_ALWAYS_INLINE
+#define FMT_ALWAYS_INLINE
 #endif
 
-template <typename Handler>
+template<typename Handler>
 inline char *lg(uint32_t n, Handler h) FMT_ALWAYS_INLINE;
 
 // Computes g = floor(log10(n)) and calls h.on<g>(n);
-template <typename Handler>
-inline char *lg(uint32_t n, Handler h) {
-  return n < 100 ? n < 10 ? h.template on<0>(n) : h.template on<1>(n)
-                 : n < 1000000
-                       ? n < 10000 ? n < 1000 ? h.template on<2>(n)
-                                              : h.template on<3>(n)
-                                   : n < 100000 ? h.template on<4>(n)
-                                                : h.template on<5>(n)
-                       : n < 100000000 ? n < 10000000 ? h.template on<6>(n)
-                                                      : h.template on<7>(n)
-                                       : n < 1000000000 ? h.template on<8>(n)
-                                                        : h.template on<9>(n);
+template<typename Handler>
+inline char *lg(uint32_t n, Handler h)
+{
+    return n < 100 ? n < 10 ? h.template on<0>(n) : h.template on<1>(n)
+                   : n < 1000000 ? n < 10000 ? n < 1000 ? h.template on<2>(n) : h.template on<3>(n)
+                                             : n < 100000 ? h.template on<4>(n) : h.template on<5>(n)
+                                 : n < 100000000 ? n < 10000000 ? h.template on<6>(n) : h.template on<7>(n)
+                                                 : n < 1000000000 ? h.template on<8>(n) : h.template on<9>(n);
 }
 
 // An lg handler that formats a decimal number.
 // Usage: lg(n, decimal_formatter(buffer));
-class decimal_formatter {
- private:
-  char *buffer_;
+class decimal_formatter
+{
+private:
+    char *buffer_;
 
-  void write_pair(unsigned N, uint32_t index) {
-    std::memcpy(buffer_ + N, data::DIGITS + index * 2, 2);
-  }
-
- public:
-  explicit decimal_formatter(char *buf) : buffer_(buf) {}
-
-  template <unsigned N> char *on(uint32_t u) {
-    if (N == 0) {
-      *buffer_ = static_cast<char>(u) + '0';
-    } else if (N == 1) {
-      write_pair(0, u);
-    } else {
-      // The idea of using 4.32 fixed-point numbers is based on
-      // https://github.com/jeaiii/itoa
-      unsigned n = N - 1;
-      unsigned a = n / 5 * n * 53 / 16;
-      uint64_t t = ((1ULL << (32 + a)) / data::POWERS_OF_10_32[n] + 1 - n / 9);
-      t = ((t * u) >> a) + n / 5 * 4;
-      write_pair(0, t >> 32);
-      for (unsigned i = 2; i < N; i += 2) {
-        t = 100ULL * static_cast<uint32_t>(t);
-        write_pair(i, t >> 32);
-      }
-      if (N % 2 == 0) {
-        buffer_[N] = static_cast<char>(
-          (10ULL * static_cast<uint32_t>(t)) >> 32) + '0';
-      }
+    void write_pair(unsigned N, uint32_t index)
+    {
+        std::memcpy(buffer_ + N, data::DIGITS + index * 2, 2);
+    }
+
+public:
+    explicit decimal_formatter(char *buf)
+        : buffer_(buf)
+    {
+    }
+
+    template<unsigned N>
+    char *on(uint32_t u)
+    {
+        if (N == 0)
+        {
+            *buffer_ = static_cast<char>(u) + '0';
+        }
+        else if (N == 1)
+        {
+            write_pair(0, u);
+        }
+        else
+        {
+            // The idea of using 4.32 fixed-point numbers is based on
+            // https://github.com/jeaiii/itoa
+            unsigned n = N - 1;
+            unsigned a = n / 5 * n * 53 / 16;
+            uint64_t t = ((1ULL << (32 + a)) / data::POWERS_OF_10_32[n] + 1 - n / 9);
+            t = ((t * u) >> a) + n / 5 * 4;
+            write_pair(0, t >> 32);
+            for (unsigned i = 2; i < N; i += 2)
+            {
+                t = 100ULL * static_cast<uint32_t>(t);
+                write_pair(i, t >> 32);
+            }
+            if (N % 2 == 0)
+            {
+                buffer_[N] = static_cast<char>((10ULL * static_cast<uint32_t>(t)) >> 32) + '0';
+            }
+        }
+        return buffer_ += N + 1;
     }
-    return buffer_ += N + 1;
-  }
 };
 
 // An lg handler that formats a decimal number with a terminating null.
-class decimal_formatter_null : public decimal_formatter {
- public:
-  explicit decimal_formatter_null(char *buf) : decimal_formatter(buf) {}
+class decimal_formatter_null : public decimal_formatter
+{
+public:
+    explicit decimal_formatter_null(char *buf)
+        : decimal_formatter(buf)
+    {
+    }
 
-  template <unsigned N> char *on(uint32_t u) {
-    char *buf = decimal_formatter::on<N>(u);
-    *buf = '\0';
-    return buf;
-  }
+    template<unsigned N>
+    char *on(uint32_t u)
+    {
+        char *buf = decimal_formatter::on<N>(u);
+        *buf = '\0';
+        return buf;
+    }
 };
 
 #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;
+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 no_thousands_sep {
-  typedef char char_type;
+struct no_thousands_sep
+{
+    typedef char char_type;
 
-  template <typename Char>
-  void operator()(Char *) {}
+    template<typename Char>
+    void operator()(Char *)
+    {
+    }
 };
 
 // A functor that adds a thousands separator.
-template <typename Char>
-class add_thousands_sep {
- private:
-  basic_string_view<Char> sep_;
+template<typename Char>
+class add_thousands_sep
+{
+private:
+    basic_string_view<Char> sep_;
 
-  // Index of a decimal digit with the least significant digit having index 0.
-  unsigned digit_index_;
+    // Index of a decimal digit with the least significant digit having index 0.
+    unsigned digit_index_;
 
- public:
-  typedef Char char_type;
+public:
+    typedef Char char_type;
 
-  explicit add_thousands_sep(basic_string_view<Char> sep)
-    : sep_(sep), digit_index_(0) {}
+    explicit add_thousands_sep(basic_string_view<Char> sep)
+        : sep_(sep)
+        , digit_index_(0)
+    {
+    }
 
-  void operator()(Char *&buffer) {
-    if (++digit_index_ % 3 != 0)
-      return;
-    buffer -= sep_.size();
-    std::uninitialized_copy(sep_.data(), sep_.data() + sep_.size(),
-                            internal::make_checked(buffer, sep_.size()));
-  }
+    void operator()(Char *&buffer)
+    {
+        if (++digit_index_ % 3 != 0)
+            return;
+        buffer -= sep_.size();
+        std::uninitialized_copy(sep_.data(), sep_.data() + sep_.size(), internal::make_checked(buffer, sep_.size()));
+    }
 };
 
-template <typename Char>
+template<typename Char>
 FMT_API Char thousands_sep(locale_provider *lp);
 
 // 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 Char *format_decimal(Char *buffer, UInt value, unsigned num_digits,
-                            ThousandsSep thousands_sep) {
-  buffer += num_digits;
-  Char *end = buffer;
-  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;
+template<typename UInt, typename Char, typename ThousandsSep>
+inline Char *format_decimal(Char *buffer, UInt value, unsigned num_digits, ThousandsSep thousands_sep)
+{
+    buffer += num_digits;
+    Char *end = buffer;
+    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 end;
+    }
+    unsigned index = static_cast<unsigned>(value * 2);
     *--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 end;
-  }
-  unsigned index = static_cast<unsigned>(value * 2);
-  *--buffer = data::DIGITS[index + 1];
-  thousands_sep(buffer);
-  *--buffer = data::DIGITS[index];
-  return end;
 }
 
-template <typename UInt, typename Iterator, typename ThousandsSep>
-inline Iterator format_decimal(
-    Iterator out, UInt value, unsigned num_digits, ThousandsSep sep) {
-  typedef typename ThousandsSep::char_type char_type;
-  // Buffer should be large enough to hold all digits (digits10 + 1) and null.
-  char_type buffer[std::numeric_limits<UInt>::digits10 + 2];
-  format_decimal(buffer, value, num_digits, sep);
-  return std::copy_n(buffer, num_digits, out);
+template<typename UInt, typename Iterator, typename ThousandsSep>
+inline Iterator format_decimal(Iterator out, UInt value, unsigned num_digits, ThousandsSep sep)
+{
+    typedef typename ThousandsSep::char_type char_type;
+    // Buffer should be large enough to hold all digits (digits10 + 1) and null.
+    char_type buffer[std::numeric_limits<UInt>::digits10 + 2];
+    format_decimal(buffer, value, num_digits, sep);
+    return std::copy_n(buffer, num_digits, out);
 }
 
-template <typename It, typename UInt>
-inline It format_decimal(It out, UInt value, unsigned num_digits) {
-  return format_decimal(out, value, num_digits, no_thousands_sep());
+template<typename It, typename UInt>
+inline It format_decimal(It out, UInt value, unsigned num_digits)
+{
+    return format_decimal(out, value, num_digits, no_thousands_sep());
 }
 
-template <unsigned BASE_BITS, typename Char, typename UInt>
-inline Char *format_uint(Char *buffer, UInt value, unsigned num_digits,
-                         bool upper = false) {
-  buffer += num_digits;
-  Char *end = buffer;
-  do {
-    const char *digits = upper ? "0123456789ABCDEF" : "0123456789abcdef";
-    unsigned digit = (value & ((1 << BASE_BITS) - 1));
-    *--buffer = BASE_BITS < 4 ? static_cast<char>('0' + digit) : digits[digit];
-  } while ((value >>= BASE_BITS) != 0);
-  return end;
+template<unsigned BASE_BITS, typename Char, typename UInt>
+inline Char *format_uint(Char *buffer, UInt value, unsigned num_digits, bool upper = false)
+{
+    buffer += num_digits;
+    Char *end = buffer;
+    do
+    {
+        const char *digits = upper ? "0123456789ABCDEF" : "0123456789abcdef";
+        unsigned digit = (value & ((1 << BASE_BITS) - 1));
+        *--buffer = BASE_BITS < 4 ? static_cast<char>('0' + digit) : digits[digit];
+    } while ((value >>= BASE_BITS) != 0);
+    return end;
 }
 
-template <unsigned BASE_BITS, typename It, typename UInt>
-inline It format_uint(It out, UInt value, unsigned num_digits,
-                      bool upper = false) {
-  // Buffer should be large enough to hold all digits (digits / BASE_BITS + 1)
-  // and null.
-  char buffer[std::numeric_limits<UInt>::digits / BASE_BITS + 2];
-  format_uint<BASE_BITS>(buffer, value, num_digits, upper);
-  return std::copy_n(buffer, num_digits, out);
+template<unsigned BASE_BITS, typename It, typename UInt>
+inline It format_uint(It out, UInt value, unsigned num_digits, bool upper = false)
+{
+    // Buffer should be large enough to hold all digits (digits / BASE_BITS + 1)
+    // and null.
+    char buffer[std::numeric_limits<UInt>::digits / BASE_BITS + 2];
+    format_uint<BASE_BITS>(buffer, value, num_digits, upper);
+    return std::copy_n(buffer, num_digits, out);
 }
 
 #ifndef _WIN32
-# define FMT_USE_WINDOWS_H 0
+#define FMT_USE_WINDOWS_H 0
 #elif !defined(FMT_USE_WINDOWS_H)
-# define FMT_USE_WINDOWS_H 1
+#define FMT_USE_WINDOWS_H 1
 #endif
 
 // Define FMT_USE_WINDOWS_H to 0 to disable use of windows.h.
@@ -1147,47 +1332,76 @@ inline It format_uint(It out, UInt value, unsigned num_digits,
 #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 utf8_to_utf16 {
- private:
-  wmemory_buffer buffer_;
+class utf8_to_utf16
+{
+private:
+    wmemory_buffer buffer_;
 
- public:
-  FMT_API explicit utf8_to_utf16(string_view s);
-  operator wstring_view() const { return wstring_view(&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()); }
+public:
+    FMT_API explicit utf8_to_utf16(string_view s);
+    operator wstring_view() const
+    {
+        return wstring_view(&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 utf16_to_utf8 {
- private:
-  memory_buffer buffer_;
+class utf16_to_utf8
+{
+private:
+    memory_buffer buffer_;
 
- public:
-  utf16_to_utf8() {}
-  FMT_API explicit utf16_to_utf8(wstring_view s);
-  operator string_view() const { return string_view(&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()); }
+public:
+    utf16_to_utf8() {}
+    FMT_API explicit utf16_to_utf8(wstring_view s);
+    operator string_view() const
+    {
+        return string_view(&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(wstring_view s);
+    // 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(wstring_view s);
 };
 
-FMT_API void format_windows_error(fmt::internal::buffer &out, int error_code,
-                                  fmt::string_view message) FMT_NOEXCEPT;
+FMT_API void format_windows_error(fmt::internal::buffer &out, int error_code, fmt::string_view message) FMT_NOEXCEPT;
 #endif
 
-template <typename T = void>
-struct null {};
-}  // namespace internal
+template<typename T = void>
+struct null
+{
+};
+} // namespace internal
 
-struct monostate {};
+struct monostate
+{
+};
 
 /**
   \rst
@@ -1196,821 +1410,1112 @@ struct monostate {};
   ``vis(value)`` will be called with the value of type ``double``.
   \endrst
  */
-template <typename Visitor, typename Context>
-FMT_CONSTEXPR typename internal::result_of<Visitor(int)>::type
-    visit(Visitor &&vis, basic_format_arg<Context> arg) {
-  typedef typename Context::char_type char_type;
-  switch (arg.type_) {
-  case internal::none_type:
-    break;
-  case internal::named_arg_type:
-    FMT_ASSERT(false, "invalid argument type");
-    break;
-  case internal::int_type:
-    return vis(arg.value_.int_value);
-  case internal::uint_type:
-    return vis(arg.value_.uint_value);
-  case internal::long_long_type:
-    return vis(arg.value_.long_long_value);
-  case internal::ulong_long_type:
-    return vis(arg.value_.ulong_long_value);
-  case internal::bool_type:
-    return vis(arg.value_.int_value != 0);
-  case internal::char_type:
-    return vis(static_cast<char_type>(arg.value_.int_value));
-  case internal::double_type:
-    return vis(arg.value_.double_value);
-  case internal::long_double_type:
-    return vis(arg.value_.long_double_value);
-  case internal::cstring_type:
-    return vis(arg.value_.string.value);
-  case internal::string_type:
-    return vis(basic_string_view<char_type>(
-                 arg.value_.string.value, arg.value_.string.size));
-  case internal::pointer_type:
-    return vis(arg.value_.pointer);
-  case internal::custom_type:
-    return vis(typename basic_format_arg<Context>::handle(arg.value_.custom));
-  }
-  return vis(monostate());
+template<typename Visitor, typename Context>
+FMT_CONSTEXPR typename internal::result_of<Visitor(int)>::type visit(Visitor &&vis, basic_format_arg<Context> arg)
+{
+    typedef typename Context::char_type char_type;
+    switch (arg.type_)
+    {
+    case internal::none_type:
+        break;
+    case internal::named_arg_type:
+        FMT_ASSERT(false, "invalid argument type");
+        break;
+    case internal::int_type:
+        return vis(arg.value_.int_value);
+    case internal::uint_type:
+        return vis(arg.value_.uint_value);
+    case internal::long_long_type:
+        return vis(arg.value_.long_long_value);
+    case internal::ulong_long_type:
+        return vis(arg.value_.ulong_long_value);
+    case internal::bool_type:
+        return vis(arg.value_.int_value != 0);
+    case internal::char_type:
+        return vis(static_cast<char_type>(arg.value_.int_value));
+    case internal::double_type:
+        return vis(arg.value_.double_value);
+    case internal::long_double_type:
+        return vis(arg.value_.long_double_value);
+    case internal::cstring_type:
+        return vis(arg.value_.string.value);
+    case internal::string_type:
+        return vis(basic_string_view<char_type>(arg.value_.string.value, arg.value_.string.size));
+    case internal::pointer_type:
+        return vis(arg.value_.pointer);
+    case internal::custom_type:
+        return vis(typename basic_format_arg<Context>::handle(arg.value_.custom));
+    }
+    return vis(monostate());
 }
 
-enum alignment {
-  ALIGN_DEFAULT, ALIGN_LEFT, ALIGN_RIGHT, ALIGN_CENTER, ALIGN_NUMERIC
+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};
+enum
+{
+    SIGN_FLAG = 1,
+    PLUS_FLAG = 2,
+    MINUS_FLAG = 4,
+    HASH_FLAG = 8
+};
 
-enum format_spec_tag {fill_tag, align_tag, width_tag, type_tag};
+enum format_spec_tag
+{
+    fill_tag,
+    align_tag,
+    width_tag,
+    type_tag
+};
 
 // Format specifier.
-template <typename T, format_spec_tag>
-class format_spec {
- private:
-  T value_;
+template<typename T, format_spec_tag>
+class format_spec
+{
+private:
+    T value_;
 
- public:
-  typedef T value_type;
+public:
+    typedef T value_type;
 
-  explicit format_spec(T value) : value_(value) {}
+    explicit format_spec(T value)
+        : value_(value)
+    {
+    }
 
-  T value() const { return value_; }
+    T value() const
+    {
+        return value_;
+    }
 };
 
 // template <typename Char>
 // typedef format_spec<Char, fill_tag> fill_spec;
-template <typename Char>
-class fill_spec : public format_spec<Char, fill_tag> {
- public:
-  explicit fill_spec(Char value) : format_spec<Char, fill_tag>(value) {}
+template<typename Char>
+class fill_spec : public format_spec<Char, fill_tag>
+{
+public:
+    explicit fill_spec(Char value)
+        : format_spec<Char, fill_tag>(value)
+    {
+    }
 };
 
 typedef format_spec<unsigned, width_tag> width_spec;
 typedef format_spec<char, type_tag> type_spec;
 
 // An empty format specifier.
-struct empty_spec {};
+struct empty_spec
+{
+};
 
 // An alignment specifier.
-struct align_spec : empty_spec {
-  unsigned width_;
-  // Fill is always wchar_t and cast to char if necessary to avoid having
-  // two specialization of AlignSpec and its subclasses.
-  wchar_t fill_;
-  alignment align_;
+struct align_spec : empty_spec
+{
+    unsigned width_;
+    // Fill is always wchar_t and cast to char if necessary to avoid having
+    // two specialization of AlignSpec and its subclasses.
+    wchar_t fill_;
+    alignment align_;
 
-  FMT_CONSTEXPR align_spec(
-      unsigned width, wchar_t fill, alignment align = ALIGN_DEFAULT)
-  : width_(width), fill_(fill), align_(align) {}
+    FMT_CONSTEXPR align_spec(unsigned width, wchar_t fill, alignment align = ALIGN_DEFAULT)
+        : width_(width)
+        , fill_(fill)
+        , align_(align)
+    {
+    }
 
-  FMT_CONSTEXPR unsigned width() const { return width_; }
-  FMT_CONSTEXPR wchar_t fill() const { return fill_; }
-  FMT_CONSTEXPR alignment align() const { return align_; }
+    FMT_CONSTEXPR unsigned width() const
+    {
+        return width_;
+    }
+    FMT_CONSTEXPR wchar_t fill() const
+    {
+        return fill_;
+    }
+    FMT_CONSTEXPR alignment align() const
+    {
+        return align_;
+    }
 
-  int precision() const { return -1; }
+    int precision() const
+    {
+        return -1;
+    }
 };
 
 // Format specifiers.
-template <typename Char>
-class basic_format_specs : public align_spec {
- public:
-  unsigned flags_;
-  int precision_;
-  Char type_;
+template<typename Char>
+class basic_format_specs : public align_spec
+{
+public:
+    unsigned flags_;
+    int precision_;
+    Char type_;
 
-  FMT_CONSTEXPR basic_format_specs(
-      unsigned width = 0, char type = 0, wchar_t fill = ' ')
-  : align_spec(width, fill), flags_(0), precision_(-1), type_(type) {}
+    FMT_CONSTEXPR basic_format_specs(unsigned width = 0, char type = 0, wchar_t fill = ' ')
+        : align_spec(width, fill)
+        , flags_(0)
+        , precision_(-1)
+        , type_(type)
+    {
+    }
 
-  FMT_CONSTEXPR bool flag(unsigned f) const { return (flags_ & f) != 0; }
-  FMT_CONSTEXPR int precision() const { return precision_; }
-  FMT_CONSTEXPR Char type() const { return type_; }
+    FMT_CONSTEXPR bool flag(unsigned f) const
+    {
+        return (flags_ & f) != 0;
+    }
+    FMT_CONSTEXPR int precision() const
+    {
+        return precision_;
+    }
+    FMT_CONSTEXPR Char type() const
+    {
+        return type_;
+    }
 };
 
 typedef basic_format_specs<char> format_specs;
 
-template <typename Char, typename ErrorHandler>
-FMT_CONSTEXPR unsigned basic_parse_context<Char, ErrorHandler>::next_arg_id() {
-  if (next_arg_id_ >= 0)
-    return internal::to_unsigned(next_arg_id_++);
-  on_error("cannot switch from manual to automatic argument indexing");
-  return 0;
+template<typename Char, typename ErrorHandler>
+FMT_CONSTEXPR unsigned basic_parse_context<Char, ErrorHandler>::next_arg_id()
+{
+    if (next_arg_id_ >= 0)
+        return internal::to_unsigned(next_arg_id_++);
+    on_error("cannot switch from manual to automatic argument indexing");
+    return 0;
 }
 
-struct format_string {};
+struct format_string
+{
+};
 
 namespace internal {
 
-template <typename Char, typename Handler>
-FMT_CONSTEXPR void handle_int_type_spec(Char spec, Handler &&handler) {
-  switch (spec) {
-  case 0: case 'd':
-    handler.on_dec();
-    break;
-  case 'x': case 'X':
-    handler.on_hex();
-    break;
-  case 'b': case 'B':
-    handler.on_bin();
-    break;
-  case 'o':
-    handler.on_oct();
-    break;
-  case 'n':
-    handler.on_num();
-    break;
-  default:
-    handler.on_error();
-  }
-}
-
-template <typename Char, typename Handler>
-FMT_CONSTEXPR void handle_float_type_spec(Char spec, Handler &&handler) {
-  switch (spec) {
-  case 0: case 'g': case 'G':
-    handler.on_general();
-    break;
-  case 'e': case 'E':
-    handler.on_exp();
-    break;
-  case 'f': case 'F':
-    handler.on_fixed();
-    break;
-   case 'a': case 'A':
-    handler.on_hex();
-    break;
-  default:
-    handler.on_error();
-    break;
-  }
-}
-
-template <typename Char, typename Handler>
-FMT_CONSTEXPR void handle_char_specs(
-    const basic_format_specs<Char> &specs, Handler &&handler) {
-  if (specs.type() && specs.type() != 'c') {
-    handler.on_int();
-    return;
-  }
-  if (specs.align() == ALIGN_NUMERIC || specs.flag(~0u) != 0)
-    handler.on_error("invalid format specifier for char");
-  handler.on_char();
-}
-
-template <typename Char, typename Handler>
-FMT_CONSTEXPR void handle_cstring_type_spec(Char spec, Handler &&handler) {
-  if (spec == 0 || spec == 's')
-    handler.on_string();
-  else if (spec == 'p')
-    handler.on_pointer();
-  else
-    handler.on_error("invalid type specifier");
-}
-
-template <typename Char, typename ErrorHandler>
-FMT_CONSTEXPR void check_string_type_spec(Char spec, ErrorHandler &&eh) {
-  if (spec != 0 && spec != 's')
-    eh.on_error("invalid type specifier");
-}
-
-template <typename Char, typename ErrorHandler>
-FMT_CONSTEXPR void check_pointer_type_spec(Char spec, ErrorHandler &&eh) {
-  if (spec != 0 && spec != 'p')
-    eh.on_error("invalid type specifier");
-}
-
-template <typename ErrorHandler>
-class int_type_checker : private ErrorHandler {
- public:
-  FMT_CONSTEXPR explicit int_type_checker(ErrorHandler eh) : ErrorHandler(eh) {}
-
-  FMT_CONSTEXPR void on_dec() {}
-  FMT_CONSTEXPR void on_hex() {}
-  FMT_CONSTEXPR void on_bin() {}
-  FMT_CONSTEXPR void on_oct() {}
-  FMT_CONSTEXPR void on_num() {}
-
-  FMT_CONSTEXPR void on_error() {
-    ErrorHandler::on_error("invalid type specifier");
-  }
-};
-
-template <typename ErrorHandler>
-class float_type_checker : private ErrorHandler {
- public:
-  FMT_CONSTEXPR explicit float_type_checker(ErrorHandler eh)
-    : ErrorHandler(eh) {}
-
-  FMT_CONSTEXPR void on_general() {}
-  FMT_CONSTEXPR void on_exp() {}
-  FMT_CONSTEXPR void on_fixed() {}
-  FMT_CONSTEXPR void on_hex() {}
-
-  FMT_CONSTEXPR void on_error() {
-    ErrorHandler::on_error("invalid type specifier");
-  }
-};
-
-template <typename ErrorHandler, typename CharType>
-class char_specs_checker : public ErrorHandler {
- private:
-  CharType type_;
-
- public:
-  FMT_CONSTEXPR char_specs_checker(CharType type, ErrorHandler eh)
-    : ErrorHandler(eh), type_(type) {}
-
-  FMT_CONSTEXPR void on_int() {
-    handle_int_type_spec(type_, int_type_checker<ErrorHandler>(*this));
-  }
-  FMT_CONSTEXPR void on_char() {}
-};
-
-template <typename ErrorHandler>
-class cstring_type_checker : public ErrorHandler {
- public:
-  FMT_CONSTEXPR explicit cstring_type_checker(ErrorHandler eh)
-    : ErrorHandler(eh) {}
-
-  FMT_CONSTEXPR void on_string() {}
-  FMT_CONSTEXPR void on_pointer() {}
-};
-
-template <typename Context>
-void arg_map<Context>::init(const basic_format_args<Context> &args) {
-  if (map_)
-    return;
-  map_ = new entry[args.max_size()];
-  bool use_values = args.type(max_packed_args - 1) == internal::none_type;
-  if (use_values) {
-    for (unsigned i = 0;/*nothing*/; ++i) {
-      internal::type arg_type = args.type(i);
-      switch (arg_type) {
-        case internal::none_type:
-          return;
-        case internal::named_arg_type:
-          push_back(args.values_[i]);
-          break;
-        default:
-          break; // Do nothing.
-      }
-    }
-    return;
-  }
-  for (unsigned i = 0; ; ++i) {
-    switch (args.args_[i].type_) {
-      case internal::none_type:
-        return;
-      case internal::named_arg_type:
-        push_back(args.args_[i].value_);
+template<typename Char, typename Handler>
+FMT_CONSTEXPR void handle_int_type_spec(Char spec, Handler &&handler)
+{
+    switch (spec)
+    {
+    case 0:
+    case 'd':
+        handler.on_dec();
         break;
-      default:
-        break; // Do nothing.
+    case 'x':
+    case 'X':
+        handler.on_hex();
+        break;
+    case 'b':
+    case 'B':
+        handler.on_bin();
+        break;
+    case 'o':
+        handler.on_oct();
+        break;
+    case 'n':
+        handler.on_num();
+        break;
+    default:
+        handler.on_error();
     }
-  }
 }
 
-template <typename Range>
-class arg_formatter_base {
- public:
-  typedef typename Range::value_type char_type;
-  typedef decltype(internal::declval<Range>().begin()) iterator;
-  typedef basic_format_specs<char_type> format_specs;
-
- private:
-  typedef basic_writer<Range> writer_type;
-  writer_type writer_;
-  format_specs &specs_;
-
-  FMT_DISALLOW_COPY_AND_ASSIGN(arg_formatter_base);
-
-  struct char_writer {
-    char_type value;
-    template <typename It>
-    void operator()(It &&it) const { *it++ = value; }
-  };
-
-  void write_char(char_type value) {
-    writer_.write_padded(1, specs_, char_writer{value});
-  }
-
-  void write_pointer(const void *p) {
-    format_specs specs = specs_;
-    specs.flags_ = HASH_FLAG;
-    specs.type_ = 'x';
-    writer_.write_int(reinterpret_cast<uintptr_t>(p), specs);
-  }
-
- protected:
-  writer_type &writer() { return writer_; }
-  format_specs &spec() { return specs_; }
-  iterator out() { return writer_.out(); }
-
-  void write(bool value) {
-    writer_.write_str(string_view(value ? "true" : "false"), specs_);
-  }
-
-  void write(const char_type *value) {
-    if (!value)
-      FMT_THROW(format_error("string pointer is null"));
-    auto length = std::char_traits<char_type>::length(value);
-    writer_.write_str(basic_string_view<char_type>(value, length), specs_);
-  }
-
- public:
-  arg_formatter_base(Range r, format_specs &s): writer_(r), specs_(s) {}
-
-  iterator operator()(monostate) {
-    FMT_ASSERT(false, "invalid argument type");
-    return out();
-  }
-
-  template <typename T>
-  typename std::enable_if<std::is_integral<T>::value, iterator>::type
-      operator()(T value) {
-    // MSVC2013 fails to compile separate overloads for bool and char_type so
-    // use std::is_same instead.
-    if (std::is_same<T, bool>::value) {
-      if (specs_.type_)
-        return (*this)(value ? 1 : 0);
-      write(value != 0);
-    } else if (std::is_same<T, char_type>::value) {
-      internal::handle_char_specs(
-        specs_, char_spec_handler(*this, static_cast<char_type>(value)));
-    } else {
-      writer_.write_int(value, specs_);
+template<typename Char, typename Handler>
+FMT_CONSTEXPR void handle_float_type_spec(Char spec, Handler &&handler)
+{
+    switch (spec)
+    {
+    case 0:
+    case 'g':
+    case 'G':
+        handler.on_general();
+        break;
+    case 'e':
+    case 'E':
+        handler.on_exp();
+        break;
+    case 'f':
+    case 'F':
+        handler.on_fixed();
+        break;
+    case 'a':
+    case 'A':
+        handler.on_hex();
+        break;
+    default:
+        handler.on_error();
+        break;
     }
-    return out();
-  }
+}
 
-  template <typename T>
-  typename std::enable_if<std::is_floating_point<T>::value, iterator>::type
-      operator()(T value) {
-    writer_.write_double(value, specs_);
-    return out();
-  }
+template<typename Char, typename Handler>
+FMT_CONSTEXPR void handle_char_specs(const basic_format_specs<Char> &specs, Handler &&handler)
+{
+    if (specs.type() && specs.type() != 'c')
+    {
+        handler.on_int();
+        return;
+    }
+    if (specs.align() == ALIGN_NUMERIC || specs.flag(~0u) != 0)
+        handler.on_error("invalid format specifier for char");
+    handler.on_char();
+}
 
-  struct char_spec_handler : internal::error_handler {
-    arg_formatter_base &formatter;
-    char_type value;
+template<typename Char, typename Handler>
+FMT_CONSTEXPR void handle_cstring_type_spec(Char spec, Handler &&handler)
+{
+    if (spec == 0 || spec == 's')
+        handler.on_string();
+    else if (spec == 'p')
+        handler.on_pointer();
+    else
+        handler.on_error("invalid type specifier");
+}
 
-    char_spec_handler(arg_formatter_base& f, char_type val)
-      : formatter(f), value(val) {}
+template<typename Char, typename ErrorHandler>
+FMT_CONSTEXPR void check_string_type_spec(Char spec, ErrorHandler &&eh)
+{
+    if (spec != 0 && spec != 's')
+        eh.on_error("invalid type specifier");
+}
 
-    void on_int() { formatter.writer_.write_int(value, formatter.specs_); }
-    void on_char() { formatter.write_char(value); }
-  };
+template<typename Char, typename ErrorHandler>
+FMT_CONSTEXPR void check_pointer_type_spec(Char spec, ErrorHandler &&eh)
+{
+    if (spec != 0 && spec != 'p')
+        eh.on_error("invalid type specifier");
+}
 
-  struct cstring_spec_handler : internal::error_handler {
-    arg_formatter_base &formatter;
-    const char_type *value;
+template<typename ErrorHandler>
+class int_type_checker : private ErrorHandler
+{
+public:
+    FMT_CONSTEXPR explicit int_type_checker(ErrorHandler eh)
+        : ErrorHandler(eh)
+    {
+    }
 
-    cstring_spec_handler(arg_formatter_base &f, const char_type *val)
-      : formatter(f), value(val) {}
+    FMT_CONSTEXPR void on_dec() {}
+    FMT_CONSTEXPR void on_hex() {}
+    FMT_CONSTEXPR void on_bin() {}
+    FMT_CONSTEXPR void on_oct() {}
+    FMT_CONSTEXPR void on_num() {}
 
-    void on_string() { formatter.write(value); }
-    void on_pointer() { formatter.write_pointer(value); }
-  };
-
-  iterator operator()(const char_type *value) {
-    internal::handle_cstring_type_spec(
-          specs_.type_, cstring_spec_handler(*this, value));
-    return out();
-  }
-
-  iterator operator()(basic_string_view<char_type> value) {
-    internal::check_string_type_spec(specs_.type_, internal::error_handler());
-    writer_.write_str(value, specs_);
-    return out();
-  }
-
-  iterator operator()(const void *value) {
-    check_pointer_type_spec(specs_.type_, internal::error_handler());
-    write_pointer(value);
-    return out();
-  }
+    FMT_CONSTEXPR void on_error()
+    {
+        ErrorHandler::on_error("invalid type specifier");
+    }
 };
 
-template <typename S>
-struct is_format_string:
-  std::integral_constant<bool, std::is_base_of<format_string, S>::value> {};
+template<typename ErrorHandler>
+class float_type_checker : private ErrorHandler
+{
+public:
+    FMT_CONSTEXPR explicit float_type_checker(ErrorHandler eh)
+        : ErrorHandler(eh)
+    {
+    }
 
-template <typename Char>
-FMT_CONSTEXPR bool is_name_start(Char c) {
-  return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c;
+    FMT_CONSTEXPR void on_general() {}
+    FMT_CONSTEXPR void on_exp() {}
+    FMT_CONSTEXPR void on_fixed() {}
+    FMT_CONSTEXPR void on_hex() {}
+
+    FMT_CONSTEXPR void on_error()
+    {
+        ErrorHandler::on_error("invalid type specifier");
+    }
+};
+
+template<typename ErrorHandler, typename CharType>
+class char_specs_checker : public ErrorHandler
+{
+private:
+    CharType type_;
+
+public:
+    FMT_CONSTEXPR char_specs_checker(CharType type, ErrorHandler eh)
+        : ErrorHandler(eh)
+        , type_(type)
+    {
+    }
+
+    FMT_CONSTEXPR void on_int()
+    {
+        handle_int_type_spec(type_, int_type_checker<ErrorHandler>(*this));
+    }
+    FMT_CONSTEXPR void on_char() {}
+};
+
+template<typename ErrorHandler>
+class cstring_type_checker : public ErrorHandler
+{
+public:
+    FMT_CONSTEXPR explicit cstring_type_checker(ErrorHandler eh)
+        : ErrorHandler(eh)
+    {
+    }
+
+    FMT_CONSTEXPR void on_string() {}
+    FMT_CONSTEXPR void on_pointer() {}
+};
+
+template<typename Context>
+void arg_map<Context>::init(const basic_format_args<Context> &args)
+{
+    if (map_)
+        return;
+    map_ = new entry[args.max_size()];
+    bool use_values = args.type(max_packed_args - 1) == internal::none_type;
+    if (use_values)
+    {
+        for (unsigned i = 0; /*nothing*/; ++i)
+        {
+            internal::type arg_type = args.type(i);
+            switch (arg_type)
+            {
+            case internal::none_type:
+                return;
+            case internal::named_arg_type:
+                push_back(args.values_[i]);
+                break;
+            default:
+                break; // Do nothing.
+            }
+        }
+        return;
+    }
+    for (unsigned i = 0;; ++i)
+    {
+        switch (args.args_[i].type_)
+        {
+        case internal::none_type:
+            return;
+        case internal::named_arg_type:
+            push_back(args.args_[i].value_);
+            break;
+        default:
+            break; // Do nothing.
+        }
+    }
+}
+
+template<typename Range>
+class arg_formatter_base
+{
+public:
+    typedef typename Range::value_type char_type;
+    typedef decltype(internal::declval<Range>().begin()) iterator;
+    typedef basic_format_specs<char_type> format_specs;
+
+private:
+    typedef basic_writer<Range> writer_type;
+    writer_type writer_;
+    format_specs &specs_;
+
+    FMT_DISALLOW_COPY_AND_ASSIGN(arg_formatter_base);
+
+    struct char_writer
+    {
+        char_type value;
+        template<typename It>
+        void operator()(It &&it) const
+        {
+            *it++ = value;
+        }
+    };
+
+    void write_char(char_type value)
+    {
+        writer_.write_padded(1, specs_, char_writer{value});
+    }
+
+    void write_pointer(const void *p)
+    {
+        format_specs specs = specs_;
+        specs.flags_ = HASH_FLAG;
+        specs.type_ = 'x';
+        writer_.write_int(reinterpret_cast<uintptr_t>(p), specs);
+    }
+
+protected:
+    writer_type &writer()
+    {
+        return writer_;
+    }
+    format_specs &spec()
+    {
+        return specs_;
+    }
+    iterator out()
+    {
+        return writer_.out();
+    }
+
+    void write(bool value)
+    {
+        writer_.write_str(string_view(value ? "true" : "false"), specs_);
+    }
+
+    void write(const char_type *value)
+    {
+        if (!value)
+            FMT_THROW(format_error("string pointer is null"));
+        auto length = std::char_traits<char_type>::length(value);
+        writer_.write_str(basic_string_view<char_type>(value, length), specs_);
+    }
+
+public:
+    arg_formatter_base(Range r, format_specs &s)
+        : writer_(r)
+        , specs_(s)
+    {
+    }
+
+    iterator operator()(monostate)
+    {
+        FMT_ASSERT(false, "invalid argument type");
+        return out();
+    }
+
+    template<typename T>
+    typename std::enable_if<std::is_integral<T>::value, iterator>::type operator()(T value)
+    {
+        // MSVC2013 fails to compile separate overloads for bool and char_type so
+        // use std::is_same instead.
+        if (std::is_same<T, bool>::value)
+        {
+            if (specs_.type_)
+                return (*this)(value ? 1 : 0);
+            write(value != 0);
+        }
+        else if (std::is_same<T, char_type>::value)
+        {
+            internal::handle_char_specs(specs_, char_spec_handler(*this, static_cast<char_type>(value)));
+        }
+        else
+        {
+            writer_.write_int(value, specs_);
+        }
+        return out();
+    }
+
+    template<typename T>
+    typename std::enable_if<std::is_floating_point<T>::value, iterator>::type operator()(T value)
+    {
+        writer_.write_double(value, specs_);
+        return out();
+    }
+
+    struct char_spec_handler : internal::error_handler
+    {
+        arg_formatter_base &formatter;
+        char_type value;
+
+        char_spec_handler(arg_formatter_base &f, char_type val)
+            : formatter(f)
+            , value(val)
+        {
+        }
+
+        void on_int()
+        {
+            formatter.writer_.write_int(value, formatter.specs_);
+        }
+        void on_char()
+        {
+            formatter.write_char(value);
+        }
+    };
+
+    struct cstring_spec_handler : internal::error_handler
+    {
+        arg_formatter_base &formatter;
+        const char_type *value;
+
+        cstring_spec_handler(arg_formatter_base &f, const char_type *val)
+            : formatter(f)
+            , value(val)
+        {
+        }
+
+        void on_string()
+        {
+            formatter.write(value);
+        }
+        void on_pointer()
+        {
+            formatter.write_pointer(value);
+        }
+    };
+
+    iterator operator()(const char_type *value)
+    {
+        internal::handle_cstring_type_spec(specs_.type_, cstring_spec_handler(*this, value));
+        return out();
+    }
+
+    iterator operator()(basic_string_view<char_type> value)
+    {
+        internal::check_string_type_spec(specs_.type_, internal::error_handler());
+        writer_.write_str(value, specs_);
+        return out();
+    }
+
+    iterator operator()(const void *value)
+    {
+        check_pointer_type_spec(specs_.type_, internal::error_handler());
+        write_pointer(value);
+        return out();
+    }
+};
+
+template<typename S>
+struct is_format_string : std::integral_constant<bool, std::is_base_of<format_string, S>::value>
+{
+};
+
+template<typename Char>
+FMT_CONSTEXPR bool is_name_start(Char c)
+{
+    return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c;
 }
 
 // Parses the input as an unsigned integer. This function assumes that the
 // first character is a digit and presence of a non-digit character at the end.
 // it: an iterator pointing to the beginning of the input range.
-template <typename Iterator, typename ErrorHandler>
-FMT_CONSTEXPR unsigned parse_nonnegative_int(Iterator &it, ErrorHandler &&eh) {
-  assert('0' <= *it && *it <= '9');
-  unsigned value = 0;
-  // Convert to unsigned to prevent a warning.
-  unsigned max_int = (std::numeric_limits<int>::max)();
-  unsigned big = max_int / 10;
-  do {
-    // Check for overflow.
-    if (value > big) {
-      value = max_int + 1;
-      break;
-    }
-    value = value * 10 + unsigned(*it - '0');
-    // Workaround for MSVC "setup_exception stack overflow" error:
-    auto next = it;
-    ++next;
-    it = next;
-  } while ('0' <= *it && *it <= '9');
-  if (value > max_int)
-    eh.on_error("number is too big");
-  return value;
+template<typename Iterator, typename ErrorHandler>
+FMT_CONSTEXPR unsigned parse_nonnegative_int(Iterator &it, ErrorHandler &&eh)
+{
+    assert('0' <= *it && *it <= '9');
+    unsigned value = 0;
+    // Convert to unsigned to prevent a warning.
+    unsigned max_int = (std::numeric_limits<int>::max)();
+    unsigned big = max_int / 10;
+    do
+    {
+        // Check for overflow.
+        if (value > big)
+        {
+            value = max_int + 1;
+            break;
+        }
+        value = value * 10 + unsigned(*it - '0');
+        // Workaround for MSVC "setup_exception stack overflow" error:
+        auto next = it;
+        ++next;
+        it = next;
+    } while ('0' <= *it && *it <= '9');
+    if (value > max_int)
+        eh.on_error("number is too big");
+    return value;
 }
 
-template <typename Char, typename Context>
-class custom_formatter: public function<bool> {
- private:
-  Context &ctx_;
+template<typename Char, typename Context>
+class custom_formatter : public function<bool>
+{
+private:
+    Context &ctx_;
 
- public:
-  explicit custom_formatter(Context &ctx): ctx_(ctx) {}
+public:
+    explicit custom_formatter(Context &ctx)
+        : ctx_(ctx)
+    {
+    }
 
-  bool operator()(typename basic_format_arg<Context>::handle h) const {
-    h.format(ctx_);
-    return true;
-  }
+    bool operator()(typename basic_format_arg<Context>::handle h) const
+    {
+        h.format(ctx_);
+        return true;
+    }
 
-  template <typename T>
-  bool operator()(T) const { return false; }
+    template<typename T>
+    bool operator()(T) const
+    {
+        return false;
+    }
 };
 
-template <typename T>
-struct is_integer {
-  enum {
-    value = std::is_integral<T>::value && !std::is_same<T, bool>::value &&
-            !std::is_same<T, char>::value && !std::is_same<T, wchar_t>::value
-  };
+template<typename T>
+struct is_integer
+{
+    enum
+    {
+        value =
+            std::is_integral<T>::value && !std::is_same<T, bool>::value && !std::is_same<T, char>::value && !std::is_same<T, wchar_t>::value
+    };
 };
 
-template <typename ErrorHandler>
-class width_checker: public function<unsigned long long> {
- public:
-  explicit FMT_CONSTEXPR width_checker(ErrorHandler &eh) : handler_(eh) {}
+template<typename ErrorHandler>
+class width_checker : public function<unsigned long long>
+{
+public:
+    explicit FMT_CONSTEXPR width_checker(ErrorHandler &eh)
+        : handler_(eh)
+    {
+    }
 
-  template <typename T>
-  FMT_CONSTEXPR
-  typename std::enable_if<
-      is_integer<T>::value, unsigned long long>::type operator()(T value) {
-    if (is_negative(value))
-      handler_.on_error("negative width");
-    return static_cast<unsigned long long>(value);
-  }
+    template<typename T>
+    FMT_CONSTEXPR typename std::enable_if<is_integer<T>::value, unsigned long long>::type operator()(T value)
+    {
+        if (is_negative(value))
+            handler_.on_error("negative width");
+        return static_cast<unsigned long long>(value);
+    }
 
-  template <typename T>
-  FMT_CONSTEXPR typename std::enable_if<
-      !is_integer<T>::value, unsigned long long>::type operator()(T) {
-    handler_.on_error("width is not integer");
-    return 0;
-  }
+    template<typename T>
+    FMT_CONSTEXPR typename std::enable_if<!is_integer<T>::value, unsigned long long>::type operator()(T)
+    {
+        handler_.on_error("width is not integer");
+        return 0;
+    }
 
- private:
-  ErrorHandler &handler_;
+private:
+    ErrorHandler &handler_;
 };
 
-template <typename ErrorHandler>
-class precision_checker: public function<unsigned long long> {
- public:
-  explicit FMT_CONSTEXPR precision_checker(ErrorHandler &eh) : handler_(eh) {}
+template<typename ErrorHandler>
+class precision_checker : public function<unsigned long long>
+{
+public:
+    explicit FMT_CONSTEXPR precision_checker(ErrorHandler &eh)
+        : handler_(eh)
+    {
+    }
 
-  template <typename T>
-  FMT_CONSTEXPR typename std::enable_if<
-      is_integer<T>::value, unsigned long long>::type operator()(T value) {
-    if (is_negative(value))
-      handler_.on_error("negative precision");
-    return static_cast<unsigned long long>(value);
-  }
+    template<typename T>
+    FMT_CONSTEXPR typename std::enable_if<is_integer<T>::value, unsigned long long>::type operator()(T value)
+    {
+        if (is_negative(value))
+            handler_.on_error("negative precision");
+        return static_cast<unsigned long long>(value);
+    }
 
-  template <typename T>
-  FMT_CONSTEXPR typename std::enable_if<
-      !is_integer<T>::value, unsigned long long>::type operator()(T) {
-    handler_.on_error("precision is not integer");
-    return 0;
-  }
+    template<typename T>
+    FMT_CONSTEXPR typename std::enable_if<!is_integer<T>::value, unsigned long long>::type operator()(T)
+    {
+        handler_.on_error("precision is not integer");
+        return 0;
+    }
 
- private:
-  ErrorHandler &handler_;
+private:
+    ErrorHandler &handler_;
 };
 
 // A format specifier handler that sets fields in basic_format_specs.
-template <typename Char>
-class specs_setter {
- public:
-  explicit FMT_CONSTEXPR specs_setter(basic_format_specs<Char> &specs):
-    specs_(specs) {}
+template<typename Char>
+class specs_setter
+{
+public:
+    explicit FMT_CONSTEXPR specs_setter(basic_format_specs<Char> &specs)
+        : specs_(specs)
+    {
+    }
 
-  FMT_CONSTEXPR specs_setter(const specs_setter &other) : specs_(other.specs_) {}
+    FMT_CONSTEXPR specs_setter(const specs_setter &other)
+        : specs_(other.specs_)
+    {
+    }
 
-  FMT_CONSTEXPR void on_align(alignment align) { specs_.align_ = align; }
-  FMT_CONSTEXPR void on_fill(Char fill) { specs_.fill_ = fill; }
-  FMT_CONSTEXPR void on_plus() { specs_.flags_ |= SIGN_FLAG | PLUS_FLAG; }
-  FMT_CONSTEXPR void on_minus() { specs_.flags_ |= MINUS_FLAG; }
-  FMT_CONSTEXPR void on_space() { specs_.flags_ |= SIGN_FLAG; }
-  FMT_CONSTEXPR void on_hash() { specs_.flags_ |= HASH_FLAG; }
+    FMT_CONSTEXPR void on_align(alignment align)
+    {
+        specs_.align_ = align;
+    }
+    FMT_CONSTEXPR void on_fill(Char fill)
+    {
+        specs_.fill_ = fill;
+    }
+    FMT_CONSTEXPR void on_plus()
+    {
+        specs_.flags_ |= SIGN_FLAG | PLUS_FLAG;
+    }
+    FMT_CONSTEXPR void on_minus()
+    {
+        specs_.flags_ |= MINUS_FLAG;
+    }
+    FMT_CONSTEXPR void on_space()
+    {
+        specs_.flags_ |= SIGN_FLAG;
+    }
+    FMT_CONSTEXPR void on_hash()
+    {
+        specs_.flags_ |= HASH_FLAG;
+    }
 
-  FMT_CONSTEXPR void on_zero() {
-    specs_.align_ = ALIGN_NUMERIC;
-    specs_.fill_ = '0';
-  }
+    FMT_CONSTEXPR void on_zero()
+    {
+        specs_.align_ = ALIGN_NUMERIC;
+        specs_.fill_ = '0';
+    }
 
-  FMT_CONSTEXPR void on_width(unsigned width) { specs_.width_ = width; }
-  FMT_CONSTEXPR void on_precision(unsigned precision) {
-    specs_.precision_ = static_cast<int>(precision);
-  }
-  FMT_CONSTEXPR void end_precision() {}
+    FMT_CONSTEXPR void on_width(unsigned width)
+    {
+        specs_.width_ = width;
+    }
+    FMT_CONSTEXPR void on_precision(unsigned precision)
+    {
+        specs_.precision_ = static_cast<int>(precision);
+    }
+    FMT_CONSTEXPR void end_precision() {}
 
-  FMT_CONSTEXPR void on_type(Char type) { specs_.type_ = type; }
+    FMT_CONSTEXPR void on_type(Char type)
+    {
+        specs_.type_ = type;
+    }
 
- protected:
-  basic_format_specs<Char> &specs_;
+protected:
+    basic_format_specs<Char> &specs_;
 };
 
 // A format specifier handler that checks if specifiers are consistent with the
 // argument type.
-template <typename Handler>
-class specs_checker : public Handler {
- public:
-  FMT_CONSTEXPR specs_checker(const Handler& handler, internal::type arg_type)
-    : Handler(handler), arg_type_(arg_type) {}
-
-  FMT_CONSTEXPR specs_checker(const specs_checker &other)
-    : Handler(other), arg_type_(other.arg_type_) {}
-
-  FMT_CONSTEXPR void on_align(alignment align) {
-    if (align == ALIGN_NUMERIC)
-      require_numeric_argument();
-    Handler::on_align(align);
-  }
-
-  FMT_CONSTEXPR void on_plus() {
-    check_sign();
-    Handler::on_plus();
-  }
-
-  FMT_CONSTEXPR void on_minus() {
-    check_sign();
-    Handler::on_minus();
-  }
-
-  FMT_CONSTEXPR void on_space() {
-    check_sign();
-    Handler::on_space();
-  }
-
-  FMT_CONSTEXPR void on_hash() {
-    require_numeric_argument();
-    Handler::on_hash();
-  }
-
-  FMT_CONSTEXPR void on_zero() {
-    require_numeric_argument();
-    Handler::on_zero();
-  }
-
-  FMT_CONSTEXPR void end_precision() {
-    if (is_integral(arg_type_) || arg_type_ == pointer_type)
-      this->on_error("precision not allowed for this argument type");
-  }
-
- private:
-  FMT_CONSTEXPR void require_numeric_argument() {
-    if (!is_arithmetic(arg_type_))
-      this->on_error("format specifier requires numeric argument");
-  }
-
-  FMT_CONSTEXPR void check_sign() {
-    require_numeric_argument();
-    if (is_integral(arg_type_) && arg_type_ != int_type &&
-        arg_type_ != long_long_type && arg_type_ != internal::char_type) {
-      this->on_error("format specifier requires signed argument");
+template<typename Handler>
+class specs_checker : public Handler
+{
+public:
+    FMT_CONSTEXPR specs_checker(const Handler &handler, internal::type arg_type)
+        : Handler(handler)
+        , arg_type_(arg_type)
+    {
     }
-  }
 
-  internal::type arg_type_;
+    FMT_CONSTEXPR specs_checker(const specs_checker &other)
+        : Handler(other)
+        , arg_type_(other.arg_type_)
+    {
+    }
+
+    FMT_CONSTEXPR void on_align(alignment align)
+    {
+        if (align == ALIGN_NUMERIC)
+            require_numeric_argument();
+        Handler::on_align(align);
+    }
+
+    FMT_CONSTEXPR void on_plus()
+    {
+        check_sign();
+        Handler::on_plus();
+    }
+
+    FMT_CONSTEXPR void on_minus()
+    {
+        check_sign();
+        Handler::on_minus();
+    }
+
+    FMT_CONSTEXPR void on_space()
+    {
+        check_sign();
+        Handler::on_space();
+    }
+
+    FMT_CONSTEXPR void on_hash()
+    {
+        require_numeric_argument();
+        Handler::on_hash();
+    }
+
+    FMT_CONSTEXPR void on_zero()
+    {
+        require_numeric_argument();
+        Handler::on_zero();
+    }
+
+    FMT_CONSTEXPR void end_precision()
+    {
+        if (is_integral(arg_type_) || arg_type_ == pointer_type)
+            this->on_error("precision not allowed for this argument type");
+    }
+
+private:
+    FMT_CONSTEXPR void require_numeric_argument()
+    {
+        if (!is_arithmetic(arg_type_))
+            this->on_error("format specifier requires numeric argument");
+    }
+
+    FMT_CONSTEXPR void check_sign()
+    {
+        require_numeric_argument();
+        if (is_integral(arg_type_) && arg_type_ != int_type && arg_type_ != long_long_type && arg_type_ != internal::char_type)
+        {
+            this->on_error("format specifier requires signed argument");
+        }
+    }
+
+    internal::type arg_type_;
 };
 
-template <template <typename> class Handler, typename T,
-          typename Context, typename ErrorHandler>
-FMT_CONSTEXPR void set_dynamic_spec(
-    T &value, basic_format_arg<Context> arg, ErrorHandler eh) {
-  unsigned long long big_value = visit(Handler<ErrorHandler>(eh), arg);
-  if (big_value > (std::numeric_limits<int>::max)())
-    eh.on_error("number is too big");
-  value = static_cast<T>(big_value);
+template<template<typename> class Handler, typename T, typename Context, typename ErrorHandler>
+FMT_CONSTEXPR void set_dynamic_spec(T &value, basic_format_arg<Context> arg, ErrorHandler eh)
+{
+    unsigned long long big_value = visit(Handler<ErrorHandler>(eh), arg);
+    if (big_value > (std::numeric_limits<int>::max)())
+        eh.on_error("number is too big");
+    value = static_cast<T>(big_value);
 }
 
-struct auto_id {};
+struct auto_id
+{
+};
 
 // The standard format specifier handler with checking.
-template <typename Context>
-class specs_handler: public specs_setter<typename Context::char_type> {
- public:
-  typedef typename Context::char_type char_type;
+template<typename Context>
+class specs_handler : public specs_setter<typename Context::char_type>
+{
+public:
+    typedef typename Context::char_type char_type;
 
-  FMT_CONSTEXPR specs_handler(basic_format_specs<char_type> &specs, Context &ctx)
-    : specs_setter<char_type>(specs), context_(ctx) {}
+    FMT_CONSTEXPR specs_handler(basic_format_specs<char_type> &specs, Context &ctx)
+        : specs_setter<char_type>(specs)
+        , context_(ctx)
+    {
+    }
 
-  template <typename Id>
-  FMT_CONSTEXPR void on_dynamic_width(Id arg_id) {
-    set_dynamic_spec<width_checker>(
-          this->specs_.width_, get_arg(arg_id), context_.error_handler());
-  }
+    template<typename Id>
+    FMT_CONSTEXPR void on_dynamic_width(Id arg_id)
+    {
+        set_dynamic_spec<width_checker>(this->specs_.width_, get_arg(arg_id), context_.error_handler());
+    }
 
-  template <typename Id>
-  FMT_CONSTEXPR void on_dynamic_precision(Id arg_id) {
-    set_dynamic_spec<precision_checker>(
-          this->specs_.precision_, get_arg(arg_id), context_.error_handler());
-  }
+    template<typename Id>
+    FMT_CONSTEXPR void on_dynamic_precision(Id arg_id)
+    {
+        set_dynamic_spec<precision_checker>(this->specs_.precision_, get_arg(arg_id), context_.error_handler());
+    }
 
-  void on_error(const char *message) {
-    context_.on_error(message);
-  }
+    void on_error(const char *message)
+    {
+        context_.on_error(message);
+    }
 
- private:
-  FMT_CONSTEXPR basic_format_arg<Context> get_arg(auto_id) {
-    return context_.next_arg();
-  }
+private:
+    FMT_CONSTEXPR basic_format_arg<Context> get_arg(auto_id)
+    {
+        return context_.next_arg();
+    }
 
-  template <typename Id>
-  FMT_CONSTEXPR basic_format_arg<Context> get_arg(Id arg_id) {
-    context_.parse_context().check_arg_id(arg_id);
-    return context_.get_arg(arg_id);
-  }
+    template<typename Id>
+    FMT_CONSTEXPR basic_format_arg<Context> get_arg(Id arg_id)
+    {
+        context_.parse_context().check_arg_id(arg_id);
+        return context_.get_arg(arg_id);
+    }
 
-  Context &context_;
+    Context &context_;
 };
 
 // An argument reference.
-template <typename Char>
-struct arg_ref {
-  enum Kind { NONE, INDEX, NAME };
+template<typename Char>
+struct arg_ref
+{
+    enum Kind
+    {
+        NONE,
+        INDEX,
+        NAME
+    };
 
-  FMT_CONSTEXPR arg_ref() : kind(NONE), index(0) {}
-  FMT_CONSTEXPR explicit arg_ref(unsigned index) : kind(INDEX), index(index) {}
-  explicit arg_ref(basic_string_view<Char> name) : kind(NAME), name(name) {}
+    FMT_CONSTEXPR arg_ref()
+        : kind(NONE)
+        , index(0)
+    {
+    }
+    FMT_CONSTEXPR explicit arg_ref(unsigned index)
+        : kind(INDEX)
+        , index(index)
+    {
+    }
+    explicit arg_ref(basic_string_view<Char> name)
+        : kind(NAME)
+        , name(name)
+    {
+    }
 
-  FMT_CONSTEXPR arg_ref &operator=(unsigned idx) {
-    kind = INDEX;
-    index = idx;
-    return *this;
-  }
+    FMT_CONSTEXPR arg_ref &operator=(unsigned idx)
+    {
+        kind = INDEX;
+        index = idx;
+        return *this;
+    }
 
-  Kind kind;
-  FMT_UNION {
-    unsigned index;
-    basic_string_view<Char> name;
-  };
+    Kind kind;
+    FMT_UNION
+    {
+        unsigned index;
+        basic_string_view<Char> name;
+    };
 };
 
 // Format specifiers with width and precision resolved at formatting rather
 // than parsing time to allow re-using the same parsed specifiers with
 // differents sets of arguments (precompilation of format strings).
-template <typename Char>
-struct dynamic_format_specs : basic_format_specs<Char> {
-  arg_ref<Char> width_ref;
-  arg_ref<Char> precision_ref;
+template<typename Char>
+struct dynamic_format_specs : basic_format_specs<Char>
+{
+    arg_ref<Char> width_ref;
+    arg_ref<Char> precision_ref;
 };
 
 // Format spec handler that saves references to arguments representing dynamic
 // width and precision to be resolved at formatting time.
-template <typename ParseContext>
-class dynamic_specs_handler :
-    public specs_setter<typename ParseContext::char_type> {
- public:
-  typedef typename ParseContext::char_type char_type;
+template<typename ParseContext>
+class dynamic_specs_handler : public specs_setter<typename ParseContext::char_type>
+{
+public:
+    typedef typename ParseContext::char_type char_type;
 
-  FMT_CONSTEXPR dynamic_specs_handler(
-      dynamic_format_specs<char_type> &specs, ParseContext &ctx)
-    : specs_setter<char_type>(specs), specs_(specs), context_(ctx) {}
+    FMT_CONSTEXPR dynamic_specs_handler(dynamic_format_specs<char_type> &specs, ParseContext &ctx)
+        : specs_setter<char_type>(specs)
+        , specs_(specs)
+        , context_(ctx)
+    {
+    }
 
-  FMT_CONSTEXPR dynamic_specs_handler(const dynamic_specs_handler &other)
-    : specs_setter<char_type>(other),
-      specs_(other.specs_), context_(other.context_) {}
+    FMT_CONSTEXPR dynamic_specs_handler(const dynamic_specs_handler &other)
+        : specs_setter<char_type>(other)
+        , specs_(other.specs_)
+        , context_(other.context_)
+    {
+    }
 
-  template <typename Id>
-  FMT_CONSTEXPR void on_dynamic_width(Id arg_id) {
-    specs_.width_ref = make_arg_ref(arg_id);
-  }
+    template<typename Id>
+    FMT_CONSTEXPR void on_dynamic_width(Id arg_id)
+    {
+        specs_.width_ref = make_arg_ref(arg_id);
+    }
 
-  template <typename Id>
-  FMT_CONSTEXPR void on_dynamic_precision(Id arg_id) {
-    specs_.precision_ref = make_arg_ref(arg_id);
-  }
+    template<typename Id>
+    FMT_CONSTEXPR void on_dynamic_precision(Id arg_id)
+    {
+        specs_.precision_ref = make_arg_ref(arg_id);
+    }
 
-  FMT_CONSTEXPR void on_error(const char *message) {
-    context_.on_error(message);
-  }
+    FMT_CONSTEXPR void on_error(const char *message)
+    {
+        context_.on_error(message);
+    }
 
- private:
-  typedef arg_ref<char_type> arg_ref_type;
+private:
+    typedef arg_ref<char_type> arg_ref_type;
 
-  template <typename Id>
-  FMT_CONSTEXPR arg_ref_type make_arg_ref(Id arg_id) {
-    context_.check_arg_id(arg_id);
-    return arg_ref_type(arg_id);
-  }
+    template<typename Id>
+    FMT_CONSTEXPR arg_ref_type make_arg_ref(Id arg_id)
+    {
+        context_.check_arg_id(arg_id);
+        return arg_ref_type(arg_id);
+    }
 
-  FMT_CONSTEXPR arg_ref_type make_arg_ref(auto_id) {
-    return arg_ref_type(context_.next_arg_id());
-  }
+    FMT_CONSTEXPR arg_ref_type make_arg_ref(auto_id)
+    {
+        return arg_ref_type(context_.next_arg_id());
+    }
 
-  dynamic_format_specs<char_type> &specs_;
-  ParseContext &context_;
+    dynamic_format_specs<char_type> &specs_;
+    ParseContext &context_;
 };
 
-template <typename Iterator, typename IDHandler>
-FMT_CONSTEXPR Iterator parse_arg_id(Iterator it, IDHandler &&handler) {
-  typedef typename std::iterator_traits<Iterator>::value_type char_type;
-  char_type c = *it;
-  if (c == '}' || c == ':') {
-    handler();
-    return it;
-  }
-  if (c >= '0' && c <= '9') {
-    unsigned index = parse_nonnegative_int(it, handler);
-    if (*it != '}' && *it != ':') {
-      handler.on_error("invalid format string");
-      return it;
+template<typename Iterator, typename IDHandler>
+FMT_CONSTEXPR Iterator parse_arg_id(Iterator it, IDHandler &&handler)
+{
+    typedef typename std::iterator_traits<Iterator>::value_type char_type;
+    char_type c = *it;
+    if (c == '}' || c == ':')
+    {
+        handler();
+        return it;
     }
-    handler(index);
+    if (c >= '0' && c <= '9')
+    {
+        unsigned index = parse_nonnegative_int(it, handler);
+        if (*it != '}' && *it != ':')
+        {
+            handler.on_error("invalid format string");
+            return it;
+        }
+        handler(index);
+        return it;
+    }
+    if (!is_name_start(c))
+    {
+        handler.on_error("invalid format string");
+        return it;
+    }
+    auto start = it;
+    do
+    {
+        c = *++it;
+    } while (is_name_start(c) || ('0' <= c && c <= '9'));
+    handler(basic_string_view<char_type>(pointer_from(start), to_unsigned(it - start)));
     return it;
-  }
-  if (!is_name_start(c)) {
-    handler.on_error("invalid format string");
-    return it;
-  }
-  auto start = it;
-  do {
-    c = *++it;
-  } while (is_name_start(c) || ('0' <= c && c <= '9'));
-  handler(basic_string_view<char_type>(pointer_from(start), to_unsigned(it - start)));
-  return it;
 }
 
 // Adapts SpecHandler to IDHandler API for dynamic width.
-template <typename SpecHandler, typename Char>
-struct width_adapter {
-  explicit FMT_CONSTEXPR width_adapter(SpecHandler &h) : handler(h) {}
+template<typename SpecHandler, typename Char>
+struct width_adapter
+{
+    explicit FMT_CONSTEXPR width_adapter(SpecHandler &h)
+        : handler(h)
+    {
+    }
 
-  FMT_CONSTEXPR void operator()() { handler.on_dynamic_width(auto_id()); }
-  FMT_CONSTEXPR void operator()(unsigned id) { handler.on_dynamic_width(id); }
-  FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
-    handler.on_dynamic_width(id);
-  }
+    FMT_CONSTEXPR void operator()()
+    {
+        handler.on_dynamic_width(auto_id());
+    }
+    FMT_CONSTEXPR void operator()(unsigned id)
+    {
+        handler.on_dynamic_width(id);
+    }
+    FMT_CONSTEXPR void operator()(basic_string_view<Char> id)
+    {
+        handler.on_dynamic_width(id);
+    }
 
-  FMT_CONSTEXPR void on_error(const char *message) {
-    handler.on_error(message);
-  }
+    FMT_CONSTEXPR void on_error(const char *message)
+    {
+        handler.on_error(message);
+    }
 
-  SpecHandler &handler;
+    SpecHandler &handler;
 };
 
 // Adapts SpecHandler to IDHandler API for dynamic precision.
-template <typename SpecHandler, typename Char>
-struct precision_adapter {
-  explicit FMT_CONSTEXPR precision_adapter(SpecHandler &h) : handler(h) {}
+template<typename SpecHandler, typename Char>
+struct precision_adapter
+{
+    explicit FMT_CONSTEXPR precision_adapter(SpecHandler &h)
+        : handler(h)
+    {
+    }
 
-  FMT_CONSTEXPR void operator()() { handler.on_dynamic_precision(auto_id()); }
-  FMT_CONSTEXPR void operator()(unsigned id) {
-    handler.on_dynamic_precision(id);
-  }
-  FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
-    handler.on_dynamic_precision(id);
-  }
+    FMT_CONSTEXPR void operator()()
+    {
+        handler.on_dynamic_precision(auto_id());
+    }
+    FMT_CONSTEXPR void operator()(unsigned id)
+    {
+        handler.on_dynamic_precision(id);
+    }
+    FMT_CONSTEXPR void operator()(basic_string_view<Char> id)
+    {
+        handler.on_dynamic_precision(id);
+    }
 
-  FMT_CONSTEXPR void on_error(const char *message) { handler.on_error(message); }
+    FMT_CONSTEXPR void on_error(const char *message)
+    {
+        handler.on_error(message);
+    }
 
-  SpecHandler &handler;
+    SpecHandler &handler;
 };
 
 // Parses standard format specifiers and sends notifications about parsed
@@ -2018,344 +2523,411 @@ struct precision_adapter {
 // it: an iterator pointing to the beginning of a null-terminated range of
 //     characters, possibly emulated via null_terminating_iterator, representing
 //     format specifiers.
-template <typename Iterator, typename SpecHandler>
-FMT_CONSTEXPR Iterator parse_format_specs(Iterator it, SpecHandler &&handler) {
-  typedef typename std::iterator_traits<Iterator>::value_type char_type;
-  char_type c = *it;
-  if (c == '}' || !c)
-    return it;
-
-  // Parse fill and alignment.
-  alignment align = ALIGN_DEFAULT;
-  int i = 1;
-  do {
-    auto p = it + i;
-    switch (*p) {
-      case '<':
-        align = ALIGN_LEFT;
-        break;
-      case '>':
-        align = ALIGN_RIGHT;
-        break;
-      case '=':
-        align = ALIGN_NUMERIC;
-        break;
-      case '^':
-        align = ALIGN_CENTER;
-        break;
-    }
-    if (align != ALIGN_DEFAULT) {
-      if (p != it) {
-        if (c == '{') {
-          handler.on_error("invalid fill character '{'");
-          return it;
-        }
-        it += 2;
-        handler.on_fill(c);
-      } else ++it;
-      handler.on_align(align);
-      break;
-    }
-  } while (--i >= 0);
-
-  // Parse sign.
-  switch (*it) {
-    case '+':
-      handler.on_plus();
-      ++it;
-      break;
-    case '-':
-      handler.on_minus();
-      ++it;
-      break;
-    case ' ':
-      handler.on_space();
-      ++it;
-      break;
-  }
-
-  if (*it == '#') {
-    handler.on_hash();
-    ++it;
-  }
-
-  // Parse zero flag.
-  if (*it == '0') {
-    handler.on_zero();
-    ++it;
-  }
-
-  // Parse width.
-  if ('0' <= *it && *it <= '9') {
-    handler.on_width(parse_nonnegative_int(it, handler));
-  } else if (*it == '{') {
-    it = parse_arg_id(it + 1, width_adapter<SpecHandler, char_type>(handler));
-    if (*it++ != '}') {
-      handler.on_error("invalid format string");
-      return it;
-    }
-  }
-
-  // Parse precision.
-  if (*it == '.') {
-    ++it;
-    if ('0' <= *it && *it <= '9') {
-      handler.on_precision(parse_nonnegative_int(it, handler));
-    } else if (*it == '{') {
-      it = parse_arg_id(
-            it + 1, precision_adapter<SpecHandler, char_type>(handler));
-      if (*it++ != '}') {
-        handler.on_error("invalid format string");
+template<typename Iterator, typename SpecHandler>
+FMT_CONSTEXPR Iterator parse_format_specs(Iterator it, SpecHandler &&handler)
+{
+    typedef typename std::iterator_traits<Iterator>::value_type char_type;
+    char_type c = *it;
+    if (c == '}' || !c)
         return it;
-      }
-    } else {
-      handler.on_error("missing precision specifier");
-      return it;
-    }
-    handler.end_precision();
-  }
 
-  // Parse type.
-  if (*it != '}' && *it)
-    handler.on_type(*it++);
-  return it;
+    // Parse fill and alignment.
+    alignment align = ALIGN_DEFAULT;
+    int i = 1;
+    do
+    {
+        auto p = it + i;
+        switch (*p)
+        {
+        case '<':
+            align = ALIGN_LEFT;
+            break;
+        case '>':
+            align = ALIGN_RIGHT;
+            break;
+        case '=':
+            align = ALIGN_NUMERIC;
+            break;
+        case '^':
+            align = ALIGN_CENTER;
+            break;
+        }
+        if (align != ALIGN_DEFAULT)
+        {
+            if (p != it)
+            {
+                if (c == '{')
+                {
+                    handler.on_error("invalid fill character '{'");
+                    return it;
+                }
+                it += 2;
+                handler.on_fill(c);
+            }
+            else
+                ++it;
+            handler.on_align(align);
+            break;
+        }
+    } while (--i >= 0);
+
+    // Parse sign.
+    switch (*it)
+    {
+    case '+':
+        handler.on_plus();
+        ++it;
+        break;
+    case '-':
+        handler.on_minus();
+        ++it;
+        break;
+    case ' ':
+        handler.on_space();
+        ++it;
+        break;
+    }
+
+    if (*it == '#')
+    {
+        handler.on_hash();
+        ++it;
+    }
+
+    // Parse zero flag.
+    if (*it == '0')
+    {
+        handler.on_zero();
+        ++it;
+    }
+
+    // Parse width.
+    if ('0' <= *it && *it <= '9')
+    {
+        handler.on_width(parse_nonnegative_int(it, handler));
+    }
+    else if (*it == '{')
+    {
+        it = parse_arg_id(it + 1, width_adapter<SpecHandler, char_type>(handler));
+        if (*it++ != '}')
+        {
+            handler.on_error("invalid format string");
+            return it;
+        }
+    }
+
+    // Parse precision.
+    if (*it == '.')
+    {
+        ++it;
+        if ('0' <= *it && *it <= '9')
+        {
+            handler.on_precision(parse_nonnegative_int(it, handler));
+        }
+        else if (*it == '{')
+        {
+            it = parse_arg_id(it + 1, precision_adapter<SpecHandler, char_type>(handler));
+            if (*it++ != '}')
+            {
+                handler.on_error("invalid format string");
+                return it;
+            }
+        }
+        else
+        {
+            handler.on_error("missing precision specifier");
+            return it;
+        }
+        handler.end_precision();
+    }
+
+    // Parse type.
+    if (*it != '}' && *it)
+        handler.on_type(*it++);
+    return it;
 }
 
-template <typename Handler, typename Char>
-struct id_adapter {
-  FMT_CONSTEXPR explicit id_adapter(Handler &h): handler(h) {}
+template<typename Handler, typename Char>
+struct id_adapter
+{
+    FMT_CONSTEXPR explicit id_adapter(Handler &h)
+        : handler(h)
+    {
+    }
 
-  FMT_CONSTEXPR void operator()() { handler.on_arg_id(); }
-  FMT_CONSTEXPR void operator()(unsigned id) { handler.on_arg_id(id); }
-  FMT_CONSTEXPR void operator()(basic_string_view<Char> id) {
-    handler.on_arg_id(id);
-  }
+    FMT_CONSTEXPR void operator()()
+    {
+        handler.on_arg_id();
+    }
+    FMT_CONSTEXPR void operator()(unsigned id)
+    {
+        handler.on_arg_id(id);
+    }
+    FMT_CONSTEXPR void operator()(basic_string_view<Char> id)
+    {
+        handler.on_arg_id(id);
+    }
 
-  FMT_CONSTEXPR void on_error(const char *message) {
-    handler.on_error(message);
-  }
+    FMT_CONSTEXPR void on_error(const char *message)
+    {
+        handler.on_error(message);
+    }
 
-  Handler &handler;
+    Handler &handler;
 };
 
-template <typename Iterator, typename Handler>
-FMT_CONSTEXPR void parse_format_string(Iterator it, Handler &&handler) {
-  typedef typename std::iterator_traits<Iterator>::value_type char_type;
-  auto start = it;
-  while (*it) {
-    char_type ch = *it++;
-    if (ch != '{' && ch != '}') continue;
-    if (*it == ch) {
-      handler.on_text(start, it);
-      start = ++it;
-      continue;
-    }
-    if (ch == '}') {
-      handler.on_error("unmatched '}' in format string");
-      return;
-    }
-    handler.on_text(start, it - 1);
+template<typename Iterator, typename Handler>
+FMT_CONSTEXPR void parse_format_string(Iterator it, Handler &&handler)
+{
+    typedef typename std::iterator_traits<Iterator>::value_type char_type;
+    auto start = it;
+    while (*it)
+    {
+        char_type ch = *it++;
+        if (ch != '{' && ch != '}')
+            continue;
+        if (*it == ch)
+        {
+            handler.on_text(start, it);
+            start = ++it;
+            continue;
+        }
+        if (ch == '}')
+        {
+            handler.on_error("unmatched '}' in format string");
+            return;
+        }
+        handler.on_text(start, it - 1);
 
-    it = parse_arg_id(it, id_adapter<Handler, char_type>(handler));
-    if (*it == '}') {
-      handler.on_replacement_field(it);
-    } else if (*it == ':') {
-      ++it;
-      it = handler.on_format_specs(it);
-      if (*it != '}') {
-        handler.on_error("unknown format specifier");
-        return;
-      }
-    } else {
-      handler.on_error("missing '}' in format string");
-      return;
-    }
+        it = parse_arg_id(it, id_adapter<Handler, char_type>(handler));
+        if (*it == '}')
+        {
+            handler.on_replacement_field(it);
+        }
+        else if (*it == ':')
+        {
+            ++it;
+            it = handler.on_format_specs(it);
+            if (*it != '}')
+            {
+                handler.on_error("unknown format specifier");
+                return;
+            }
+        }
+        else
+        {
+            handler.on_error("missing '}' in format string");
+            return;
+        }
 
-    start = ++it;
-  }
-  handler.on_text(start, it);
+        start = ++it;
+    }
+    handler.on_text(start, it);
 }
 
-template <typename T, typename ParseContext>
-FMT_CONSTEXPR const typename ParseContext::char_type *
-    parse_format_specs(ParseContext &ctx) {
-  // GCC 7.2 requires initializer.
-  formatter<T, typename ParseContext::char_type> f{};
-  return f.parse(ctx);
+template<typename T, typename ParseContext>
+FMT_CONSTEXPR const typename ParseContext::char_type *parse_format_specs(ParseContext &ctx)
+{
+    // GCC 7.2 requires initializer.
+    formatter<T, typename ParseContext::char_type> f{};
+    return f.parse(ctx);
 }
 
-template <typename Char, typename ErrorHandler, typename... Args>
-class format_string_checker {
- public:
-  explicit FMT_CONSTEXPR format_string_checker(
-      basic_string_view<Char> format_str, ErrorHandler eh)
-    : arg_id_(-1), context_(format_str, eh),
-      parse_funcs_{&parse_format_specs<Args, parse_context_type>...} {}
+template<typename Char, typename ErrorHandler, typename... Args>
+class format_string_checker
+{
+public:
+    explicit FMT_CONSTEXPR format_string_checker(basic_string_view<Char> format_str, ErrorHandler eh)
+        : arg_id_(-1)
+        , context_(format_str, eh)
+        , parse_funcs_{&parse_format_specs<Args, parse_context_type>...}
+    {
+    }
 
-  FMT_CONSTEXPR void on_text(const Char *, const Char *) {}
+    FMT_CONSTEXPR void on_text(const Char *, const Char *) {}
 
-  FMT_CONSTEXPR void on_arg_id() {
-    arg_id_ = context_.next_arg_id();
-    check_arg_id();
-  }
-  FMT_CONSTEXPR void on_arg_id(unsigned id) {
-    arg_id_ = id;
-    context_.check_arg_id(id);
-    check_arg_id();
-  }
-  FMT_CONSTEXPR void on_arg_id(basic_string_view<Char>) {}
+    FMT_CONSTEXPR void on_arg_id()
+    {
+        arg_id_ = context_.next_arg_id();
+        check_arg_id();
+    }
+    FMT_CONSTEXPR void on_arg_id(unsigned id)
+    {
+        arg_id_ = id;
+        context_.check_arg_id(id);
+        check_arg_id();
+    }
+    FMT_CONSTEXPR void on_arg_id(basic_string_view<Char>) {}
 
-  FMT_CONSTEXPR void on_replacement_field(const Char *) {}
+    FMT_CONSTEXPR void on_replacement_field(const Char *) {}
 
-  FMT_CONSTEXPR const Char *on_format_specs(const Char *s) {
-    context_.advance_to(s);
-    return to_unsigned(arg_id_) < NUM_ARGS ?
-          parse_funcs_[arg_id_](context_) : s;
-  }
+    FMT_CONSTEXPR const Char *on_format_specs(const Char *s)
+    {
+        context_.advance_to(s);
+        return to_unsigned(arg_id_) < NUM_ARGS ? parse_funcs_[arg_id_](context_) : s;
+    }
 
-  FMT_CONSTEXPR void on_error(const char *message) {
-    context_.on_error(message);
-  }
+    FMT_CONSTEXPR void on_error(const char *message)
+    {
+        context_.on_error(message);
+    }
 
- private:
-  typedef basic_parse_context<Char, ErrorHandler> parse_context_type;
-  enum { NUM_ARGS = sizeof...(Args) };
+private:
+    typedef basic_parse_context<Char, ErrorHandler> parse_context_type;
+    enum
+    {
+        NUM_ARGS = sizeof...(Args)
+    };
 
-  FMT_CONSTEXPR void check_arg_id() {
-    if (internal::to_unsigned(arg_id_) >= NUM_ARGS)
-      context_.on_error("argument index out of range");
-  }
+    FMT_CONSTEXPR void check_arg_id()
+    {
+        if (internal::to_unsigned(arg_id_) >= NUM_ARGS)
+            context_.on_error("argument index out of range");
+    }
 
-  // Format specifier parsing function.
-  typedef const Char *(*parse_func)(parse_context_type &);
+    // Format specifier parsing function.
+    typedef const Char *(*parse_func)(parse_context_type &);
 
-  int arg_id_;
-  parse_context_type context_;
-  parse_func parse_funcs_[NUM_ARGS > 0 ? NUM_ARGS : 1];
+    int arg_id_;
+    parse_context_type context_;
+    parse_func parse_funcs_[NUM_ARGS > 0 ? NUM_ARGS : 1];
 };
 
-template <typename Char, typename ErrorHandler, typename... Args>
-FMT_CONSTEXPR bool check_format_string(
-    basic_string_view<Char> s, ErrorHandler eh = ErrorHandler()) {
-  format_string_checker<Char, ErrorHandler, Args...> checker(s, eh);
-  parse_format_string(s.begin(), checker);
-  return true;
+template<typename Char, typename ErrorHandler, typename... Args>
+FMT_CONSTEXPR bool check_format_string(basic_string_view<Char> s, ErrorHandler eh = ErrorHandler())
+{
+    format_string_checker<Char, ErrorHandler, Args...> checker(s, eh);
+    parse_format_string(s.begin(), checker);
+    return true;
 }
 
-template <typename... Args, typename String>
-void check_format_string(String format_str) {
-  FMT_CONSTEXPR_DECL bool invalid_format =
-      internal::check_format_string<char, internal::error_handler, Args...>(
-        string_view(format_str.data(), format_str.size()));
-  (void)invalid_format;
+template<typename... Args, typename String>
+void check_format_string(String format_str)
+{
+    FMT_CONSTEXPR_DECL bool invalid_format =
+        internal::check_format_string<char, internal::error_handler, Args...>(string_view(format_str.data(), format_str.size()));
+    (void)invalid_format;
 }
 
 // Specifies whether to format T using the standard formatter.
 // It is not possible to use get_type in formatter specialization directly
 // because of a bug in MSVC.
-template <typename Context, typename T>
-struct format_type :
-  std::integral_constant<bool, get_type<Context, T>::value != custom_type> {};
+template<typename Context, typename T>
+struct format_type : std::integral_constant<bool, get_type<Context, T>::value != custom_type>
+{
+};
 
 // Specifies whether to format enums.
-template <typename T, typename Enable = void>
-struct format_enum : std::integral_constant<bool, std::is_enum<T>::value> {};
+template<typename T, typename Enable = void>
+struct format_enum : std::integral_constant<bool, std::is_enum<T>::value>
+{
+};
 
-template <template <typename> class Handler, typename Spec, typename Context>
-void handle_dynamic_spec(
-    Spec &value, arg_ref<typename Context::char_type> ref, Context &ctx) {
-  typedef typename Context::char_type char_type;
-  switch (ref.kind) {
-  case arg_ref<char_type>::NONE:
-    break;
-  case arg_ref<char_type>::INDEX:
-    internal::set_dynamic_spec<Handler>(
-          value, ctx.get_arg(ref.index), ctx.error_handler());
-    break;
-  case arg_ref<char_type>::NAME:
-    internal::set_dynamic_spec<Handler>(
-          value, ctx.get_arg(ref.name), ctx.error_handler());
-    break;
-  }
+template<template<typename> class Handler, typename Spec, typename Context>
+void handle_dynamic_spec(Spec &value, arg_ref<typename Context::char_type> ref, Context &ctx)
+{
+    typedef typename Context::char_type char_type;
+    switch (ref.kind)
+    {
+    case arg_ref<char_type>::NONE:
+        break;
+    case arg_ref<char_type>::INDEX:
+        internal::set_dynamic_spec<Handler>(value, ctx.get_arg(ref.index), ctx.error_handler());
+        break;
+    case arg_ref<char_type>::NAME:
+        internal::set_dynamic_spec<Handler>(value, ctx.get_arg(ref.name), ctx.error_handler());
+        break;
+    }
 }
-}  // namespace internal
+} // namespace internal
 
 /** The default argument formatter. */
-template <typename Range>
-class arg_formatter:
-  public internal::function<
-    typename internal::arg_formatter_base<Range>::iterator>,
-  public internal::arg_formatter_base<Range> {
- private:
-  typedef typename Range::value_type char_type;
-  typedef internal::arg_formatter_base<Range> base;
-  typedef basic_format_context<typename base::iterator, char_type> context_type;
+template<typename Range>
+class arg_formatter : public internal::function<typename internal::arg_formatter_base<Range>::iterator>,
+                      public internal::arg_formatter_base<Range>
+{
+private:
+    typedef typename Range::value_type char_type;
+    typedef internal::arg_formatter_base<Range> base;
+    typedef basic_format_context<typename base::iterator, char_type> context_type;
 
-  context_type &ctx_;
+    context_type &ctx_;
 
- public:
-  typedef Range range;
-  typedef typename base::iterator iterator;
-  typedef typename base::format_specs format_specs;
+public:
+    typedef Range range;
+    typedef typename base::iterator iterator;
+    typedef typename base::format_specs format_specs;
 
-  /**
-    \rst
-    Constructs an argument formatter object.
-    *ctx* is a reference to the formatting context,
-    *spec* contains format specifier information for standard argument types.
-    \endrst
-   */
-  arg_formatter(context_type &ctx, format_specs &spec)
-  : base(Range(ctx.out()), spec), ctx_(ctx) {}
+    /**
+      \rst
+      Constructs an argument formatter object.
+      *ctx* is a reference to the formatting context,
+      *spec* contains format specifier information for standard argument types.
+      \endrst
+     */
+    arg_formatter(context_type &ctx, format_specs &spec)
+        : base(Range(ctx.out()), spec)
+        , ctx_(ctx)
+    {
+    }
 
-  using base::operator();
+    using base::operator();
 
-  /** Formats an argument of a user-defined type. */
-  iterator operator()(typename basic_format_arg<context_type>::handle handle) {
-    handle.format(ctx_);
-    return this->out();
-  }
+    /** Formats an argument of a user-defined type. */
+    iterator operator()(typename basic_format_arg<context_type>::handle handle)
+    {
+        handle.format(ctx_);
+        return this->out();
+    }
 };
 
 /**
  An error returned by an operating system or a language runtime,
  for example a file opening error.
 */
-class system_error : public std::runtime_error {
- private:
-  FMT_API void init(int err_code, string_view format_str, format_args args);
+class system_error : public std::runtime_error
+{
+private:
+    FMT_API void init(int err_code, string_view format_str, format_args args);
 
- protected:
-  int error_code_;
+protected:
+    int error_code_;
 
-  system_error() : std::runtime_error("") {}
+    system_error()
+        : std::runtime_error("")
+    {
+    }
 
- public:
-  /**
-   \rst
-   Constructs a :class:`fmt::system_error` object with a description
-   formatted with `fmt::format_system_error`. *message* and additional
-   arguments passed into the constructor are formatted similarly to
-   `fmt::format`.
+public:
+    /**
+     \rst
+     Constructs a :class:`fmt::system_error` object with a description
+     formatted with `fmt::format_system_error`. *message* and additional
+     arguments passed into the constructor are formatted similarly to
+     `fmt::format`.
 
-   **Example**::
+     **Example**::
 
-     // This throws a system_error 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::system_error(errno, "cannot open file '{}'", filename);
-   \endrst
-  */
-  template <typename... Args>
-  system_error(int error_code, string_view message, const Args & ... args)
-    : std::runtime_error("") {
-    init(error_code, message, make_format_args(args...));
-  }
+       // This throws a system_error 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::system_error(errno, "cannot open file '{}'", filename);
+     \endrst
+    */
+    template<typename... Args>
+    system_error(int error_code, string_view message, const Args &... args)
+        : std::runtime_error("")
+    {
+        init(error_code, message, make_format_args(args...));
+    }
 
-  int error_code() const { return error_code_; }
+    int error_code() const
+    {
+        return error_code_;
+    }
 };
 
 /**
@@ -2374,838 +2946,976 @@ class system_error : public std::runtime_error {
   may look like "Unknown error -1" and is platform-dependent.
   \endrst
  */
-FMT_API void format_system_error(internal::buffer &out, int error_code,
-                                 fmt::string_view message) FMT_NOEXCEPT;
+FMT_API void format_system_error(internal::buffer &out, int error_code, fmt::string_view message) FMT_NOEXCEPT;
 
 /**
   This template provides operations for formatting and writing data into a
   character range.
  */
-template <typename Range>
-class basic_writer {
- public:
-  typedef typename Range::value_type char_type;
-  typedef decltype(internal::declval<Range>().begin()) iterator;
-  typedef basic_format_specs<char_type> format_specs;
+template<typename Range>
+class basic_writer
+{
+public:
+    typedef typename Range::value_type char_type;
+    typedef decltype(internal::declval<Range>().begin()) iterator;
+    typedef basic_format_specs<char_type> format_specs;
 
- private:
-  // Output iterator.
-  iterator out_;
+private:
+    // Output iterator.
+    iterator out_;
 
-  std::unique_ptr<locale_provider> locale_;
+    std::unique_ptr<locale_provider> locale_;
 
-  FMT_DISALLOW_COPY_AND_ASSIGN(basic_writer);
+    FMT_DISALLOW_COPY_AND_ASSIGN(basic_writer);
 
-  iterator out() const { return out_; }
-
-  // Attempts to reserve space for n extra characters in the output range.
-  // Returns a pointer to the reserved range or a reference to out_.
-  auto reserve(std::size_t n) -> decltype(internal::reserve(out_, n)) {
-    return internal::reserve(out_, n);
-  }
-
-  // Writes a value in the format
-  //   <left-padding><value><right-padding>
-  // where <value> is written by f(it).
-  template <typename F>
-  void write_padded(std::size_t size, const align_spec &spec, F f);
-
-  template <typename F>
-  struct padded_int_writer {
-    string_view prefix;
-    char_type fill;
-    std::size_t padding;
-    F f;
-
-    template <typename It>
-    void operator()(It &&it) const {
-      if (prefix.size() != 0)
-        it = std::copy_n(prefix.data(), prefix.size(), it);
-      it = std::fill_n(it, padding, fill);
-      f(it);
+    iterator out() const
+    {
+        return out_;
     }
-  };
 
-  // Writes an integer in the format
-  //   <left-padding><prefix><numeric-padding><digits><right-padding>
-  // where <digits> are written by f(it).
-  template <typename Spec, typename F>
-  void write_int(unsigned num_digits, string_view prefix,
-                 const Spec &spec, F f) {
-    std::size_t size = prefix.size() + num_digits;
+    // Attempts to reserve space for n extra characters in the output range.
+    // Returns a pointer to the reserved range or a reference to out_.
+    auto reserve(std::size_t n) -> decltype(internal::reserve(out_, n))
+    {
+        return internal::reserve(out_, n);
+    }
+
+    // Writes a value in the format
+    //   <left-padding><value><right-padding>
+    // where <value> is written by f(it).
+    template<typename F>
+    void write_padded(std::size_t size, const align_spec &spec, F f);
+
+    template<typename F>
+    struct padded_int_writer
+    {
+        string_view prefix;
+        char_type fill;
+        std::size_t padding;
+        F f;
+
+        template<typename It>
+        void operator()(It &&it) const
+        {
+            if (prefix.size() != 0)
+                it = std::copy_n(prefix.data(), prefix.size(), it);
+            it = std::fill_n(it, padding, fill);
+            f(it);
+        }
+    };
+
+    // Writes an integer in the format
+    //   <left-padding><prefix><numeric-padding><digits><right-padding>
+    // where <digits> are written by f(it).
+    template<typename Spec, typename F>
+    void write_int(unsigned num_digits, string_view prefix, const Spec &spec, F f)
+    {
+        std::size_t size = prefix.size() + num_digits;
+        char_type fill = static_cast<char_type>(spec.fill());
+        std::size_t padding = 0;
+        if (spec.align() == ALIGN_NUMERIC)
+        {
+            if (spec.width() > size)
+            {
+                padding = spec.width() - size;
+                size = spec.width();
+            }
+        }
+        else if (spec.precision() > static_cast<int>(num_digits))
+        {
+            size = prefix.size() + static_cast<std::size_t>(spec.precision());
+            padding = static_cast<std::size_t>(spec.precision()) - num_digits;
+            fill = '0';
+        }
+        align_spec as = spec;
+        if (spec.align() == ALIGN_DEFAULT)
+            as.align_ = ALIGN_RIGHT;
+        write_padded(size, as, padded_int_writer<F>{prefix, fill, padding, f});
+    }
+
+    // Writes a decimal integer.
+    template<typename Int>
+    void write_decimal(Int value)
+    {
+        typedef typename internal::int_traits<Int>::main_type main_type;
+        main_type abs_value = static_cast<main_type>(value);
+        bool is_negative = internal::is_negative(value);
+        if (is_negative)
+            abs_value = 0 - abs_value;
+        unsigned num_digits = internal::count_digits(abs_value);
+        auto &&it = reserve((is_negative ? 1 : 0) + num_digits);
+        if (is_negative)
+            *it++ = '-';
+        internal::format_decimal(it, abs_value, num_digits);
+    }
+
+    // The handle_int_type_spec handler that writes an integer.
+    template<typename Int, typename Spec>
+    struct int_writer
+    {
+        typedef typename internal::int_traits<Int>::main_type unsigned_type;
+
+        basic_writer<Range> &writer;
+        const Spec &spec;
+        unsigned_type abs_value;
+        char prefix[4];
+        unsigned prefix_size;
+
+        string_view get_prefix() const
+        {
+            return string_view(prefix, prefix_size);
+        }
+
+        // Counts the number of digits in abs_value. BITS = log2(radix).
+        template<unsigned BITS>
+        unsigned count_digits() const
+        {
+            unsigned_type n = abs_value;
+            unsigned num_digits = 0;
+            do
+            {
+                ++num_digits;
+            } while ((n >>= BITS) != 0);
+            return num_digits;
+        }
+
+        int_writer(basic_writer<Range> &w, Int value, const Spec &s)
+            : writer(w)
+            , spec(s)
+            , abs_value(static_cast<unsigned_type>(value))
+            , prefix_size(0)
+        {
+            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;
+            }
+        }
+
+        struct dec_writer
+        {
+            unsigned_type abs_value;
+            unsigned num_digits;
+
+            template<typename It>
+            void operator()(It &&it) const
+            {
+                it = internal::format_decimal(it, abs_value, num_digits);
+            }
+        };
+
+        void on_dec()
+        {
+            unsigned num_digits = internal::count_digits(abs_value);
+            writer.write_int(num_digits, get_prefix(), spec, dec_writer{abs_value, num_digits});
+        }
+
+        struct hex_writer
+        {
+            int_writer &self;
+            unsigned num_digits;
+
+            template<typename It>
+            void operator()(It &&it) const
+            {
+                it = internal::format_uint<4>(it, self.abs_value, num_digits, self.spec.type() != 'x');
+            }
+        };
+
+        void on_hex()
+        {
+            if (spec.flag(HASH_FLAG))
+            {
+                prefix[prefix_size++] = '0';
+                prefix[prefix_size++] = static_cast<char>(spec.type());
+            }
+            unsigned num_digits = count_digits<4>();
+            writer.write_int(num_digits, get_prefix(), spec, hex_writer{*this, num_digits});
+        }
+
+        template<int BITS>
+        struct bin_writer
+        {
+            unsigned_type abs_value;
+            unsigned num_digits;
+
+            template<typename It>
+            void operator()(It &&it) const
+            {
+                it = internal::format_uint<BITS>(it, abs_value, num_digits);
+            }
+        };
+
+        void on_bin()
+        {
+            if (spec.flag(HASH_FLAG))
+            {
+                prefix[prefix_size++] = '0';
+                prefix[prefix_size++] = static_cast<char>(spec.type());
+            }
+            unsigned num_digits = count_digits<1>();
+            writer.write_int(num_digits, get_prefix(), spec, bin_writer<1>{abs_value, num_digits});
+        }
+
+        void on_oct()
+        {
+            unsigned num_digits = count_digits<3>();
+            if (spec.flag(HASH_FLAG) && spec.precision() <= static_cast<int>(num_digits))
+            {
+                // Octal prefix '0' is counted as a digit, so only add it if precision
+                // is not greater than the number of digits.
+                prefix[prefix_size++] = '0';
+            }
+            writer.write_int(num_digits, get_prefix(), spec, bin_writer<3>{abs_value, num_digits});
+        }
+
+        enum
+        {
+            SEP_SIZE = 1
+        };
+
+        struct num_writer
+        {
+            unsigned_type abs_value;
+            unsigned size;
+            char_type sep;
+
+            template<typename It>
+            void operator()(It &&it) const
+            {
+                basic_string_view<char_type> s(&sep, SEP_SIZE);
+                it = format_decimal(it, abs_value, size, internal::add_thousands_sep<char_type>(s));
+            }
+        };
+
+        void on_num()
+        {
+            unsigned num_digits = internal::count_digits(abs_value);
+            char_type sep = internal::thousands_sep<char_type>(writer.locale_.get());
+            unsigned size = num_digits + SEP_SIZE * ((num_digits - 1) / 3);
+            writer.write_int(size, get_prefix(), spec, num_writer{abs_value, size, sep});
+        }
+
+        void on_error()
+        {
+            FMT_THROW(format_error("invalid type specifier"));
+        }
+    };
+
+    // Writes a formatted integer.
+    template<typename T, typename Spec>
+    void write_int(T value, const Spec &spec)
+    {
+        internal::handle_int_type_spec(spec.type(), int_writer<T, Spec>(*this, value, spec));
+    }
+
+    enum
+    {
+        INF_SIZE = 3
+    }; // This is an enum to workaround a bug in MSVC.
+
+    struct inf_or_nan_writer
+    {
+        char sign;
+        const char *str;
+
+        template<typename It>
+        void operator()(It &&it) const
+        {
+            if (sign)
+                *it++ = sign;
+            it = std::copy_n(str, static_cast<std::size_t>(INF_SIZE), it);
+        }
+    };
+
+    struct double_writer
+    {
+        size_t n;
+        char sign;
+        basic_memory_buffer<char_type> &buffer;
+
+        template<typename It>
+        void operator()(It &&it)
+        {
+            if (sign)
+            {
+                *it++ = sign;
+                --n;
+            }
+            it = std::copy_n(buffer.begin(), n, it);
+        }
+    };
+
+    // Formats a floating-point number (double or long double).
+    template<typename T>
+    void write_double(T value, const format_specs &spec);
+    template<typename T>
+    void write_double_sprintf(T value, const format_specs &spec, internal::basic_buffer<char_type> &buffer);
+
+    template<typename Char>
+    struct str_writer
+    {
+        const Char *s;
+        std::size_t size;
+
+        template<typename It>
+        void operator()(It &&it) const
+        {
+            it = std::copy_n(s, size, it);
+        }
+    };
+
+    // Writes a formatted string.
+    template<typename Char>
+    void write_str(const Char *s, std::size_t size, const align_spec &spec)
+    {
+        write_padded(size, spec, str_writer<Char>{s, size});
+    }
+
+    template<typename Char>
+    void write_str(basic_string_view<Char> str, const format_specs &spec);
+
+    // Appends floating-point length specifier to the format string.
+    // The second argument is only used for overload resolution.
+    void append_float_length(char_type *&format_ptr, long double)
+    {
+        *format_ptr++ = 'L';
+    }
+
+    template<typename T>
+    void append_float_length(char_type *&, T)
+    {
+    }
+
+    template<typename Char>
+    friend class internal::arg_formatter_base;
+
+public:
+    /** Constructs a ``basic_writer`` object. */
+    explicit basic_writer(Range out)
+        : out_(out.begin())
+    {
+    }
+
+    void write(int value)
+    {
+        write_decimal(value);
+    }
+    void write(long value)
+    {
+        write_decimal(value);
+    }
+    void write(long long value)
+    {
+        write_decimal(value);
+    }
+
+    void write(unsigned value)
+    {
+        write_decimal(value);
+    }
+    void write(unsigned long value)
+    {
+        write_decimal(value);
+    }
+    void write(unsigned long long value)
+    {
+        write_decimal(value);
+    }
+
+    /**
+      \rst
+      Formats *value* and writes it to the buffer.
+      \endrst
+     */
+    template<typename T, typename FormatSpec, typename... FormatSpecs>
+    typename std::enable_if<std::is_integral<T>::value, void>::type write(T value, FormatSpec spec, FormatSpecs... specs)
+    {
+        format_specs s(spec, specs...);
+        s.align_ = ALIGN_RIGHT;
+        write_int(value, s);
+    }
+
+    void write(double value)
+    {
+        write_double(value, format_specs());
+    }
+
+    /**
+      \rst
+      Formats *value* using the general format for floating-point numbers
+      (``'g'``) and writes it to the buffer.
+      \endrst
+     */
+    void write(long double value)
+    {
+        write_double(value, format_specs());
+    }
+
+    /** Writes a character to the buffer. */
+    void write(char value)
+    {
+        *reserve(1) = value;
+    }
+
+    void write(wchar_t value)
+    {
+        internal::require_wchar<char_type>();
+        *reserve(1) = value;
+    }
+
+    /**
+      \rst
+      Writes *value* to the buffer.
+      \endrst
+     */
+    void write(string_view value)
+    {
+        auto &&it = reserve(value.size());
+        it = std::copy(value.begin(), value.end(), it);
+    }
+
+    void write(wstring_view value)
+    {
+        internal::require_wchar<char_type>();
+        auto &&it = reserve(value.size());
+        it = std::uninitialized_copy(value.begin(), value.end(), it);
+    }
+
+    template<typename... FormatSpecs>
+    void write(basic_string_view<char_type> str, FormatSpecs... specs)
+    {
+        write_str(str, format_specs(specs...));
+    }
+
+    template<typename T>
+    typename std::enable_if<std::is_same<T, void>::value>::type write(const T *p)
+    {
+        format_specs specs;
+        specs.flags_ = HASH_FLAG;
+        specs.type_ = 'x';
+        write_int(reinterpret_cast<uintptr_t>(p), specs);
+    }
+};
+
+template<typename Range>
+template<typename F>
+void basic_writer<Range>::write_padded(std::size_t size, const align_spec &spec, F f)
+{
+    unsigned width = spec.width();
+    if (width <= size)
+        return f(reserve(size));
+    auto &&it = reserve(width);
     char_type fill = static_cast<char_type>(spec.fill());
-    std::size_t padding = 0;
-    if (spec.align() == ALIGN_NUMERIC) {
-      if (spec.width() > size) {
-        padding = spec.width() - size;
-        size = spec.width();
-      }
-    } else if (spec.precision() > static_cast<int>(num_digits)) {
-      size = prefix.size() + static_cast<std::size_t>(spec.precision());
-      padding = static_cast<std::size_t>(spec.precision()) - num_digits;
-      fill = '0';
+    std::size_t padding = width - size;
+    if (spec.align() == ALIGN_RIGHT)
+    {
+        it = std::fill_n(it, padding, fill);
+        f(it);
     }
-    align_spec as = spec;
-    if (spec.align() == ALIGN_DEFAULT)
-      as.align_ = ALIGN_RIGHT;
-    write_padded(size, as, padded_int_writer<F>{prefix, fill, padding, f});
-  }
-
-  // Writes a decimal integer.
-  template <typename Int>
-  void write_decimal(Int value) {
-    typedef typename internal::int_traits<Int>::main_type main_type;
-    main_type abs_value = static_cast<main_type>(value);
-    bool is_negative = internal::is_negative(value);
-    if (is_negative)
-      abs_value = 0 - abs_value;
-    unsigned num_digits = internal::count_digits(abs_value);
-    auto &&it = reserve((is_negative ? 1 : 0) + num_digits);
-    if (is_negative)
-      *it++ = '-';
-    internal::format_decimal(it, abs_value, num_digits);
-  }
-
-  // The handle_int_type_spec handler that writes an integer.
-  template <typename Int, typename Spec>
-  struct int_writer {
-    typedef typename internal::int_traits<Int>::main_type unsigned_type;
-
-    basic_writer<Range> &writer;
-    const Spec &spec;
-    unsigned_type abs_value;
-    char prefix[4];
-    unsigned prefix_size;
-
-    string_view get_prefix() const { return string_view(prefix, prefix_size); }
-
-    // Counts the number of digits in abs_value. BITS = log2(radix).
-    template <unsigned BITS>
-    unsigned count_digits() const {
-      unsigned_type n = abs_value;
-      unsigned num_digits = 0;
-      do {
-        ++num_digits;
-      } while ((n >>= BITS) != 0);
-      return num_digits;
+    else if (spec.align() == ALIGN_CENTER)
+    {
+        std::size_t left_padding = padding / 2;
+        it = std::fill_n(it, left_padding, fill);
+        f(it);
+        it = std::fill_n(it, padding - left_padding, fill);
     }
-
-    int_writer(basic_writer<Range> &w, Int value, const Spec &s)
-      : writer(w), spec(s), abs_value(static_cast<unsigned_type>(value)),
-        prefix_size(0) {
-      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;
-      }
-    }
-
-    struct dec_writer {
-      unsigned_type abs_value;
-      unsigned num_digits;
-
-      template <typename It>
-      void operator()(It &&it) const {
-        it = internal::format_decimal(it, abs_value, num_digits);
-      }
-    };
-
-    void on_dec() {
-      unsigned num_digits = internal::count_digits(abs_value);
-      writer.write_int(num_digits, get_prefix(), spec,
-                       dec_writer{abs_value, num_digits});
-    }
-
-    struct hex_writer {
-      int_writer &self;
-      unsigned num_digits;
-
-      template <typename It>
-      void operator()(It &&it) const {
-        it = internal::format_uint<4>(it, self.abs_value, num_digits,
-                                      self.spec.type() != 'x');
-      }
-    };
-
-    void on_hex() {
-      if (spec.flag(HASH_FLAG)) {
-        prefix[prefix_size++] = '0';
-        prefix[prefix_size++] = static_cast<char>(spec.type());
-      }
-      unsigned num_digits = count_digits<4>();
-      writer.write_int(num_digits, get_prefix(), spec,
-                       hex_writer{*this, num_digits});
-    }
-
-    template <int BITS>
-    struct bin_writer {
-      unsigned_type abs_value;
-      unsigned num_digits;
-
-      template <typename It>
-      void operator()(It &&it) const {
-        it = internal::format_uint<BITS>(it, abs_value, num_digits);
-      }
-    };
-
-    void on_bin() {
-      if (spec.flag(HASH_FLAG)) {
-        prefix[prefix_size++] = '0';
-        prefix[prefix_size++] = static_cast<char>(spec.type());
-      }
-      unsigned num_digits = count_digits<1>();
-      writer.write_int(num_digits, get_prefix(), spec,
-                       bin_writer<1>{abs_value, num_digits});
-    }
-
-    void on_oct() {
-      unsigned num_digits = count_digits<3>();
-      if (spec.flag(HASH_FLAG) &&
-          spec.precision() <= static_cast<int>(num_digits)) {
-        // Octal prefix '0' is counted as a digit, so only add it if precision
-        // is not greater than the number of digits.
-        prefix[prefix_size++] = '0';
-      }
-      writer.write_int(num_digits, get_prefix(), spec,
-                       bin_writer<3>{abs_value, num_digits});
-    }
-
-    enum { SEP_SIZE = 1 };
-
-    struct num_writer {
-      unsigned_type abs_value;
-      unsigned size;
-      char_type sep;
-
-      template <typename It>
-      void operator()(It &&it) const {
-        basic_string_view<char_type> s(&sep, SEP_SIZE);
-        it = format_decimal(it, abs_value, size,
-                            internal::add_thousands_sep<char_type>(s));
-      }
-    };
-
-    void on_num() {
-      unsigned num_digits = internal::count_digits(abs_value);
-      char_type sep = internal::thousands_sep<char_type>(writer.locale_.get());
-      unsigned size = num_digits + SEP_SIZE * ((num_digits - 1) / 3);
-      writer.write_int(size, get_prefix(), spec,
-                       num_writer{abs_value, size, sep});
-    }
-
-    void on_error() {
-      FMT_THROW(format_error("invalid type specifier"));
-    }
-  };
-
-  // Writes a formatted integer.
-  template <typename T, typename Spec>
-  void write_int(T value, const Spec &spec) {
-    internal::handle_int_type_spec(spec.type(),
-                                   int_writer<T, Spec>(*this, value, spec));
-  }
-
-  enum {INF_SIZE = 3}; // This is an enum to workaround a bug in MSVC.
-
-  struct inf_or_nan_writer {
-    char sign;
-    const char *str;
-
-    template <typename It>
-    void operator()(It &&it) const {
-      if (sign)
-        *it++ = sign;
-      it = std::copy_n(str, static_cast<std::size_t>(INF_SIZE), it);
-    }
-  };
-
-  struct double_writer {
-    size_t n;
-    char sign;
-    basic_memory_buffer<char_type> &buffer;
-
-    template <typename It>
-    void operator()(It &&it) {
-      if (sign) {
-        *it++ = sign;
-        --n;
-      }
-      it = std::copy_n(buffer.begin(), n, it);
-    }
-  };
-
-  // Formats a floating-point number (double or long double).
-  template <typename T>
-  void write_double(T value, const format_specs &spec);
-  template <typename T>
-  void write_double_sprintf(T value, const format_specs &spec,
-                            internal::basic_buffer<char_type>& buffer);
-
-  template <typename Char>
-  struct str_writer {
-    const Char *s;
-    std::size_t size;
-
-    template <typename It>
-    void operator()(It &&it) const {
-      it = std::copy_n(s, size, it);
-    }
-  };
-
-  // Writes a formatted string.
-  template <typename Char>
-  void write_str(const Char *s, std::size_t size, const align_spec &spec) {
-    write_padded(size, spec, str_writer<Char>{s, size});
-  }
-
-  template <typename Char>
-  void write_str(basic_string_view<Char> str, const format_specs &spec);
-
-  // Appends floating-point length specifier to the format string.
-  // The second argument is only used for overload resolution.
-  void append_float_length(char_type *&format_ptr, long double) {
-    *format_ptr++ = 'L';
-  }
-
-  template<typename T>
-  void append_float_length(char_type *&, T) {}
-
-  template <typename Char>
-  friend class internal::arg_formatter_base;
-
- public:
-  /** Constructs a ``basic_writer`` object. */
-  explicit basic_writer(Range out): out_(out.begin()) {}
-
-  void write(int value) { write_decimal(value); }
-  void write(long value) { write_decimal(value); }
-  void write(long long value) { write_decimal(value); }
-
-  void write(unsigned value) { write_decimal(value); }
-  void write(unsigned long value) { write_decimal(value); }
-  void write(unsigned long long value) { write_decimal(value); }
-
-  /**
-    \rst
-    Formats *value* and writes it to the buffer.
-    \endrst
-   */
-  template <typename T, typename FormatSpec, typename... FormatSpecs>
-  typename std::enable_if<std::is_integral<T>::value, void>::type
-      write(T value, FormatSpec spec, FormatSpecs... specs) {
-    format_specs s(spec, specs...);
-    s.align_ = ALIGN_RIGHT;
-    write_int(value, s);
-  }
-
-  void write(double value) {
-    write_double(value, format_specs());
-  }
-
-  /**
-    \rst
-    Formats *value* using the general format for floating-point numbers
-    (``'g'``) and writes it to the buffer.
-    \endrst
-   */
-  void write(long double value) {
-    write_double(value, format_specs());
-  }
-
-  /** Writes a character to the buffer. */
-  void write(char value) {
-    *reserve(1) = value;
-  }
-
-  void write(wchar_t value) {
-    internal::require_wchar<char_type>();
-    *reserve(1) = value;
-  }
-
-  /**
-    \rst
-    Writes *value* to the buffer.
-    \endrst
-   */
-  void write(string_view value) {
-    auto &&it = reserve(value.size());
-    it = std::copy(value.begin(), value.end(), it);
-  }
-
-  void write(wstring_view value) {
-    internal::require_wchar<char_type>();
-    auto &&it = reserve(value.size());
-    it = std::uninitialized_copy(value.begin(), value.end(), it);
-  }
-
-  template <typename... FormatSpecs>
-  void write(basic_string_view<char_type> str, FormatSpecs... specs) {
-    write_str(str, format_specs(specs...));
-  }
-
-  template <typename T>
-  typename std::enable_if<std::is_same<T, void>::value>::type write(const T* p) {
-    format_specs specs;
-    specs.flags_ = HASH_FLAG;
-    specs.type_ = 'x';
-    write_int(reinterpret_cast<uintptr_t>(p), specs);
-  }
-};
-
-template <typename Range>
-template <typename F>
-void basic_writer<Range>::write_padded(
-    std::size_t size, const align_spec &spec, F f) {
-  unsigned width = spec.width();
-  if (width <= size)
-    return f(reserve(size));
-  auto &&it = reserve(width);
-  char_type fill = static_cast<char_type>(spec.fill());
-  std::size_t padding = width - size;
-  if (spec.align() == ALIGN_RIGHT) {
-    it = std::fill_n(it, padding, fill);
-    f(it);
-  } else if (spec.align() == ALIGN_CENTER) {
-    std::size_t left_padding = padding / 2;
-    it = std::fill_n(it, left_padding, fill);
-    f(it);
-    it = std::fill_n(it, padding - left_padding, fill);
-  } else {
-    f(it);
-    it = std::fill_n(it, padding, fill);
-  }
-}
-
-template <typename Range>
-template <typename Char>
-void basic_writer<Range>::write_str(
-    basic_string_view<Char> s, const format_specs &spec) {
-  const Char *data = s.data();
-  std::size_t size = s.size();
-  std::size_t precision = static_cast<std::size_t>(spec.precision_);
-  if (spec.precision_ >= 0 && precision < size)
-    size = precision;
-  write_str(data, size, spec);
-}
-
-template <typename Char>
-struct float_spec_handler {
-  Char type;
-  bool upper;
-
-  explicit float_spec_handler(Char t) : type(t), upper(false) {}
-
-  void on_general() {
-    if (type == 'G')
-      upper = true;
     else
-      type = 'g';
-  }
-
-  void on_exp() {
-    if (type == 'E')
-      upper = true;
-  }
-
-  void on_fixed() {
-    if (type == 'F') {
-      upper = true;
-#if FMT_MSC_VER
-      // MSVC's printf doesn't support 'F'.
-      type = 'f';
-#endif
+    {
+        f(it);
+        it = std::fill_n(it, padding, fill);
     }
-  }
-
-  void on_hex() {
-    if (type == 'A')
-      upper = true;
-  }
-
-  void on_error() {
-    FMT_THROW(format_error("invalid type specifier"));
-  }
-};
-
-template <typename Range>
-template <typename T>
-void basic_writer<Range>::write_double(T value, const format_specs &spec) {
-  // Check type.
-  float_spec_handler<char_type> handler(spec.type());
-  internal::handle_float_type_spec(spec.type(), handler);
-
-  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) ? '+' : ' ';
-  }
-
-  struct write_inf_or_nan_t {
-    basic_writer &writer;
-    format_specs spec;
-    char sign;
-    void operator()(const char *str) const {
-      writer.write_padded(INF_SIZE + (sign ? 1 : 0), spec,
-                          inf_or_nan_writer{sign, str});
-    }
-  } write_inf_or_nan = {*this, spec, sign};
-
-  // Format NaN and ininity ourselves because sprintf's output is not consistent
-  // across platforms.
-  if (internal::fputil::isnotanumber(value))
-    return write_inf_or_nan(handler.upper ? "NAN" : "nan");
-  if (internal::fputil::isinfinity(value))
-    return write_inf_or_nan(handler.upper ? "INF" : "inf");
-
-  basic_memory_buffer<char_type> buffer;
-  if (FMT_USE_GRISU && sizeof(T) <= sizeof(double) &&
-      std::numeric_limits<double>::is_iec559) {
-    internal::fp fp_value(static_cast<double>(value));
-    fp_value.normalize();
-    // Find a cached power of 10 close to 1 / fp_value.
-    int dec_exp = 0;
-    const int min_exp = -60;
-    auto dec_pow = internal::get_cached_power(
-        min_exp - (fp_value.e + internal::fp::significand_size), dec_exp);
-    internal::fp product = fp_value * dec_pow;
-    // Generate output.
-    internal::fp one(1ull << -product.e, product.e);
-    uint64_t hi = product.f >> -one.e;
-    uint64_t f = product.f & (one.f - 1);
-    typedef back_insert_range<internal::basic_buffer<char_type>> range;
-    basic_writer<range> w{range(buffer)};
-    w.write(hi);
-    size_t digits = buffer.size();
-    w.write('.');
-    const unsigned max_digits = 18;
-    while (digits++ < max_digits) {
-      f *= 10;
-      w.write(static_cast<char>('0' + (f >> -one.e)));
-      f &= one.f - 1;
-    }
-    w.write('e');
-    w.write(-dec_exp);
-  } else {
-    format_specs normalized_spec(spec);
-    normalized_spec.type_ = handler.type;
-    write_double_sprintf(value, normalized_spec, buffer);
-  }
-  size_t n = buffer.size();
-  align_spec as = spec;
-  if (spec.align() == ALIGN_NUMERIC) {
-    if (sign) {
-      auto &&it = reserve(1);
-      *it++ = sign;
-      sign = 0;
-      if (as.width_)
-        --as.width_;
-    }
-    as.align_ = ALIGN_RIGHT;
-  } else {
-    if (spec.align() == ALIGN_DEFAULT)
-      as.align_ = ALIGN_RIGHT;
-    if (sign)
-      ++n;
-  }
-  write_padded(n, as, double_writer{n, sign, buffer});
 }
 
-template <typename Range>
-template <typename T>
-void basic_writer<Range>::write_double_sprintf(
-    T value, const format_specs &spec,
-    internal::basic_buffer<char_type>& buffer) {
-  // Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail.
-  FMT_ASSERT(buffer.capacity() != 0, "empty buffer");
+template<typename Range>
+template<typename Char>
+void basic_writer<Range>::write_str(basic_string_view<Char> s, const format_specs &spec)
+{
+    const Char *data = s.data();
+    std::size_t size = s.size();
+    std::size_t precision = static_cast<std::size_t>(spec.precision_);
+    if (spec.precision_ >= 0 && precision < size)
+        size = precision;
+    write_str(data, size, spec);
+}
 
-  // Build format string.
-  enum { MAX_FORMAT_SIZE = 10}; // longest format: %#-*.*Lg
-  char_type format[MAX_FORMAT_SIZE];
-  char_type *format_ptr = format;
-  *format_ptr++ = '%';
-  if (spec.flag(HASH_FLAG))
-    *format_ptr++ = '#';
-  if (spec.precision() >= 0) {
-    *format_ptr++ = '.';
-    *format_ptr++ = '*';
-  }
+template<typename Char>
+struct float_spec_handler
+{
+    Char type;
+    bool upper;
 
-  append_float_length(format_ptr, value);
-  *format_ptr++ = spec.type();
-  *format_ptr = '\0';
-
-  // Format using snprintf.
-  char_type *start = FMT_NULL;
-  for (;;) {
-    std::size_t buffer_size = buffer.capacity();
-    start = &buffer[0];
-    int result = internal::char_traits<char_type>::format_float(
-        start, buffer_size, format, spec.precision(), value);
-    if (result >= 0) {
-      unsigned n = internal::to_unsigned(result);
-      if (n < buffer.capacity()) {
-        buffer.resize(n);
-        break;  // The buffer is large enough - continue with formatting.
-      }
-      buffer.reserve(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);
+    explicit float_spec_handler(Char t)
+        : type(t)
+        , upper(false)
+    {
+    }
+
+    void on_general()
+    {
+        if (type == 'G')
+            upper = true;
+        else
+            type = 'g';
+    }
+
+    void on_exp()
+    {
+        if (type == 'E')
+            upper = true;
+    }
+
+    void on_fixed()
+    {
+        if (type == 'F')
+        {
+            upper = true;
+#if FMT_MSC_VER
+            // MSVC's printf doesn't support 'F'.
+            type = 'f';
+#endif
+        }
+    }
+
+    void on_hex()
+    {
+        if (type == 'A')
+            upper = true;
+    }
+
+    void on_error()
+    {
+        FMT_THROW(format_error("invalid type specifier"));
+    }
+};
+
+template<typename Range>
+template<typename T>
+void basic_writer<Range>::write_double(T value, const format_specs &spec)
+{
+    // Check type.
+    float_spec_handler<char_type> handler(spec.type());
+    internal::handle_float_type_spec(spec.type(), handler);
+
+    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) ? '+' : ' ';
+    }
+
+    struct write_inf_or_nan_t
+    {
+        basic_writer &writer;
+        format_specs spec;
+        char sign;
+        void operator()(const char *str) const
+        {
+            writer.write_padded(INF_SIZE + (sign ? 1 : 0), spec, inf_or_nan_writer{sign, str});
+        }
+    } write_inf_or_nan = {*this, spec, sign};
+
+    // Format NaN and ininity ourselves because sprintf's output is not consistent
+    // across platforms.
+    if (internal::fputil::isnotanumber(value))
+        return write_inf_or_nan(handler.upper ? "NAN" : "nan");
+    if (internal::fputil::isinfinity(value))
+        return write_inf_or_nan(handler.upper ? "INF" : "inf");
+
+    basic_memory_buffer<char_type> buffer;
+    if (FMT_USE_GRISU && sizeof(T) <= sizeof(double) && std::numeric_limits<double>::is_iec559)
+    {
+        internal::fp fp_value(static_cast<double>(value));
+        fp_value.normalize();
+        // Find a cached power of 10 close to 1 / fp_value.
+        int dec_exp = 0;
+        const int min_exp = -60;
+        auto dec_pow = internal::get_cached_power(min_exp - (fp_value.e + internal::fp::significand_size), dec_exp);
+        internal::fp product = fp_value * dec_pow;
+        // Generate output.
+        internal::fp one(1ull << -product.e, product.e);
+        uint64_t hi = product.f >> -one.e;
+        uint64_t f = product.f & (one.f - 1);
+        typedef back_insert_range<internal::basic_buffer<char_type>> range;
+        basic_writer<range> w{range(buffer)};
+        w.write(hi);
+        size_t digits = buffer.size();
+        w.write('.');
+        const unsigned max_digits = 18;
+        while (digits++ < max_digits)
+        {
+            f *= 10;
+            w.write(static_cast<char>('0' + (f >> -one.e)));
+            f &= one.f - 1;
+        }
+        w.write('e');
+        w.write(-dec_exp);
+    }
+    else
+    {
+        format_specs normalized_spec(spec);
+        normalized_spec.type_ = handler.type;
+        write_double_sprintf(value, normalized_spec, buffer);
+    }
+    size_t n = buffer.size();
+    align_spec as = spec;
+    if (spec.align() == ALIGN_NUMERIC)
+    {
+        if (sign)
+        {
+            auto &&it = reserve(1);
+            *it++ = sign;
+            sign = 0;
+            if (as.width_)
+                --as.width_;
+        }
+        as.align_ = ALIGN_RIGHT;
+    }
+    else
+    {
+        if (spec.align() == ALIGN_DEFAULT)
+            as.align_ = ALIGN_RIGHT;
+        if (sign)
+            ++n;
+    }
+    write_padded(n, as, double_writer{n, sign, buffer});
+}
+
+template<typename Range>
+template<typename T>
+void basic_writer<Range>::write_double_sprintf(T value, const format_specs &spec, internal::basic_buffer<char_type> &buffer)
+{
+    // Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail.
+    FMT_ASSERT(buffer.capacity() != 0, "empty buffer");
+
+    // Build format string.
+    enum
+    {
+        MAX_FORMAT_SIZE = 10
+    }; // longest format: %#-*.*Lg
+    char_type format[MAX_FORMAT_SIZE];
+    char_type *format_ptr = format;
+    *format_ptr++ = '%';
+    if (spec.flag(HASH_FLAG))
+        *format_ptr++ = '#';
+    if (spec.precision() >= 0)
+    {
+        *format_ptr++ = '.';
+        *format_ptr++ = '*';
+    }
+
+    append_float_length(format_ptr, value);
+    *format_ptr++ = spec.type();
+    *format_ptr = '\0';
+
+    // Format using snprintf.
+    char_type *start = FMT_NULL;
+    for (;;)
+    {
+        std::size_t buffer_size = buffer.capacity();
+        start = &buffer[0];
+        int result = internal::char_traits<char_type>::format_float(start, buffer_size, format, spec.precision(), value);
+        if (result >= 0)
+        {
+            unsigned n = internal::to_unsigned(result);
+            if (n < buffer.capacity())
+            {
+                buffer.resize(n);
+                break; // The buffer is large enough - continue with formatting.
+            }
+            buffer.reserve(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);
+        }
     }
-  }
 }
 
 // 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,
-                                 string_view message) FMT_NOEXCEPT;
+FMT_API void report_system_error(int error_code, string_view message) FMT_NOEXCEPT;
 
 #if FMT_USE_WINDOWS_H
 
 /** A Windows error. */
-class windows_error : public system_error {
- private:
-  FMT_API void init(int error_code, string_view format_str, format_args args);
+class windows_error : public system_error
+{
+private:
+    FMT_API void init(int error_code, string_view format_str, format_args args);
 
- public:
-  /**
-   \rst
-   Constructs a :class:`fmt::windows_error` object with the description
-   of the form
+public:
+    /**
+     \rst
+     Constructs a :class:`fmt::windows_error` object with the description
+     of the form
 
-   .. parsed-literal::
-     *<message>*: *<system-message>*
+     .. 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".
+     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**::
+     **Example**::
 
-     // This throws a windows_error 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::windows_error(GetLastError(),
-                                "cannot open file '{}'", filename);
-     }
-   \endrst
-  */
-  template <typename... Args>
-  windows_error(int error_code, string_view message, const Args & ... args) {
-    init(error_code, message, make_format_args(args...));
-  }
+       // This throws a windows_error 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::windows_error(GetLastError(),
+                                  "cannot open file '{}'", filename);
+       }
+     \endrst
+    */
+    template<typename... Args>
+    windows_error(int error_code, string_view message, const Args &... args)
+    {
+        init(error_code, message, make_format_args(args...));
+    }
 };
 
 // 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,
-                                  string_view message) FMT_NOEXCEPT;
+FMT_API void report_windows_error(int error_code, string_view message) FMT_NOEXCEPT;
 
 #endif
 
 /** Fast integer formatter. */
-class format_int {
- private:
-  // Buffer should be large enough to hold all digits (digits10 + 1),
-  // a sign and a null character.
-  enum {BUFFER_SIZE = std::numeric_limits<unsigned long long>::digits10 + 3};
-  mutable char buffer_[BUFFER_SIZE];
-  char *str_;
+class format_int
+{
+private:
+    // Buffer should be large enough to hold all digits (digits10 + 1),
+    // a sign and a null character.
+    enum
+    {
+        BUFFER_SIZE = std::numeric_limits<unsigned long long>::digits10 + 3
+    };
+    mutable char buffer_[BUFFER_SIZE];
+    char *str_;
 
-  // Formats value in reverse and returns a pointer to the beginning.
-  char *format_decimal(unsigned long long value) {
-    char *ptr = 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;
-      *--ptr = internal::data::DIGITS[index + 1];
-      *--ptr = internal::data::DIGITS[index];
+    // Formats value in reverse and returns a pointer to the beginning.
+    char *format_decimal(unsigned long long value)
+    {
+        char *ptr = 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;
+            *--ptr = internal::data::DIGITS[index + 1];
+            *--ptr = internal::data::DIGITS[index];
+        }
+        if (value < 10)
+        {
+            *--ptr = static_cast<char>('0' + value);
+            return ptr;
+        }
+        unsigned index = static_cast<unsigned>(value * 2);
+        *--ptr = internal::data::DIGITS[index + 1];
+        *--ptr = internal::data::DIGITS[index];
+        return ptr;
     }
-    if (value < 10) {
-      *--ptr = static_cast<char>('0' + value);
-      return ptr;
+
+    void format_signed(long long value)
+    {
+        unsigned long long abs_value = static_cast<unsigned long long>(value);
+        bool negative = value < 0;
+        if (negative)
+            abs_value = 0 - abs_value;
+        str_ = format_decimal(abs_value);
+        if (negative)
+            *--str_ = '-';
     }
-    unsigned index = static_cast<unsigned>(value * 2);
-    *--ptr = internal::data::DIGITS[index + 1];
-    *--ptr = internal::data::DIGITS[index];
-    return ptr;
-  }
 
-  void format_signed(long long value) {
-    unsigned long long abs_value = static_cast<unsigned long long>(value);
-    bool negative = value < 0;
-    if (negative)
-      abs_value = 0 - abs_value;
-    str_ = format_decimal(abs_value);
-    if (negative)
-      *--str_ = '-';
-  }
+public:
+    explicit format_int(int value)
+    {
+        format_signed(value);
+    }
+    explicit format_int(long value)
+    {
+        format_signed(value);
+    }
+    explicit format_int(long long value)
+    {
+        format_signed(value);
+    }
+    explicit format_int(unsigned value)
+        : str_(format_decimal(value))
+    {
+    }
+    explicit format_int(unsigned long value)
+        : str_(format_decimal(value))
+    {
+    }
+    explicit format_int(unsigned long long value)
+        : str_(format_decimal(value))
+    {
+    }
 
- public:
-  explicit format_int(int value) { format_signed(value); }
-  explicit format_int(long value) { format_signed(value); }
-  explicit format_int(long long value) { format_signed(value); }
-  explicit format_int(unsigned value) : str_(format_decimal(value)) {}
-  explicit format_int(unsigned long value) : str_(format_decimal(value)) {}
-  explicit format_int(unsigned long long 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 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. 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_;
+    }
 
-  /**
-    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()); }
+    /**
+      \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::int_traits<T>::main_type main_type;
-  main_type abs_value = static_cast<main_type>(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;
+template<typename T>
+inline void format_decimal(char *&buffer, T value)
+{
+    typedef typename internal::int_traits<T>::main_type main_type;
+    main_type abs_value = static_cast<main_type>(value);
+    if (internal::is_negative(value))
+    {
+        *buffer++ = '-';
+        abs_value = 0 - abs_value;
     }
-    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;
+    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;
 }
 
 // Formatter of objects of type T.
-template <typename T, typename Char>
-struct formatter<
-    T, Char,
-    typename std::enable_if<internal::format_type<
-        typename buffer_context<Char>::type, T>::value>::type> {
+template<typename T, typename Char>
+struct formatter<T, Char, typename std::enable_if<internal::format_type<typename buffer_context<Char>::type, T>::value>::type>
+{
 
-  // Parses format specifiers stopping either at the end of the range or at the
-  // terminating '}'.
-  template <typename ParseContext>
-  FMT_CONSTEXPR typename ParseContext::iterator parse(ParseContext &ctx) {
-    auto it = internal::null_terminating_iterator<Char>(ctx);
-    typedef internal::dynamic_specs_handler<ParseContext> handler_type;
-    auto type = internal::get_type<
-      typename buffer_context<Char>::type, T>::value;
-    internal::specs_checker<handler_type>
-        handler(handler_type(specs_, ctx), type);
-    it = parse_format_specs(it, handler);
-    auto type_spec = specs_.type();
-    auto eh = ctx.error_handler();
-    switch (type) {
-    case internal::none_type:
-    case internal::named_arg_type:
-      FMT_ASSERT(false, "invalid argument type");
-      break;
-    case internal::int_type:
-    case internal::uint_type:
-    case internal::long_long_type:
-    case internal::ulong_long_type:
-    case internal::bool_type:
-      handle_int_type_spec(
-            type_spec, internal::int_type_checker<decltype(eh)>(eh));
-      break;
-    case internal::char_type:
-      handle_char_specs(
-          specs_,
-          internal::char_specs_checker<decltype(eh), decltype(type_spec)>(
-              type_spec, eh));
-      break;
-    case internal::double_type:
-    case internal::long_double_type:
-      handle_float_type_spec(
-            type_spec, internal::float_type_checker<decltype(eh)>(eh));
-      break;
-    case internal::cstring_type:
-      internal::handle_cstring_type_spec(
-            type_spec, internal::cstring_type_checker<decltype(eh)>(eh));
-      break;
-    case internal::string_type:
-      internal::check_string_type_spec(type_spec, eh);
-      break;
-    case internal::pointer_type:
-      internal::check_pointer_type_spec(type_spec, eh);
-      break;
-    case internal::custom_type:
-      // Custom format specifiers should be checked in parse functions of
-      // formatter specializations.
-      break;
+    // Parses format specifiers stopping either at the end of the range or at the
+    // terminating '}'.
+    template<typename ParseContext>
+    FMT_CONSTEXPR typename ParseContext::iterator parse(ParseContext &ctx)
+    {
+        auto it = internal::null_terminating_iterator<Char>(ctx);
+        typedef internal::dynamic_specs_handler<ParseContext> handler_type;
+        auto type = internal::get_type<typename buffer_context<Char>::type, T>::value;
+        internal::specs_checker<handler_type> handler(handler_type(specs_, ctx), type);
+        it = parse_format_specs(it, handler);
+        auto type_spec = specs_.type();
+        auto eh = ctx.error_handler();
+        switch (type)
+        {
+        case internal::none_type:
+        case internal::named_arg_type:
+            FMT_ASSERT(false, "invalid argument type");
+            break;
+        case internal::int_type:
+        case internal::uint_type:
+        case internal::long_long_type:
+        case internal::ulong_long_type:
+        case internal::bool_type:
+            handle_int_type_spec(type_spec, internal::int_type_checker<decltype(eh)>(eh));
+            break;
+        case internal::char_type:
+            handle_char_specs(specs_, internal::char_specs_checker<decltype(eh), decltype(type_spec)>(type_spec, eh));
+            break;
+        case internal::double_type:
+        case internal::long_double_type:
+            handle_float_type_spec(type_spec, internal::float_type_checker<decltype(eh)>(eh));
+            break;
+        case internal::cstring_type:
+            internal::handle_cstring_type_spec(type_spec, internal::cstring_type_checker<decltype(eh)>(eh));
+            break;
+        case internal::string_type:
+            internal::check_string_type_spec(type_spec, eh);
+            break;
+        case internal::pointer_type:
+            internal::check_pointer_type_spec(type_spec, eh);
+            break;
+        case internal::custom_type:
+            // Custom format specifiers should be checked in parse functions of
+            // formatter specializations.
+            break;
+        }
+        return pointer_from(it);
     }
-    return pointer_from(it);
-  }
 
-  template <typename FormatContext>
-  auto format(const T &val, FormatContext &ctx) -> decltype(ctx.out()) {
-    internal::handle_dynamic_spec<internal::width_checker>(
-      specs_.width_, specs_.width_ref, ctx);
-    internal::handle_dynamic_spec<internal::precision_checker>(
-      specs_.precision_, specs_.precision_ref, ctx);
-    typedef output_range<typename FormatContext::iterator,
-                         typename FormatContext::char_type> range_type;
-    return visit(arg_formatter<range_type>(ctx, specs_),
-                 internal::make_arg<FormatContext>(val));
-  }
+    template<typename FormatContext>
+    auto format(const T &val, FormatContext &ctx) -> decltype(ctx.out())
+    {
+        internal::handle_dynamic_spec<internal::width_checker>(specs_.width_, specs_.width_ref, ctx);
+        internal::handle_dynamic_spec<internal::precision_checker>(specs_.precision_, specs_.precision_ref, ctx);
+        typedef output_range<typename FormatContext::iterator, typename FormatContext::char_type> range_type;
+        return visit(arg_formatter<range_type>(ctx, specs_), internal::make_arg<FormatContext>(val));
+    }
 
- private:
-  internal::dynamic_format_specs<Char> specs_;
+private:
+    internal::dynamic_format_specs<Char> specs_;
 };
 
-template <typename T, typename Char>
-struct formatter<T, Char,
-    typename std::enable_if<internal::format_enum<T>::value>::type>
-    : public formatter<int, Char> {
-  template <typename ParseContext>
-  auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
-    return ctx.begin();
-  }
+template<typename T, typename Char>
+struct formatter<T, Char, typename std::enable_if<internal::format_enum<T>::value>::type> : public formatter<int, Char>
+{
+    template<typename ParseContext>
+    auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+    {
+        return ctx.begin();
+    }
 };
 
 // A formatter for types known only at run time such as variant alternatives.
@@ -3218,201 +3928,228 @@ struct formatter<T, Char,
 //       visit([&](const auto &val) { format(buf, val, ctx); }, v);
 //     }
 //   };
-template <typename Char = char>
-class dynamic_formatter {
- private:
-  struct null_handler: internal::error_handler {
-    void on_align(alignment) {}
-    void on_plus() {}
-    void on_minus() {}
-    void on_space() {}
-    void on_hash() {}
-  };
+template<typename Char = char>
+class dynamic_formatter
+{
+private:
+    struct null_handler : internal::error_handler
+    {
+        void on_align(alignment) {}
+        void on_plus() {}
+        void on_minus() {}
+        void on_space() {}
+        void on_hash() {}
+    };
 
- public:
-  template <typename ParseContext>
-  auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
-    auto it = internal::null_terminating_iterator<Char>(ctx);
-    // Checks are deferred to formatting time when the argument type is known.
-    internal::dynamic_specs_handler<ParseContext> handler(specs_, ctx);
-    it = parse_format_specs(it, handler);
-    return pointer_from(it);
-  }
-
-  template <typename T, typename FormatContext>
-  auto format(const T &val, FormatContext &ctx) -> decltype(ctx.out()) {
-    handle_specs(ctx);
-    internal::specs_checker<null_handler>
-        checker(null_handler(), internal::get_type<FormatContext, T>::value);
-    checker.on_align(specs_.align());
-    if (specs_.flags_ == 0) {
-      // Do nothing.
-    } else if (specs_.flag(SIGN_FLAG)) {
-      if (specs_.flag(PLUS_FLAG))
-        checker.on_plus();
-      else
-        checker.on_space();
-    } else if (specs_.flag(MINUS_FLAG)) {
-      checker.on_minus();
-    } else if (specs_.flag(HASH_FLAG)) {
-      checker.on_hash();
+public:
+    template<typename ParseContext>
+    auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+    {
+        auto it = internal::null_terminating_iterator<Char>(ctx);
+        // Checks are deferred to formatting time when the argument type is known.
+        internal::dynamic_specs_handler<ParseContext> handler(specs_, ctx);
+        it = parse_format_specs(it, handler);
+        return pointer_from(it);
     }
-    if (specs_.precision_ != -1)
-      checker.end_precision();
-    typedef output_range<typename FormatContext::iterator,
-                         typename FormatContext::char_type> range;
-    visit(arg_formatter<range>(ctx, specs_),
-          internal::make_arg<FormatContext>(val));
-    return ctx.out();
-  }
 
- private:
-  template <typename Context>
-  void handle_specs(Context &ctx) {
-    internal::handle_dynamic_spec<internal::width_checker>(
-      specs_.width_, specs_.width_ref, ctx);
-    internal::handle_dynamic_spec<internal::precision_checker>(
-      specs_.precision_, specs_.precision_ref, ctx);
-  }
+    template<typename T, typename FormatContext>
+    auto format(const T &val, FormatContext &ctx) -> decltype(ctx.out())
+    {
+        handle_specs(ctx);
+        internal::specs_checker<null_handler> checker(null_handler(), internal::get_type<FormatContext, T>::value);
+        checker.on_align(specs_.align());
+        if (specs_.flags_ == 0)
+        {
+            // Do nothing.
+        }
+        else if (specs_.flag(SIGN_FLAG))
+        {
+            if (specs_.flag(PLUS_FLAG))
+                checker.on_plus();
+            else
+                checker.on_space();
+        }
+        else if (specs_.flag(MINUS_FLAG))
+        {
+            checker.on_minus();
+        }
+        else if (specs_.flag(HASH_FLAG))
+        {
+            checker.on_hash();
+        }
+        if (specs_.precision_ != -1)
+            checker.end_precision();
+        typedef output_range<typename FormatContext::iterator, typename FormatContext::char_type> range;
+        visit(arg_formatter<range>(ctx, specs_), internal::make_arg<FormatContext>(val));
+        return ctx.out();
+    }
 
-  internal::dynamic_format_specs<Char> specs_;
+private:
+    template<typename Context>
+    void handle_specs(Context &ctx)
+    {
+        internal::handle_dynamic_spec<internal::width_checker>(specs_.width_, specs_.width_ref, ctx);
+        internal::handle_dynamic_spec<internal::precision_checker>(specs_.precision_, specs_.precision_ref, ctx);
+    }
+
+    internal::dynamic_format_specs<Char> specs_;
 };
 
-template <typename Range, typename Char>
-typename basic_format_context<Range, Char>::format_arg
-  basic_format_context<Range, Char>::get_arg(basic_string_view<char_type> name) {
-  map_.init(this->args());
-  format_arg arg = map_.find(name);
-  if (arg.type() == internal::none_type)
-    this->on_error("argument not found");
-  return arg;
+template<typename Range, typename Char>
+typename basic_format_context<Range, Char>::format_arg basic_format_context<Range, Char>::get_arg(basic_string_view<char_type> name)
+{
+    map_.init(this->args());
+    format_arg arg = map_.find(name);
+    if (arg.type() == internal::none_type)
+        this->on_error("argument not found");
+    return arg;
 }
 
-template <typename ArgFormatter, typename Char, typename Context>
-struct format_handler : internal::error_handler {
-  typedef internal::null_terminating_iterator<Char> iterator;
-  typedef typename ArgFormatter::range range;
+template<typename ArgFormatter, typename Char, typename Context>
+struct format_handler : internal::error_handler
+{
+    typedef internal::null_terminating_iterator<Char> iterator;
+    typedef typename ArgFormatter::range range;
 
-  format_handler(range r, basic_string_view<Char> str,
-                 basic_format_args<Context> format_args)
-    : context(r.begin(), str, format_args) {}
+    format_handler(range r, basic_string_view<Char> str, basic_format_args<Context> format_args)
+        : context(r.begin(), str, format_args)
+    {
+    }
 
-  void on_text(iterator begin, iterator end) {
-    auto size = internal::to_unsigned(end - begin);
-    auto out = context.out();
-    auto &&it = internal::reserve(out, size);
-    it = std::copy_n(begin, size, it);
-    context.advance_to(out);
-  }
+    void on_text(iterator begin, iterator end)
+    {
+        auto size = internal::to_unsigned(end - begin);
+        auto out = context.out();
+        auto &&it = internal::reserve(out, size);
+        it = std::copy_n(begin, size, it);
+        context.advance_to(out);
+    }
 
-  void on_arg_id() { arg = context.next_arg(); }
-  void on_arg_id(unsigned id) {
-    context.parse_context().check_arg_id(id);
-    arg = context.get_arg(id);
-  }
-  void on_arg_id(basic_string_view<Char> id) {
-    arg = context.get_arg(id);
-  }
+    void on_arg_id()
+    {
+        arg = context.next_arg();
+    }
+    void on_arg_id(unsigned id)
+    {
+        context.parse_context().check_arg_id(id);
+        arg = context.get_arg(id);
+    }
+    void on_arg_id(basic_string_view<Char> id)
+    {
+        arg = context.get_arg(id);
+    }
 
-  void on_replacement_field(iterator it) {
-    context.parse_context().advance_to(pointer_from(it));
-    if (visit(internal::custom_formatter<Char, Context>(context), arg))
-      return;
-    basic_format_specs<Char> specs;
-    context.advance_to(visit(ArgFormatter(context, specs), arg));
-  }
+    void on_replacement_field(iterator it)
+    {
+        context.parse_context().advance_to(pointer_from(it));
+        if (visit(internal::custom_formatter<Char, Context>(context), arg))
+            return;
+        basic_format_specs<Char> specs;
+        context.advance_to(visit(ArgFormatter(context, specs), arg));
+    }
 
-  iterator on_format_specs(iterator it) {
-    auto& parse_ctx = context.parse_context();
-    parse_ctx.advance_to(pointer_from(it));
-    if (visit(internal::custom_formatter<Char, Context>(context), arg))
-      return iterator(parse_ctx);
-    basic_format_specs<Char> specs;
-    using internal::specs_handler;
-    internal::specs_checker<specs_handler<Context>>
-        handler(specs_handler<Context>(specs, context), arg.type());
-    it = parse_format_specs(it, handler);
-    if (*it != '}')
-      on_error("missing '}' in format string");
-    parse_ctx.advance_to(pointer_from(it));
-    context.advance_to(visit(ArgFormatter(context, specs), arg));
-    return it;
-  }
+    iterator on_format_specs(iterator it)
+    {
+        auto &parse_ctx = context.parse_context();
+        parse_ctx.advance_to(pointer_from(it));
+        if (visit(internal::custom_formatter<Char, Context>(context), arg))
+            return iterator(parse_ctx);
+        basic_format_specs<Char> specs;
+        using internal::specs_handler;
+        internal::specs_checker<specs_handler<Context>> handler(specs_handler<Context>(specs, context), arg.type());
+        it = parse_format_specs(it, handler);
+        if (*it != '}')
+            on_error("missing '}' in format string");
+        parse_ctx.advance_to(pointer_from(it));
+        context.advance_to(visit(ArgFormatter(context, specs), arg));
+        return it;
+    }
 
-  Context context;
-  basic_format_arg<Context> arg;
+    Context context;
+    basic_format_arg<Context> arg;
 };
 
 /** Formats arguments and writes the output to the range. */
-template <typename ArgFormatter, typename Char, typename Context>
-typename Context::iterator vformat_to(typename ArgFormatter::range out,
-                                      basic_string_view<Char> format_str,
-                                      basic_format_args<Context> args) {
-  typedef internal::null_terminating_iterator<Char> iterator;
-  format_handler<ArgFormatter, Char, Context> h(out, format_str, args);
-  parse_format_string(iterator(format_str.begin(), format_str.end()), h);
-  return h.context.out();
+template<typename ArgFormatter, typename Char, typename Context>
+typename Context::iterator vformat_to(typename ArgFormatter::range out, basic_string_view<Char> format_str, basic_format_args<Context> args)
+{
+    typedef internal::null_terminating_iterator<Char> iterator;
+    format_handler<ArgFormatter, Char, Context> h(out, format_str, args);
+    parse_format_string(iterator(format_str.begin(), format_str.end()), h);
+    return h.context.out();
 }
 
 // Casts ``p`` to ``const void*`` for pointer formatting.
 // Example:
 //   auto s = format("{}", ptr(p));
-template <typename T>
-inline const void *ptr(const T *p) { return p; }
-
-template <typename It, typename Char>
-struct arg_join {
-  It begin;
-  It end;
-  basic_string_view<Char> sep;
-
-  arg_join(It begin, It end, basic_string_view<Char> sep)
-    : begin(begin), end(end), sep(sep) {}
-};
-
-template <typename It, typename Char>
-struct formatter<arg_join<It, Char>, Char>:
-    formatter<typename std::iterator_traits<It>::value_type, Char> {
-  template <typename FormatContext>
-  auto format(const arg_join<It, Char> &value, FormatContext &ctx)
-      -> decltype(ctx.out()) {
-    typedef formatter<typename std::iterator_traits<It>::value_type, Char> base;
-    auto it = value.begin;
-    auto out = ctx.out();
-    if (it != value.end) {
-      out = base::format(*it++, ctx);
-      while (it != value.end) {
-        out = std::copy(value.sep.begin(), value.sep.end(), out);
-        ctx.advance_to(out);
-        out = base::format(*it++, ctx);
-      }
-    }
-    return out;
-  }
-};
-
-template <typename It>
-arg_join<It, char> join(It begin, It end, string_view sep) {
-  return arg_join<It, char>(begin, end, sep);
+template<typename T>
+inline const void *ptr(const T *p)
+{
+    return p;
 }
 
-template <typename It>
-arg_join<It, wchar_t> join(It begin, It end, wstring_view sep) {
-  return arg_join<It, wchar_t>(begin, end, sep);
+template<typename It, typename Char>
+struct arg_join
+{
+    It begin;
+    It end;
+    basic_string_view<Char> sep;
+
+    arg_join(It begin, It end, basic_string_view<Char> sep)
+        : begin(begin)
+        , end(end)
+        , sep(sep)
+    {
+    }
+};
+
+template<typename It, typename Char>
+struct formatter<arg_join<It, Char>, Char> : formatter<typename std::iterator_traits<It>::value_type, Char>
+{
+    template<typename FormatContext>
+    auto format(const arg_join<It, Char> &value, FormatContext &ctx) -> decltype(ctx.out())
+    {
+        typedef formatter<typename std::iterator_traits<It>::value_type, Char> base;
+        auto it = value.begin;
+        auto out = ctx.out();
+        if (it != value.end)
+        {
+            out = base::format(*it++, ctx);
+            while (it != value.end)
+            {
+                out = std::copy(value.sep.begin(), value.sep.end(), out);
+                ctx.advance_to(out);
+                out = base::format(*it++, ctx);
+            }
+        }
+        return out;
+    }
+};
+
+template<typename It>
+arg_join<It, char> join(It begin, It end, string_view sep)
+{
+    return arg_join<It, char>(begin, end, sep);
+}
+
+template<typename It>
+arg_join<It, wchar_t> join(It begin, It end, wstring_view sep)
+{
+    return arg_join<It, wchar_t>(begin, end, sep);
 }
 
 // The following causes ICE in gcc 4.4.
 #if FMT_USE_TRAILING_RETURN && (!FMT_GCC_VERSION || FMT_GCC_VERSION >= 405)
-template <typename Range>
-auto join(const Range &range, string_view sep)
-    -> arg_join<decltype(internal::begin(range)), char> {
-  return join(internal::begin(range), internal::end(range), sep);
+template<typename Range>
+auto join(const Range &range, string_view sep) -> arg_join<decltype(internal::begin(range)), char>
+{
+    return join(internal::begin(range), internal::end(range), sep);
 }
 
-template <typename Range>
-auto join(const Range &range, wstring_view sep)
-    -> arg_join<decltype(internal::begin(range)), wchar_t> {
-  return join(internal::begin(range), internal::end(range), sep);
+template<typename Range>
+auto join(const Range &range, wstring_view sep) -> arg_join<decltype(internal::begin(range)), wchar_t>
+{
+    return join(internal::begin(range), internal::end(range), sep);
 }
 #endif
 
@@ -3427,79 +4164,82 @@ auto join(const Range &range, wstring_view sep)
     std::string answer = fmt::to_string(42);
   \endrst
  */
-template <typename T>
-std::string to_string(const T &value) {
-  std::string str;
-  internal::container_buffer<std::string> buf(str);
-  writer(buf).write(value);
-  return str;
+template<typename T>
+std::string to_string(const T &value)
+{
+    std::string str;
+    internal::container_buffer<std::string> buf(str);
+    writer(buf).write(value);
+    return str;
 }
 
 /**
   Converts *value* to ``std::wstring`` using the default format for type *T*.
  */
-template <typename T>
-std::wstring to_wstring(const T &value) {
-  std::wstring str;
-  internal::container_buffer<std::wstring> buf(str);
-  wwriter(buf).write(value);
-  return str;
+template<typename T>
+std::wstring to_wstring(const T &value)
+{
+    std::wstring str;
+    internal::container_buffer<std::wstring> buf(str);
+    wwriter(buf).write(value);
+    return str;
 }
 
-template <typename Char, std::size_t SIZE>
-std::basic_string<Char> to_string(const basic_memory_buffer<Char, SIZE> &buf) {
-  return std::basic_string<Char>(buf.data(), buf.size());
+template<typename Char, std::size_t SIZE>
+std::basic_string<Char> to_string(const basic_memory_buffer<Char, SIZE> &buf)
+{
+    return std::basic_string<Char>(buf.data(), buf.size());
 }
 
-inline format_context::iterator vformat_to(
-    internal::buffer &buf, string_view format_str, format_args args) {
-  typedef back_insert_range<internal::buffer> range;
-  return vformat_to<arg_formatter<range>>(buf, format_str, args);
+inline format_context::iterator vformat_to(internal::buffer &buf, string_view format_str, format_args args)
+{
+    typedef back_insert_range<internal::buffer> range;
+    return vformat_to<arg_formatter<range>>(buf, format_str, args);
 }
 
-inline wformat_context::iterator vformat_to(
-    internal::wbuffer &buf, wstring_view format_str, wformat_args args) {
-  typedef back_insert_range<internal::wbuffer> range;
-  return vformat_to<arg_formatter<range>>(buf, format_str, args);
+inline wformat_context::iterator vformat_to(internal::wbuffer &buf, wstring_view format_str, wformat_args args)
+{
+    typedef back_insert_range<internal::wbuffer> range;
+    return vformat_to<arg_formatter<range>>(buf, format_str, args);
 }
 
-template <typename... Args, std::size_t SIZE = inline_buffer_size>
-inline format_context::iterator format_to(
-    basic_memory_buffer<char, SIZE> &buf, string_view format_str,
-    const Args & ... args) {
-  return vformat_to(buf, format_str, make_format_args(args...));
+template<typename... Args, std::size_t SIZE = inline_buffer_size>
+inline format_context::iterator format_to(basic_memory_buffer<char, SIZE> &buf, string_view format_str, const Args &... args)
+{
+    return vformat_to(buf, format_str, make_format_args(args...));
 }
 
-template <typename... Args, std::size_t SIZE = inline_buffer_size>
-inline wformat_context::iterator format_to(
-    basic_memory_buffer<wchar_t, SIZE> &buf, wstring_view format_str,
-    const Args & ... args) {
-  return vformat_to(buf, format_str, make_format_args<wformat_context>(args...));
+template<typename... Args, std::size_t SIZE = inline_buffer_size>
+inline wformat_context::iterator format_to(basic_memory_buffer<wchar_t, SIZE> &buf, wstring_view format_str, const Args &... args)
+{
+    return vformat_to(buf, format_str, make_format_args<wformat_context>(args...));
 }
 
-template <typename OutputIt, typename Char = char>
-//using format_context_t = basic_format_context<OutputIt, Char>;
-struct format_context_t { typedef basic_format_context<OutputIt, Char> type; };
-
-template <typename OutputIt, typename Char = char>
-//using format_args_t = basic_format_args<format_context_t<OutputIt, Char>>;
-struct format_args_t {
-  typedef basic_format_args<
-    typename format_context_t<OutputIt, Char>::type> type;
+template<typename OutputIt, typename Char = char>
+// using format_context_t = basic_format_context<OutputIt, Char>;
+struct format_context_t
+{
+    typedef basic_format_context<OutputIt, Char> type;
 };
 
-template <typename OutputIt, typename... Args>
-inline OutputIt vformat_to(OutputIt out, string_view format_str,
-                           typename format_args_t<OutputIt>::type args) {
-  typedef output_range<OutputIt, char> range;
-  return vformat_to<arg_formatter<range>>(range(out), format_str, args);
+template<typename OutputIt, typename Char = char>
+// using format_args_t = basic_format_args<format_context_t<OutputIt, Char>>;
+struct format_args_t
+{
+    typedef basic_format_args<typename format_context_t<OutputIt, Char>::type> type;
+};
+
+template<typename OutputIt, typename... Args>
+inline OutputIt vformat_to(OutputIt out, string_view format_str, typename format_args_t<OutputIt>::type args)
+{
+    typedef output_range<OutputIt, char> range;
+    return vformat_to<arg_formatter<range>>(range(out), format_str, args);
 }
-template <typename OutputIt, typename... Args>
-inline OutputIt vformat_to(
-    OutputIt out, wstring_view format_str,
-    typename format_args_t<OutputIt, wchar_t>::type args) {
-  typedef output_range<OutputIt, wchar_t> range;
-  return vformat_to<arg_formatter<range>>(range(out), format_str, args);
+template<typename OutputIt, typename... Args>
+inline OutputIt vformat_to(OutputIt out, wstring_view format_str, typename format_args_t<OutputIt, wchar_t>::type args)
+{
+    typedef output_range<OutputIt, wchar_t> range;
+    return vformat_to<arg_formatter<range>>(range(out), format_str, args);
 }
 
 /**
@@ -3513,57 +4253,53 @@ inline OutputIt vformat_to(
    fmt::format_to(std::back_inserter(out), "{}", 42);
  \endrst
  */
-template <typename OutputIt, typename... Args>
-inline OutputIt format_to(OutputIt out, string_view format_str,
-                          const Args & ... args) {
-  return vformat_to(out, format_str,
-      make_format_args<typename format_context_t<OutputIt>::type>(args...));
+template<typename OutputIt, typename... Args>
+inline OutputIt format_to(OutputIt out, string_view format_str, const Args &... args)
+{
+    return vformat_to(out, format_str, make_format_args<typename format_context_t<OutputIt>::type>(args...));
 }
 
-template <typename Container, typename... Args>
-inline typename std::enable_if<
-  is_contiguous<Container>::value, std::back_insert_iterator<Container>>::type
-    format_to(std::back_insert_iterator<Container> out,
-              string_view format_str, const Args & ... args) {
-  return vformat_to(out, format_str, make_format_args<format_context>(args...));
+template<typename Container, typename... Args>
+inline typename std::enable_if<is_contiguous<Container>::value, std::back_insert_iterator<Container>>::type format_to(
+    std::back_insert_iterator<Container> out, string_view format_str, const Args &... args)
+{
+    return vformat_to(out, format_str, make_format_args<format_context>(args...));
 }
 
-template <typename Container, typename... Args>
-inline typename std::enable_if<
-  is_contiguous<Container>::value, std::back_insert_iterator<Container>>::type
-    format_to(std::back_insert_iterator<Container> out,
-              wstring_view format_str, const Args & ... args) {
-  return vformat_to(out, format_str, make_format_args<wformat_context>(args...));
+template<typename Container, typename... Args>
+inline typename std::enable_if<is_contiguous<Container>::value, std::back_insert_iterator<Container>>::type format_to(
+    std::back_insert_iterator<Container> out, wstring_view format_str, const Args &... args)
+{
+    return vformat_to(out, format_str, make_format_args<wformat_context>(args...));
 }
 
-template <typename OutputIt>
-struct format_to_n_result {
-  /** Iterator past the end of the output range. */
-  OutputIt out;
-  /** Total (not truncated) output size. */
-  std::size_t size;
+template<typename OutputIt>
+struct format_to_n_result
+{
+    /** Iterator past the end of the output range. */
+    OutputIt out;
+    /** Total (not truncated) output size. */
+    std::size_t size;
 };
 
-template <typename OutputIt>
-using format_to_n_context = typename fmt::format_context_t<
-  fmt::internal::truncating_iterator<OutputIt>>::type;
+template<typename OutputIt>
+using format_to_n_context = typename fmt::format_context_t<fmt::internal::truncating_iterator<OutputIt>>::type;
 
-template <typename OutputIt>
+template<typename OutputIt>
 using format_to_n_args = fmt::basic_format_args<format_to_n_context<OutputIt>>;
 
-template <typename OutputIt, typename ...Args>
-inline format_arg_store<format_to_n_context<OutputIt>, Args...>
-    make_format_to_n_args(const Args & ... args) {
-  return format_arg_store<format_to_n_context<OutputIt>, Args...>(args...);
+template<typename OutputIt, typename... Args>
+inline format_arg_store<format_to_n_context<OutputIt>, Args...> make_format_to_n_args(const Args &... args)
+{
+    return format_arg_store<format_to_n_context<OutputIt>, Args...>(args...);
 }
 
-template <typename OutputIt, typename... Args>
-inline format_to_n_result<OutputIt> vformat_to_n(
-    OutputIt out, std::size_t n, string_view format_str,
-    format_to_n_args<OutputIt> args) {
-  typedef internal::truncating_iterator<OutputIt> It;
-  auto it = vformat_to(It(out, n), format_str, args);
-  return {it.base(), it.count()};
+template<typename OutputIt, typename... Args>
+inline format_to_n_result<OutputIt> vformat_to_n(OutputIt out, std::size_t n, string_view format_str, format_to_n_args<OutputIt> args)
+{
+    typedef internal::truncating_iterator<OutputIt> It;
+    auto it = vformat_to(It(out, n), format_str, args);
+    return {it.base(), it.count()};
 }
 
 /**
@@ -3573,220 +4309,237 @@ inline format_to_n_result<OutputIt> vformat_to_n(
  of the output range.
  \endrst
  */
-template <typename OutputIt, typename... Args>
-inline format_to_n_result<OutputIt> format_to_n(
-    OutputIt out, std::size_t n, string_view format_str, const Args &... args) {
-  return vformat_to_n<OutputIt>(
-    out, n, format_str, make_format_to_n_args<OutputIt>(args...));
+template<typename OutputIt, typename... Args>
+inline format_to_n_result<OutputIt> format_to_n(OutputIt out, std::size_t n, string_view format_str, const Args &... args)
+{
+    return vformat_to_n<OutputIt>(out, n, format_str, make_format_to_n_args<OutputIt>(args...));
 }
-template <typename OutputIt, typename... Args>
-inline format_to_n_result<OutputIt> format_to_n(
-    OutputIt out, std::size_t n, wstring_view format_str, const Args &... args) {
-  typedef internal::truncating_iterator<OutputIt> It;
-  auto it = vformat_to(It(out, n), format_str,
-      make_format_args<typename format_context_t<It, wchar_t>::type>(args...));
-  return {it.base(), it.count()};
+template<typename OutputIt, typename... Args>
+inline format_to_n_result<OutputIt> format_to_n(OutputIt out, std::size_t n, wstring_view format_str, const Args &... args)
+{
+    typedef internal::truncating_iterator<OutputIt> It;
+    auto it = vformat_to(It(out, n), format_str, make_format_args<typename format_context_t<It, wchar_t>::type>(args...));
+    return {it.base(), it.count()};
 }
 
-inline std::string vformat(string_view format_str, format_args args) {
-  memory_buffer buffer;
-  vformat_to(buffer, format_str, args);
-  return fmt::to_string(buffer);
+inline std::string vformat(string_view format_str, format_args args)
+{
+    memory_buffer buffer;
+    vformat_to(buffer, format_str, args);
+    return fmt::to_string(buffer);
 }
 
-inline std::wstring vformat(wstring_view format_str, wformat_args args) {
-  wmemory_buffer buffer;
-  vformat_to(buffer, format_str, args);
-  return to_string(buffer);
+inline std::wstring vformat(wstring_view format_str, wformat_args args)
+{
+    wmemory_buffer buffer;
+    vformat_to(buffer, format_str, args);
+    return to_string(buffer);
 }
 
-template <typename String, typename... Args>
-inline typename std::enable_if<
-  internal::is_format_string<String>::value, std::string>::type
-    format(String format_str, const Args & ... args) {
-  internal::check_format_string<Args...>(format_str);
-  return vformat(format_str.data(), make_format_args(args...));
+template<typename String, typename... Args>
+inline typename std::enable_if<internal::is_format_string<String>::value, std::string>::type format(String format_str, const Args &... args)
+{
+    internal::check_format_string<Args...>(format_str);
+    return vformat(format_str.data(), make_format_args(args...));
 }
 
-template <typename String, typename... Args>
-inline typename std::enable_if<internal::is_format_string<String>::value>::type
-    print(String format_str, const Args & ... args) {
-  internal::check_format_string<Args...>(format_str);
-  return vprint(format_str.data(), make_format_args(args...));
+template<typename String, typename... Args>
+inline typename std::enable_if<internal::is_format_string<String>::value>::type print(String format_str, const Args &... args)
+{
+    internal::check_format_string<Args...>(format_str);
+    return vprint(format_str.data(), make_format_args(args...));
 }
 
 /**
   Returns the number of characters in the output of
   ``format(format_str, args...)``.
  */
-template <typename... Args>
-inline std::size_t formatted_size(string_view format_str,
-                                  const Args & ... args) {
-  auto it = format_to(internal::counting_iterator<char>(), format_str, args...);
-  return it.count();
+template<typename... Args>
+inline std::size_t formatted_size(string_view format_str, const Args &... args)
+{
+    auto it = format_to(internal::counting_iterator<char>(), format_str, args...);
+    return it.count();
 }
 
 // Experimental color support.
 #ifdef FMT_EXTENDED_COLORS
-enum class color : uint32_t {
-  alice_blue              = 0xF0F8FF, // rgb(240,248,255)
-  antique_white           = 0xFAEBD7, // rgb(250,235,215)
-  aqua                    = 0x00FFFF, // rgb(0,255,255)
-  aquamarine              = 0x7FFFD4, // rgb(127,255,212)
-  azure                   = 0xF0FFFF, // rgb(240,255,255)
-  beige                   = 0xF5F5DC, // rgb(245,245,220)
-  bisque                  = 0xFFE4C4, // rgb(255,228,196)
-  black                   = 0x000000, // rgb(0,0,0)
-  blanched_almond         = 0xFFEBCD, // rgb(255,235,205)
-  blue                    = 0x0000FF, // rgb(0,0,255)
-  blue_violet             = 0x8A2BE2, // rgb(138,43,226)
-  brown                   = 0xA52A2A, // rgb(165,42,42)
-  burly_wood              = 0xDEB887, // rgb(222,184,135)
-  cadet_blue              = 0x5F9EA0, // rgb(95,158,160)
-  chartreuse              = 0x7FFF00, // rgb(127,255,0)
-  chocolate               = 0xD2691E, // rgb(210,105,30)
-  coral                   = 0xFF7F50, // rgb(255,127,80)
-  cornflower_blue         = 0x6495ED, // rgb(100,149,237)
-  cornsilk                = 0xFFF8DC, // rgb(255,248,220)
-  crimson                 = 0xDC143C, // rgb(220,20,60)
-  cyan                    = 0x00FFFF, // rgb(0,255,255)
-  dark_blue               = 0x00008B, // rgb(0,0,139)
-  dark_cyan               = 0x008B8B, // rgb(0,139,139)
-  dark_golden_rod         = 0xB8860B, // rgb(184,134,11)
-  dark_gray               = 0xA9A9A9, // rgb(169,169,169)
-  dark_green              = 0x006400, // rgb(0,100,0)
-  dark_khaki              = 0xBDB76B, // rgb(189,183,107)
-  dark_magenta            = 0x8B008B, // rgb(139,0,139)
-  dark_olive_green        = 0x556B2F, // rgb(85,107,47)
-  dark_orange             = 0xFF8C00, // rgb(255,140,0)
-  dark_orchid             = 0x9932CC, // rgb(153,50,204)
-  dark_red                = 0x8B0000, // rgb(139,0,0)
-  dark_salmon             = 0xE9967A, // rgb(233,150,122)
-  dark_sea_green          = 0x8FBC8F, // rgb(143,188,143)
-  dark_slate_blue         = 0x483D8B, // rgb(72,61,139)
-  dark_slate_gray         = 0x2F4F4F, // rgb(47,79,79)
-  dark_turquoise          = 0x00CED1, // rgb(0,206,209)
-  dark_violet             = 0x9400D3, // rgb(148,0,211)
-  deep_pink               = 0xFF1493, // rgb(255,20,147)
-  deep_sky_blue           = 0x00BFFF, // rgb(0,191,255)
-  dim_gray                = 0x696969, // rgb(105,105,105)
-  dodger_blue             = 0x1E90FF, // rgb(30,144,255)
-  fire_brick              = 0xB22222, // rgb(178,34,34)
-  floral_white            = 0xFFFAF0, // rgb(255,250,240)
-  forest_green            = 0x228B22, // rgb(34,139,34)
-  fuchsia                 = 0xFF00FF, // rgb(255,0,255)
-  gainsboro               = 0xDCDCDC, // rgb(220,220,220)
-  ghost_white             = 0xF8F8FF, // rgb(248,248,255)
-  gold                    = 0xFFD700, // rgb(255,215,0)
-  golden_rod              = 0xDAA520, // rgb(218,165,32)
-  gray                    = 0x808080, // rgb(128,128,128)
-  green                   = 0x008000, // rgb(0,128,0)
-  green_yellow            = 0xADFF2F, // rgb(173,255,47)
-  honey_dew               = 0xF0FFF0, // rgb(240,255,240)
-  hot_pink                = 0xFF69B4, // rgb(255,105,180)
-  indian_red              = 0xCD5C5C, // rgb(205,92,92)
-  indigo                  = 0x4B0082, // rgb(75,0,130)
-  ivory                   = 0xFFFFF0, // rgb(255,255,240)
-  khaki                   = 0xF0E68C, // rgb(240,230,140)
-  lavender                = 0xE6E6FA, // rgb(230,230,250)
-  lavender_blush          = 0xFFF0F5, // rgb(255,240,245)
-  lawn_green              = 0x7CFC00, // rgb(124,252,0)
-  lemon_chiffon           = 0xFFFACD, // rgb(255,250,205)
-  light_blue              = 0xADD8E6, // rgb(173,216,230)
-  light_coral             = 0xF08080, // rgb(240,128,128)
-  light_cyan              = 0xE0FFFF, // rgb(224,255,255)
-  light_golden_rod_yellow = 0xFAFAD2, // rgb(250,250,210)
-  light_gray              = 0xD3D3D3, // rgb(211,211,211)
-  light_green             = 0x90EE90, // rgb(144,238,144)
-  light_pink              = 0xFFB6C1, // rgb(255,182,193)
-  light_salmon            = 0xFFA07A, // rgb(255,160,122)
-  light_sea_green         = 0x20B2AA, // rgb(32,178,170)
-  light_sky_blue          = 0x87CEFA, // rgb(135,206,250)
-  light_slate_gray        = 0x778899, // rgb(119,136,153)
-  light_steel_blue        = 0xB0C4DE, // rgb(176,196,222)
-  light_yellow            = 0xFFFFE0, // rgb(255,255,224)
-  lime                    = 0x00FF00, // rgb(0,255,0)
-  lime_green              = 0x32CD32, // rgb(50,205,50)
-  linen                   = 0xFAF0E6, // rgb(250,240,230)
-  magenta                 = 0xFF00FF, // rgb(255,0,255)
-  maroon                  = 0x800000, // rgb(128,0,0)
-  medium_aquamarine       = 0x66CDAA, // rgb(102,205,170)
-  medium_blue             = 0x0000CD, // rgb(0,0,205)
-  medium_orchid           = 0xBA55D3, // rgb(186,85,211)
-  medium_purple           = 0x9370DB, // rgb(147,112,219)
-  medium_sea_green        = 0x3CB371, // rgb(60,179,113)
-  medium_slate_blue       = 0x7B68EE, // rgb(123,104,238)
-  medium_spring_green     = 0x00FA9A, // rgb(0,250,154)
-  medium_turquoise        = 0x48D1CC, // rgb(72,209,204)
-  medium_violet_red       = 0xC71585, // rgb(199,21,133)
-  midnight_blue           = 0x191970, // rgb(25,25,112)
-  mint_cream              = 0xF5FFFA, // rgb(245,255,250)
-  misty_rose              = 0xFFE4E1, // rgb(255,228,225)
-  moccasin                = 0xFFE4B5, // rgb(255,228,181)
-  navajo_white            = 0xFFDEAD, // rgb(255,222,173)
-  navy                    = 0x000080, // rgb(0,0,128)
-  old_lace                = 0xFDF5E6, // rgb(253,245,230)
-  olive                   = 0x808000, // rgb(128,128,0)
-  olive_drab              = 0x6B8E23, // rgb(107,142,35)
-  orange                  = 0xFFA500, // rgb(255,165,0)
-  orange_red              = 0xFF4500, // rgb(255,69,0)
-  orchid                  = 0xDA70D6, // rgb(218,112,214)
-  pale_golden_rod         = 0xEEE8AA, // rgb(238,232,170)
-  pale_green              = 0x98FB98, // rgb(152,251,152)
-  pale_turquoise          = 0xAFEEEE, // rgb(175,238,238)
-  pale_violet_red         = 0xDB7093, // rgb(219,112,147)
-  papaya_whip             = 0xFFEFD5, // rgb(255,239,213)
-  peach_puff              = 0xFFDAB9, // rgb(255,218,185)
-  peru                    = 0xCD853F, // rgb(205,133,63)
-  pink                    = 0xFFC0CB, // rgb(255,192,203)
-  plum                    = 0xDDA0DD, // rgb(221,160,221)
-  powder_blue             = 0xB0E0E6, // rgb(176,224,230)
-  purple                  = 0x800080, // rgb(128,0,128)
-  rebecca_purple          = 0x663399, // rgb(102,51,153)
-  red                     = 0xFF0000, // rgb(255,0,0)
-  rosy_brown              = 0xBC8F8F, // rgb(188,143,143)
-  royal_blue              = 0x4169E1, // rgb(65,105,225)
-  saddle_brown            = 0x8B4513, // rgb(139,69,19)
-  salmon                  = 0xFA8072, // rgb(250,128,114)
-  sandy_brown             = 0xF4A460, // rgb(244,164,96)
-  sea_green               = 0x2E8B57, // rgb(46,139,87)
-  sea_shell               = 0xFFF5EE, // rgb(255,245,238)
-  sienna                  = 0xA0522D, // rgb(160,82,45)
-  silver                  = 0xC0C0C0, // rgb(192,192,192)
-  sky_blue                = 0x87CEEB, // rgb(135,206,235)
-  slate_blue              = 0x6A5ACD, // rgb(106,90,205)
-  slate_gray              = 0x708090, // rgb(112,128,144)
-  snow                    = 0xFFFAFA, // rgb(255,250,250)
-  spring_green            = 0x00FF7F, // rgb(0,255,127)
-  steel_blue              = 0x4682B4, // rgb(70,130,180)
-  tan                     = 0xD2B48C, // rgb(210,180,140)
-  teal                    = 0x008080, // rgb(0,128,128)
-  thistle                 = 0xD8BFD8, // rgb(216,191,216)
-  tomato                  = 0xFF6347, // rgb(255,99,71)
-  turquoise               = 0x40E0D0, // rgb(64,224,208)
-  violet                  = 0xEE82EE, // rgb(238,130,238)
-  wheat                   = 0xF5DEB3, // rgb(245,222,179)
-  white                   = 0xFFFFFF, // rgb(255,255,255)
-  white_smoke             = 0xF5F5F5, // rgb(245,245,245)
-  yellow                  = 0xFFFF00, // rgb(255,255,0)
-  yellow_green            = 0x9ACD32, // rgb(154,205,50)
-};  // enum class color
+enum class color : uint32_t
+{
+    alice_blue = 0xF0F8FF,              // rgb(240,248,255)
+    antique_white = 0xFAEBD7,           // rgb(250,235,215)
+    aqua = 0x00FFFF,                    // rgb(0,255,255)
+    aquamarine = 0x7FFFD4,              // rgb(127,255,212)
+    azure = 0xF0FFFF,                   // rgb(240,255,255)
+    beige = 0xF5F5DC,                   // rgb(245,245,220)
+    bisque = 0xFFE4C4,                  // rgb(255,228,196)
+    black = 0x000000,                   // rgb(0,0,0)
+    blanched_almond = 0xFFEBCD,         // rgb(255,235,205)
+    blue = 0x0000FF,                    // rgb(0,0,255)
+    blue_violet = 0x8A2BE2,             // rgb(138,43,226)
+    brown = 0xA52A2A,                   // rgb(165,42,42)
+    burly_wood = 0xDEB887,              // rgb(222,184,135)
+    cadet_blue = 0x5F9EA0,              // rgb(95,158,160)
+    chartreuse = 0x7FFF00,              // rgb(127,255,0)
+    chocolate = 0xD2691E,               // rgb(210,105,30)
+    coral = 0xFF7F50,                   // rgb(255,127,80)
+    cornflower_blue = 0x6495ED,         // rgb(100,149,237)
+    cornsilk = 0xFFF8DC,                // rgb(255,248,220)
+    crimson = 0xDC143C,                 // rgb(220,20,60)
+    cyan = 0x00FFFF,                    // rgb(0,255,255)
+    dark_blue = 0x00008B,               // rgb(0,0,139)
+    dark_cyan = 0x008B8B,               // rgb(0,139,139)
+    dark_golden_rod = 0xB8860B,         // rgb(184,134,11)
+    dark_gray = 0xA9A9A9,               // rgb(169,169,169)
+    dark_green = 0x006400,              // rgb(0,100,0)
+    dark_khaki = 0xBDB76B,              // rgb(189,183,107)
+    dark_magenta = 0x8B008B,            // rgb(139,0,139)
+    dark_olive_green = 0x556B2F,        // rgb(85,107,47)
+    dark_orange = 0xFF8C00,             // rgb(255,140,0)
+    dark_orchid = 0x9932CC,             // rgb(153,50,204)
+    dark_red = 0x8B0000,                // rgb(139,0,0)
+    dark_salmon = 0xE9967A,             // rgb(233,150,122)
+    dark_sea_green = 0x8FBC8F,          // rgb(143,188,143)
+    dark_slate_blue = 0x483D8B,         // rgb(72,61,139)
+    dark_slate_gray = 0x2F4F4F,         // rgb(47,79,79)
+    dark_turquoise = 0x00CED1,          // rgb(0,206,209)
+    dark_violet = 0x9400D3,             // rgb(148,0,211)
+    deep_pink = 0xFF1493,               // rgb(255,20,147)
+    deep_sky_blue = 0x00BFFF,           // rgb(0,191,255)
+    dim_gray = 0x696969,                // rgb(105,105,105)
+    dodger_blue = 0x1E90FF,             // rgb(30,144,255)
+    fire_brick = 0xB22222,              // rgb(178,34,34)
+    floral_white = 0xFFFAF0,            // rgb(255,250,240)
+    forest_green = 0x228B22,            // rgb(34,139,34)
+    fuchsia = 0xFF00FF,                 // rgb(255,0,255)
+    gainsboro = 0xDCDCDC,               // rgb(220,220,220)
+    ghost_white = 0xF8F8FF,             // rgb(248,248,255)
+    gold = 0xFFD700,                    // rgb(255,215,0)
+    golden_rod = 0xDAA520,              // rgb(218,165,32)
+    gray = 0x808080,                    // rgb(128,128,128)
+    green = 0x008000,                   // rgb(0,128,0)
+    green_yellow = 0xADFF2F,            // rgb(173,255,47)
+    honey_dew = 0xF0FFF0,               // rgb(240,255,240)
+    hot_pink = 0xFF69B4,                // rgb(255,105,180)
+    indian_red = 0xCD5C5C,              // rgb(205,92,92)
+    indigo = 0x4B0082,                  // rgb(75,0,130)
+    ivory = 0xFFFFF0,                   // rgb(255,255,240)
+    khaki = 0xF0E68C,                   // rgb(240,230,140)
+    lavender = 0xE6E6FA,                // rgb(230,230,250)
+    lavender_blush = 0xFFF0F5,          // rgb(255,240,245)
+    lawn_green = 0x7CFC00,              // rgb(124,252,0)
+    lemon_chiffon = 0xFFFACD,           // rgb(255,250,205)
+    light_blue = 0xADD8E6,              // rgb(173,216,230)
+    light_coral = 0xF08080,             // rgb(240,128,128)
+    light_cyan = 0xE0FFFF,              // rgb(224,255,255)
+    light_golden_rod_yellow = 0xFAFAD2, // rgb(250,250,210)
+    light_gray = 0xD3D3D3,              // rgb(211,211,211)
+    light_green = 0x90EE90,             // rgb(144,238,144)
+    light_pink = 0xFFB6C1,              // rgb(255,182,193)
+    light_salmon = 0xFFA07A,            // rgb(255,160,122)
+    light_sea_green = 0x20B2AA,         // rgb(32,178,170)
+    light_sky_blue = 0x87CEFA,          // rgb(135,206,250)
+    light_slate_gray = 0x778899,        // rgb(119,136,153)
+    light_steel_blue = 0xB0C4DE,        // rgb(176,196,222)
+    light_yellow = 0xFFFFE0,            // rgb(255,255,224)
+    lime = 0x00FF00,                    // rgb(0,255,0)
+    lime_green = 0x32CD32,              // rgb(50,205,50)
+    linen = 0xFAF0E6,                   // rgb(250,240,230)
+    magenta = 0xFF00FF,                 // rgb(255,0,255)
+    maroon = 0x800000,                  // rgb(128,0,0)
+    medium_aquamarine = 0x66CDAA,       // rgb(102,205,170)
+    medium_blue = 0x0000CD,             // rgb(0,0,205)
+    medium_orchid = 0xBA55D3,           // rgb(186,85,211)
+    medium_purple = 0x9370DB,           // rgb(147,112,219)
+    medium_sea_green = 0x3CB371,        // rgb(60,179,113)
+    medium_slate_blue = 0x7B68EE,       // rgb(123,104,238)
+    medium_spring_green = 0x00FA9A,     // rgb(0,250,154)
+    medium_turquoise = 0x48D1CC,        // rgb(72,209,204)
+    medium_violet_red = 0xC71585,       // rgb(199,21,133)
+    midnight_blue = 0x191970,           // rgb(25,25,112)
+    mint_cream = 0xF5FFFA,              // rgb(245,255,250)
+    misty_rose = 0xFFE4E1,              // rgb(255,228,225)
+    moccasin = 0xFFE4B5,                // rgb(255,228,181)
+    navajo_white = 0xFFDEAD,            // rgb(255,222,173)
+    navy = 0x000080,                    // rgb(0,0,128)
+    old_lace = 0xFDF5E6,                // rgb(253,245,230)
+    olive = 0x808000,                   // rgb(128,128,0)
+    olive_drab = 0x6B8E23,              // rgb(107,142,35)
+    orange = 0xFFA500,                  // rgb(255,165,0)
+    orange_red = 0xFF4500,              // rgb(255,69,0)
+    orchid = 0xDA70D6,                  // rgb(218,112,214)
+    pale_golden_rod = 0xEEE8AA,         // rgb(238,232,170)
+    pale_green = 0x98FB98,              // rgb(152,251,152)
+    pale_turquoise = 0xAFEEEE,          // rgb(175,238,238)
+    pale_violet_red = 0xDB7093,         // rgb(219,112,147)
+    papaya_whip = 0xFFEFD5,             // rgb(255,239,213)
+    peach_puff = 0xFFDAB9,              // rgb(255,218,185)
+    peru = 0xCD853F,                    // rgb(205,133,63)
+    pink = 0xFFC0CB,                    // rgb(255,192,203)
+    plum = 0xDDA0DD,                    // rgb(221,160,221)
+    powder_blue = 0xB0E0E6,             // rgb(176,224,230)
+    purple = 0x800080,                  // rgb(128,0,128)
+    rebecca_purple = 0x663399,          // rgb(102,51,153)
+    red = 0xFF0000,                     // rgb(255,0,0)
+    rosy_brown = 0xBC8F8F,              // rgb(188,143,143)
+    royal_blue = 0x4169E1,              // rgb(65,105,225)
+    saddle_brown = 0x8B4513,            // rgb(139,69,19)
+    salmon = 0xFA8072,                  // rgb(250,128,114)
+    sandy_brown = 0xF4A460,             // rgb(244,164,96)
+    sea_green = 0x2E8B57,               // rgb(46,139,87)
+    sea_shell = 0xFFF5EE,               // rgb(255,245,238)
+    sienna = 0xA0522D,                  // rgb(160,82,45)
+    silver = 0xC0C0C0,                  // rgb(192,192,192)
+    sky_blue = 0x87CEEB,                // rgb(135,206,235)
+    slate_blue = 0x6A5ACD,              // rgb(106,90,205)
+    slate_gray = 0x708090,              // rgb(112,128,144)
+    snow = 0xFFFAFA,                    // rgb(255,250,250)
+    spring_green = 0x00FF7F,            // rgb(0,255,127)
+    steel_blue = 0x4682B4,              // rgb(70,130,180)
+    tan = 0xD2B48C,                     // rgb(210,180,140)
+    teal = 0x008080,                    // rgb(0,128,128)
+    thistle = 0xD8BFD8,                 // rgb(216,191,216)
+    tomato = 0xFF6347,                  // rgb(255,99,71)
+    turquoise = 0x40E0D0,               // rgb(64,224,208)
+    violet = 0xEE82EE,                  // rgb(238,130,238)
+    wheat = 0xF5DEB3,                   // rgb(245,222,179)
+    white = 0xFFFFFF,                   // rgb(255,255,255)
+    white_smoke = 0xF5F5F5,             // rgb(245,245,245)
+    yellow = 0xFFFF00,                  // rgb(255,255,0)
+    yellow_green = 0x9ACD32,            // rgb(154,205,50)
+};                                      // enum class color
 
 // rgb is a struct for red, green and blue colors.
 // We use rgb as name because some editors will show it as color direct in the
 // editor.
-struct rgb {
-  FMT_CONSTEXPR_DECL rgb() : r(0), g(0), b(0) {}
-  FMT_CONSTEXPR_DECL rgb(uint8_t r_, uint8_t g_, uint8_t b_)
-    : r(r_), g(g_), b(b_) {}
-  FMT_CONSTEXPR_DECL rgb(uint32_t hex)
-    : r((hex >> 16) & 0xFF), g((hex >> 8) & 0xFF), b((hex) & 0xFF) {}
-  FMT_CONSTEXPR_DECL rgb(color hex)
-    : r((uint32_t(hex) >> 16) & 0xFF), g((uint32_t(hex) >> 8) & 0xFF),
-      b(uint32_t(hex) & 0xFF) {}
-  uint8_t r;
-  uint8_t g;
-  uint8_t b;
+struct rgb
+{
+    FMT_CONSTEXPR_DECL rgb()
+        : r(0)
+        , g(0)
+        , b(0)
+    {
+    }
+    FMT_CONSTEXPR_DECL rgb(uint8_t r_, uint8_t g_, uint8_t b_)
+        : r(r_)
+        , g(g_)
+        , b(b_)
+    {
+    }
+    FMT_CONSTEXPR_DECL rgb(uint32_t hex)
+        : r((hex >> 16) & 0xFF)
+        , g((hex >> 8) & 0xFF)
+        , b((hex)&0xFF)
+    {
+    }
+    FMT_CONSTEXPR_DECL rgb(color hex)
+        : r((uint32_t(hex) >> 16) & 0xFF)
+        , g((uint32_t(hex) >> 8) & 0xFF)
+        , b(uint32_t(hex) & 0xFF)
+    {
+    }
+    uint8_t r;
+    uint8_t g;
+    uint8_t b;
 };
 
 void vprint_rgb(rgb fd, string_view format, format_args args);
@@ -3798,9 +4551,10 @@ void vprint_rgb(rgb fd, rgb bg, string_view format, format_args args);
   Example:
     fmt::print(fmt::color::red, "Elapsed time: {0:.2f} seconds", 1.23);
  */
-template <typename... Args>
-inline void print(rgb fd, string_view format_str, const Args & ... args) {
-  vprint_rgb(fd, format_str, make_format_args(args...));
+template<typename... Args>
+inline void print(rgb fd, string_view format_str, const Args &... args)
+{
+    vprint_rgb(fd, format_str, make_format_args(args...));
 }
 
 /**
@@ -3809,62 +4563,68 @@ inline void print(rgb fd, string_view format_str, const Args & ... args) {
   Example:
     fmt::print(fmt::color::red, fmt::color::black, "Elapsed time: {0:.2f} seconds", 1.23);
  */
-template <typename... Args>
-inline void print(rgb fd, rgb bg, string_view format_str, const Args & ... args) {
-  vprint_rgb(fd, bg, format_str, make_format_args(args...));
+template<typename... Args>
+inline void print(rgb fd, rgb bg, string_view format_str, const Args &... args)
+{
+    vprint_rgb(fd, bg, format_str, make_format_args(args...));
 }
-#endif  // FMT_EXTENDED_COLORS
+#endif // FMT_EXTENDED_COLORS
 
 #if FMT_USE_USER_DEFINED_LITERALS
 namespace internal {
 
-# if FMT_UDL_TEMPLATE
-template <typename Char, Char... CHARS>
-class udl_formatter {
- public:
-  template <typename... Args>
-  std::basic_string<Char> operator()(const Args &... args) const {
-    FMT_CONSTEXPR_DECL Char s[] = {CHARS..., '\0'};
-    FMT_CONSTEXPR_DECL bool invalid_format =
-        check_format_string<Char, error_handler, Args...>(
-          basic_string_view<Char>(s, sizeof...(CHARS)));
-    (void)invalid_format;
-    return format(s, args...);
-  }
+#if FMT_UDL_TEMPLATE
+template<typename Char, Char... CHARS>
+class udl_formatter
+{
+public:
+    template<typename... Args>
+    std::basic_string<Char> operator()(const Args &... args) const
+    {
+        FMT_CONSTEXPR_DECL Char s[] = {CHARS..., '\0'};
+        FMT_CONSTEXPR_DECL bool invalid_format =
+            check_format_string<Char, error_handler, Args...>(basic_string_view<Char>(s, sizeof...(CHARS)));
+        (void)invalid_format;
+        return format(s, args...);
+    }
 };
-# else
-template <typename Char>
-struct udl_formatter {
-  const Char *str;
+#else
+template<typename Char>
+struct udl_formatter
+{
+    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... Args>
+    auto operator()(Args &&... args) const -> decltype(format(str, std::forward<Args>(args)...))
+    {
+        return format(str, std::forward<Args>(args)...);
+    }
 };
-# endif // FMT_UDL_TEMPLATE
+#endif // FMT_UDL_TEMPLATE
 
-template <typename Char>
-struct udl_arg {
-  const Char *str;
+template<typename Char>
+struct udl_arg
+{
+    const Char *str;
 
-  template <typename T>
-  named_arg<T, Char> operator=(T &&value) const {
-    return {str, std::forward<T>(value)};
-  }
+    template<typename T>
+    named_arg<T, Char> operator=(T &&value) const
+    {
+        return {str, std::forward<T>(value)};
+    }
 };
 
 } // namespace internal
 
 inline namespace literals {
 
-# if FMT_UDL_TEMPLATE
-template <typename Char, Char... CHARS>
-FMT_CONSTEXPR internal::udl_formatter<Char, CHARS...> operator""_format() {
-  return {};
+#if FMT_UDL_TEMPLATE
+template<typename Char, Char... CHARS>
+FMT_CONSTEXPR internal::udl_formatter<Char, CHARS...> operator""_format()
+{
+    return {};
 }
-# else
+#else
 /**
   \rst
   User-defined literal equivalent of :func:`fmt::format`.
@@ -3875,11 +4635,15 @@ FMT_CONSTEXPR internal::udl_formatter<Char, CHARS...> operator""_format() {
     std::string message = "The answer is {}"_format(42);
   \endrst
  */
-inline internal::udl_formatter<char>
-operator"" _format(const char *s, std::size_t) { return {s}; }
-inline internal::udl_formatter<wchar_t>
-operator"" _format(const wchar_t *s, std::size_t) { return {s}; }
-# endif // FMT_UDL_TEMPLATE
+inline internal::udl_formatter<char> operator"" _format(const char *s, std::size_t)
+{
+    return {s};
+}
+inline internal::udl_formatter<wchar_t> operator"" _format(const wchar_t *s, std::size_t)
+{
+    return {s};
+}
+#endif // FMT_UDL_TEMPLATE
 
 /**
   \rst
@@ -3891,21 +4655,33 @@ operator"" _format(const wchar_t *s, std::size_t) { return {s}; }
     fmt::print("Elapsed time: {s:.2f} seconds", "s"_a=1.23);
   \endrst
  */
-inline internal::udl_arg<char>
-operator"" _a(const char *s, std::size_t) { return {s}; }
-inline internal::udl_arg<wchar_t>
-operator"" _a(const wchar_t *s, std::size_t) { return {s}; }
-} // inline namespace literals
+inline internal::udl_arg<char> operator"" _a(const char *s, std::size_t)
+{
+    return {s};
+}
+inline internal::udl_arg<wchar_t> operator"" _a(const wchar_t *s, std::size_t)
+{
+    return {s};
+}
+} // namespace literals
 #endif // FMT_USE_USER_DEFINED_LITERALS
 FMT_END_NAMESPACE
 
-#define FMT_STRING(s) [] { \
-    struct S : fmt::format_string { \
-      static FMT_CONSTEXPR decltype(s) data() { return s; } \
-      static FMT_CONSTEXPR size_t size() { return sizeof(s); } \
-    }; \
-    return S{}; \
-  }()
+#define FMT_STRING(s)                                                                                                                      \
+    [] {                                                                                                                                   \
+        struct S : fmt::format_string                                                                                                      \
+        {                                                                                                                                  \
+            static FMT_CONSTEXPR decltype(s) data()                                                                                        \
+            {                                                                                                                              \
+                return s;                                                                                                                  \
+            }                                                                                                                              \
+            static FMT_CONSTEXPR size_t size()                                                                                             \
+            {                                                                                                                              \
+                return sizeof(s);                                                                                                          \
+            }                                                                                                                              \
+        };                                                                                                                                 \
+        return S{};                                                                                                                        \
+    }()
 
 #ifndef FMT_NO_FMT_STRING_ALIAS
 /**
@@ -3919,19 +4695,19 @@ FMT_END_NAMESPACE
     std::string s = format(fmt("{:d}"), "foo");
   \endrst
  */
-# define fmt(s) FMT_STRING(s)
+#define fmt(s) FMT_STRING(s)
 #endif
 
 #ifdef FMT_HEADER_ONLY
-# define FMT_FUNC inline
-# include "format-inl.h"
+#define FMT_FUNC inline
+#include "format-inl.h"
 #else
-# define FMT_FUNC
+#define FMT_FUNC
 #endif
 
 // Restore warnings.
 #if FMT_GCC_VERSION >= 406 || FMT_CLANG_VERSION
-# pragma GCC diagnostic pop
+#pragma GCC diagnostic pop
 #endif
 
-#endif  // FMT_FORMAT_H_
+#endif // FMT_FORMAT_H_
diff --git a/include/spdlog/fmt/bundled/ostream.h b/include/spdlog/fmt/bundled/ostream.h
index 94f18834..df7b03d5 100644
--- a/include/spdlog/fmt/bundled/ostream.h
+++ b/include/spdlog/fmt/bundled/ostream.h
@@ -14,128 +14,137 @@
 FMT_BEGIN_NAMESPACE
 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;
+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;
 
-  basic_buffer<Char> &buffer_;
+    basic_buffer<Char> &buffer_;
 
- public:
-  formatbuf(basic_buffer<Char> &buffer) : buffer_(buffer) {}
+public:
+    formatbuf(basic_buffer<Char> &buffer)
+        : buffer_(buffer)
+    {
+    }
 
- protected:
-  // The put-area is actually always empty. This makes the implementation
-  // simpler and has the advantage that the streambuf and the buffer are always
-  // in sync and sputc never writes into uninitialized memory. The obvious
-  // disadvantage is that each call to sputc always results in a (virtual) call
-  // to overflow. There is no disadvantage here for sputn since this always
-  // results in a call to xsputn.
+protected:
+    // The put-area is actually always empty. This makes the implementation
+    // simpler and has the advantage that the streambuf and the buffer are always
+    // in sync and sputc never writes into uninitialized memory. The obvious
+    // disadvantage is that each call to sputc always results in a (virtual) call
+    // to overflow. There is no disadvantage here for sputn since this always
+    // results in a call to xsputn.
 
-  int_type overflow(int_type ch = traits_type::eof()) FMT_OVERRIDE {
-    if (!traits_type::eq_int_type(ch, traits_type::eof()))
-      buffer_.push_back(static_cast<Char>(ch));
-    return ch;
-  }
+    int_type overflow(int_type ch = traits_type::eof()) FMT_OVERRIDE
+    {
+        if (!traits_type::eq_int_type(ch, traits_type::eof()))
+            buffer_.push_back(static_cast<Char>(ch));
+        return ch;
+    }
 
-  std::streamsize xsputn(const Char *s, std::streamsize count) FMT_OVERRIDE {
-    buffer_.append(s, s + count);
-    return count;
-  }
+    std::streamsize xsputn(const Char *s, std::streamsize count) FMT_OVERRIDE
+    {
+        buffer_.append(s, s + count);
+        return count;
+    }
 };
 
-template <typename Char>
-struct test_stream : std::basic_ostream<Char> {
- private:
-  struct null;
-  // Hide all operator<< from std::basic_ostream<Char>.
-  void operator<<(null);
+template<typename Char>
+struct test_stream : std::basic_ostream<Char>
+{
+private:
+    struct null;
+    // Hide all operator<< from std::basic_ostream<Char>.
+    void operator<<(null);
 };
 
 // Checks if T has a user-defined operator<< (e.g. not a member of std::ostream).
-template <typename T, typename Char>
-class is_streamable {
- private:
-  template <typename U>
-  static decltype(
-    internal::declval<test_stream<Char>&>()
-      << internal::declval<U>(), std::true_type()) test(int);
+template<typename T, typename Char>
+class is_streamable
+{
+private:
+    template<typename U>
+    static decltype(internal::declval<test_stream<Char> &>() << internal::declval<U>(), std::true_type()) test(int);
 
-  template <typename>
-  static std::false_type test(...);
+    template<typename>
+    static std::false_type test(...);
 
-  typedef decltype(test<T>(0)) result;
+    typedef decltype(test<T>(0)) result;
 
- public:
-  // std::string operator<< is not considered user-defined because we handle strings
-  // specially.
-  static const bool value = result::value && !std::is_same<T, std::string>::value;
+public:
+    // std::string operator<< is not considered user-defined because we handle strings
+    // specially.
+    static const bool value = result::value && !std::is_same<T, std::string>::value;
 };
 
 // Disable conversion to int if T has an overloaded operator<< which is a free
 // function (not a member of std::ostream).
-template <typename T, typename Char>
-class convert_to_int<T, Char, true> {
- public:
-  static const bool value =
-    convert_to_int<T, Char, false>::value && !is_streamable<T, Char>::value;
+template<typename T, typename Char>
+class convert_to_int<T, Char, true>
+{
+public:
+    static const bool value = convert_to_int<T, Char, false>::value && !is_streamable<T, Char>::value;
 };
 
 // Write the content of buf to os.
-template <typename Char>
-void write(std::basic_ostream<Char> &os, basic_buffer<Char> &buf) {
-  const Char *data = buf.data();
-  typedef std::make_unsigned<std::streamsize>::type UnsignedStreamSize;
-  UnsignedStreamSize size = buf.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);
+template<typename Char>
+void write(std::basic_ostream<Char> &os, basic_buffer<Char> &buf)
+{
+    const Char *data = buf.data();
+    typedef std::make_unsigned<std::streamsize>::type UnsignedStreamSize;
+    UnsignedStreamSize size = buf.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);
 }
 
-template <typename Char, typename T>
-void format_value(basic_buffer<Char> &buffer, const T &value) {
-  internal::formatbuf<Char> format_buf(buffer);
-  std::basic_ostream<Char> output(&format_buf);
-  output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
-  output << value;
-  buffer.resize(buffer.size());
+template<typename Char, typename T>
+void format_value(basic_buffer<Char> &buffer, const T &value)
+{
+    internal::formatbuf<Char> format_buf(buffer);
+    std::basic_ostream<Char> output(&format_buf);
+    output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
+    output << value;
+    buffer.resize(buffer.size());
 }
 
 // Disable builtin formatting of enums and use operator<< instead.
-template <typename T>
-struct format_enum<T,
-    typename std::enable_if<std::is_enum<T>::value>::type> : std::false_type {};
-}  // namespace internal
+template<typename T>
+struct format_enum<T, typename std::enable_if<std::is_enum<T>::value>::type> : std::false_type
+{
+};
+} // namespace internal
 
 // Formats an object of type T that has an overloaded ostream operator<<.
-template <typename T, typename Char>
-struct formatter<T, Char,
-    typename std::enable_if<internal::is_streamable<T, Char>::value>::type>
-    : formatter<basic_string_view<Char>, Char> {
+template<typename T, typename Char>
+struct formatter<T, Char, typename std::enable_if<internal::is_streamable<T, Char>::value>::type> : formatter<basic_string_view<Char>, Char>
+{
 
-  template <typename Context>
-  auto format(const T &value, Context &ctx) -> decltype(ctx.out()) {
-    basic_memory_buffer<Char> buffer;
-    internal::format_value(buffer, value);
-    basic_string_view<Char> str(buffer.data(), buffer.size());
-    formatter<basic_string_view<Char>, Char>::format(str, ctx);
-    return ctx.out();
-  }
+    template<typename Context>
+    auto format(const T &value, Context &ctx) -> decltype(ctx.out())
+    {
+        basic_memory_buffer<Char> buffer;
+        internal::format_value(buffer, value);
+        basic_string_view<Char> str(buffer.data(), buffer.size());
+        formatter<basic_string_view<Char>, Char>::format(str, ctx);
+        return ctx.out();
+    }
 };
 
-template <typename Char>
-inline void vprint(std::basic_ostream<Char> &os,
-                   basic_string_view<Char> format_str,
-                   basic_format_args<typename buffer_context<Char>::type> args) {
-  basic_memory_buffer<Char> buffer;
-  vformat_to(buffer, format_str, args);
-  internal::write(os, buffer);
+template<typename Char>
+inline void vprint(
+    std::basic_ostream<Char> &os, basic_string_view<Char> format_str, basic_format_args<typename buffer_context<Char>::type> args)
+{
+    basic_memory_buffer<Char> buffer;
+    vformat_to(buffer, format_str, args);
+    internal::write(os, buffer);
 }
 /**
   \rst
@@ -146,17 +155,17 @@ inline void vprint(std::basic_ostream<Char> &os,
     fmt::print(cerr, "Don't {}!", "panic");
   \endrst
  */
-template <typename... Args>
-inline void print(std::ostream &os, string_view format_str,
-                  const Args & ... args) {
-  vprint<char>(os, format_str, make_format_args<format_context>(args...));
+template<typename... Args>
+inline void print(std::ostream &os, string_view format_str, const Args &... args)
+{
+    vprint<char>(os, format_str, make_format_args<format_context>(args...));
 }
 
-template <typename... Args>
-inline void print(std::wostream &os, wstring_view format_str,
-                  const Args & ... args) {
-  vprint<wchar_t>(os, format_str, make_format_args<wformat_context>(args...));
+template<typename... Args>
+inline void print(std::wostream &os, wstring_view format_str, const Args &... args)
+{
+    vprint<wchar_t>(os, format_str, make_format_args<wformat_context>(args...));
 }
 FMT_END_NAMESPACE
 
-#endif  // FMT_OSTREAM_H_
+#endif // FMT_OSTREAM_H_
diff --git a/include/spdlog/fmt/bundled/posix.h b/include/spdlog/fmt/bundled/posix.h
index 8682d716..20c75899 100644
--- a/include/spdlog/fmt/bundled/posix.h
+++ b/include/spdlog/fmt/bundled/posix.h
@@ -10,54 +10,55 @@
 
 #if defined(__MINGW32__) || defined(__CYGWIN__)
 // Workaround MinGW bug https://sourceforge.net/p/mingw/bugs/2024/.
-# undef __STRICT_ANSI__
+#undef __STRICT_ANSI__
 #endif
 
 #include <errno.h>
-#include <fcntl.h>   // for O_RDONLY
-#include <locale.h>  // for locale_t
+#include <fcntl.h>  // for O_RDONLY
+#include <locale.h> // for locale_t
 #include <stdio.h>
-#include <stdlib.h>  // for strtod_l
+#include <stdlib.h> // for strtod_l
 
 #include <cstddef>
 
 #if defined __APPLE__ || defined(__FreeBSD__)
-# include <xlocale.h>  // for LC_NUMERIC_MASK on OS X
+#include <xlocale.h> // for LC_NUMERIC_MASK on OS X
 #endif
 
 #include "format.h"
 
 #ifndef FMT_POSIX
-# if defined(_WIN32) && !defined(__MINGW32__)
+#if defined(_WIN32) && !defined(__MINGW32__)
 // Fix warnings about deprecated symbols.
-#  define FMT_POSIX(call) _##call
-# else
-#  define FMT_POSIX(call) call
-# endif
+#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)
+#define FMT_POSIX_CALL(call) FMT_SYSTEM(call)
 #else
-# define FMT_SYSTEM(call) call
-# ifdef _WIN32
+#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
+#define FMT_POSIX_CALL(call) ::_##call
+#else
+#define FMT_POSIX_CALL(call) ::call
+#endif
 #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)
+#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)
+#define FMT_RETRY_VAL(result, expression, error_result) result = (expression)
 #endif
 
 #define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1)
@@ -89,137 +90,167 @@ FMT_BEGIN_NAMESPACE
     format(std::string("{}"), 42);
   \endrst
  */
-template <typename Char>
-class basic_cstring_view {
- private:
-  const Char *data_;
+template<typename Char>
+class basic_cstring_view
+{
+private:
+    const Char *data_;
 
- public:
-  /** Constructs a string reference object from a C string. */
-  basic_cstring_view(const Char *s) : data_(s) {}
+public:
+    /** Constructs a string reference object from a C string. */
+    basic_cstring_view(const Char *s)
+        : data_(s)
+    {
+    }
 
-  /**
-    \rst
-    Constructs a string reference from an ``std::string`` object.
-    \endrst
-   */
-  basic_cstring_view(const std::basic_string<Char> &s) : data_(s.c_str()) {}
+    /**
+      \rst
+      Constructs a string reference from an ``std::string`` object.
+      \endrst
+     */
+    basic_cstring_view(const std::basic_string<Char> &s)
+        : data_(s.c_str())
+    {
+    }
 
-  /** Returns the pointer to a C string. */
-  const Char *c_str() const { return data_; }
+    /** Returns the pointer to a C string. */
+    const Char *c_str() const
+    {
+        return data_;
+    }
 };
 
 typedef basic_cstring_view<char> cstring_view;
 typedef basic_cstring_view<wchar_t> wcstring_view;
 
 // An error code.
-class error_code {
- private:
-  int value_;
+class error_code
+{
+private:
+    int value_;
 
- public:
-  explicit error_code(int value = 0) FMT_NOEXCEPT : value_(value) {}
+public:
+    explicit error_code(int value = 0) FMT_NOEXCEPT : value_(value) {}
 
-  int get() const FMT_NOEXCEPT { return value_; }
+    int get() const FMT_NOEXCEPT
+    {
+        return value_;
+    }
 };
 
 // A buffered file.
-class buffered_file {
- private:
-  FILE *file_;
+class buffered_file
+{
+private:
+    FILE *file_;
 
-  friend class file;
+    friend class file;
 
-  explicit buffered_file(FILE *f) : file_(f) {}
-
- public:
-  // Constructs a buffered_file object which doesn't represent any file.
-  buffered_file() FMT_NOEXCEPT : file_(FMT_NULL) {}
-
-  // Destroys the object closing the file it represents if any.
-  FMT_API ~buffered_file() FMT_DTOR_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;
-  };
+    explicit buffered_file(FILE *f)
+        : file_(f)
+    {
+    }
 
 public:
-  // A "move constructor" for moving from a temporary.
-  buffered_file(Proxy p) FMT_NOEXCEPT : file_(p.file) {}
+    // Constructs a buffered_file object which doesn't represent any file.
+    buffered_file() FMT_NOEXCEPT : file_(FMT_NULL) {}
 
-  // A "move constructor" for moving from an lvalue.
-  buffered_file(buffered_file &f) FMT_NOEXCEPT : file_(f.file_) {
-    f.file_ = FMT_NULL;
-  }
+    // Destroys the object closing the file it represents if any.
+    FMT_API ~buffered_file() FMT_DTOR_NOEXCEPT;
 
-  // A "move assignment operator" for moving from a temporary.
-  buffered_file &operator=(Proxy p) {
-    close();
-    file_ = p.file;
-    return *this;
-  }
+#if !FMT_USE_RVALUE_REFERENCES
+    // Emulate a move constructor and a move assignment operator if rvalue
+    // references are not supported.
 
-  // A "move assignment operator" for moving from an lvalue.
-  buffered_file &operator=(buffered_file &other) {
-    close();
-    file_ = other.file_;
-    other.file_ = FMT_NULL;
-    return *this;
-  }
+private:
+    // A proxy object to emulate a move constructor.
+    // It is private to make it impossible call operator Proxy directly.
+    struct Proxy
+    {
+        FILE *file;
+    };
 
-  // Returns a proxy object for moving from a temporary:
-  //   buffered_file file = buffered_file(...);
-  operator Proxy() FMT_NOEXCEPT {
-    Proxy p = {file_};
-    file_ = FMT_NULL;
-    return p;
-  }
+public:
+    // A "move constructor" for moving from a temporary.
+    buffered_file(Proxy p) FMT_NOEXCEPT : file_(p.file) {}
+
+    // A "move constructor" for moving from an lvalue.
+    buffered_file(buffered_file &f) FMT_NOEXCEPT : file_(f.file_)
+    {
+        f.file_ = FMT_NULL;
+    }
+
+    // A "move assignment operator" for moving from a temporary.
+    buffered_file &operator=(Proxy p)
+    {
+        close();
+        file_ = p.file;
+        return *this;
+    }
+
+    // A "move assignment operator" for moving from an lvalue.
+    buffered_file &operator=(buffered_file &other)
+    {
+        close();
+        file_ = other.file_;
+        other.file_ = FMT_NULL;
+        return *this;
+    }
+
+    // Returns a proxy object for moving from a temporary:
+    //   buffered_file file = buffered_file(...);
+    operator Proxy() FMT_NOEXCEPT
+    {
+        Proxy p = {file_};
+        file_ = FMT_NULL;
+        return p;
+    }
 
 #else
- private:
-  FMT_DISALLOW_COPY_AND_ASSIGN(buffered_file);
+private:
+    FMT_DISALLOW_COPY_AND_ASSIGN(buffered_file);
 
- public:
-  buffered_file(buffered_file &&other) FMT_NOEXCEPT : file_(other.file_) {
-    other.file_ = FMT_NULL;
-  }
+public:
+    buffered_file(buffered_file &&other) FMT_NOEXCEPT : file_(other.file_)
+    {
+        other.file_ = FMT_NULL;
+    }
 
-  buffered_file& operator=(buffered_file &&other) {
-    close();
-    file_ = other.file_;
-    other.file_ = FMT_NULL;
-    return *this;
-  }
+    buffered_file &operator=(buffered_file &&other)
+    {
+        close();
+        file_ = other.file_;
+        other.file_ = FMT_NULL;
+        return *this;
+    }
 #endif
 
-  // Opens a file.
-  FMT_API buffered_file(cstring_view filename, cstring_view mode);
+    // Opens a file.
+    FMT_API buffered_file(cstring_view filename, cstring_view mode);
 
-  // Closes the file.
-  FMT_API void close();
+    // Closes the file.
+    FMT_API void close();
 
-  // Returns the pointer to a FILE object representing this file.
-  FILE *get() const FMT_NOEXCEPT { return file_; }
+    // 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.
-  FMT_API int (fileno)() const;
+    // We place parentheses around fileno to workaround a bug in some versions
+    // of MinGW that define fileno as a macro.
+    FMT_API int(fileno)() const;
 
-  void vprint(string_view format_str, format_args args) {
-    fmt::vprint(file_, format_str, args);
-  }
+    void vprint(string_view format_str, format_args args)
+    {
+        fmt::vprint(file_, format_str, args);
+    }
 
-  template <typename... Args>
-  inline void print(string_view format_str, const Args & ... args) {
-    vprint(format_str, make_format_args(args...));
-  }
+    template<typename... Args>
+    inline void print(string_view format_str, const Args &... args)
+    {
+        vprint(format_str, make_format_args(args...));
+    }
 };
 
 // A file. Closed file is represented by a file object with descriptor -1.
@@ -228,190 +259,226 @@ public:
 // 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.
+class file
+{
+private:
+    int fd_; // File descriptor.
 
-  // Constructs a file object with a given descriptor.
-  explicit file(int fd) : fd_(fd) {}
+    // 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.
-  };
+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) {}
+    // 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.
-  FMT_API file(cstring_view path, int oflag);
+    // Opens a file and constructs a file object representing this file.
+    FMT_API file(cstring_view path, int oflag);
 
 #if !FMT_USE_RVALUE_REFERENCES
-  // Emulate a move constructor and a move assignment operator if rvalue
-  // references are not supported.
+    // 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;
-  };
+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) {}
+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 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 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;
-  }
+    // 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 f = file(...);
-  operator Proxy() FMT_NOEXCEPT {
-    Proxy p = {fd_};
-    fd_ = -1;
-    return p;
-  }
+    // Returns a proxy object for moving from a temporary:
+    //   file f = file(...);
+    operator Proxy() FMT_NOEXCEPT
+    {
+        Proxy p = {fd_};
+        fd_ = -1;
+        return p;
+    }
 
 #else
- private:
-  FMT_DISALLOW_COPY_AND_ASSIGN(file);
+private:
+    FMT_DISALLOW_COPY_AND_ASSIGN(file);
 
- public:
-  file(file &&other) FMT_NOEXCEPT : fd_(other.fd_) {
-    other.fd_ = -1;
-  }
+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;
-  }
+    file &operator=(file &&other)
+    {
+        close();
+        fd_ = other.fd_;
+        other.fd_ = -1;
+        return *this;
+    }
 #endif
 
-  // Destroys the object closing the file it represents if any.
-  FMT_API ~file() FMT_DTOR_NOEXCEPT;
+    // Destroys the object closing the file it represents if any.
+    FMT_API ~file() FMT_DTOR_NOEXCEPT;
 
-  // Returns the file descriptor.
-  int descriptor() const FMT_NOEXCEPT { return fd_; }
+    // Returns the file descriptor.
+    int descriptor() const FMT_NOEXCEPT
+    {
+        return fd_;
+    }
 
-  // Closes the file.
-  FMT_API void close();
+    // Closes the file.
+    FMT_API void close();
 
-  // Returns the file size. The size has signed type for consistency with
-  // stat::st_size.
-  FMT_API long long size() const;
+    // Returns the file size. The size has signed type for consistency with
+    // stat::st_size.
+    FMT_API long long size() const;
 
-  // Attempts to read count bytes from the file into the specified buffer.
-  FMT_API std::size_t read(void *buffer, std::size_t count);
+    // Attempts to read count bytes from the file into the specified buffer.
+    FMT_API std::size_t read(void *buffer, std::size_t count);
 
-  // Attempts to write count bytes from the specified buffer to the file.
-  FMT_API std::size_t write(const void *buffer, std::size_t count);
+    // Attempts to write count bytes from the specified buffer to the file.
+    FMT_API 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.
-  FMT_API static file dup(int fd);
+    // Duplicates a file descriptor with the dup function and returns
+    // the duplicate as a file object.
+    FMT_API static file dup(int fd);
 
-  // Makes fd be the copy of this file descriptor, closing fd first if
-  // necessary.
-  FMT_API void dup2(int fd);
+    // Makes fd be the copy of this file descriptor, closing fd first if
+    // necessary.
+    FMT_API void dup2(int fd);
 
-  // Makes fd be the copy of this file descriptor, closing fd first if
-  // necessary.
-  FMT_API void dup2(int fd, error_code &ec) FMT_NOEXCEPT;
+    // Makes fd be the copy of this file descriptor, closing fd first if
+    // necessary.
+    FMT_API void dup2(int fd, error_code &ec) FMT_NOEXCEPT;
 
-  // Creates a pipe setting up read_end and write_end file objects for reading
-  // and writing respectively.
-  FMT_API static void pipe(file &read_end, file &write_end);
+    // Creates a pipe setting up read_end and write_end file objects for reading
+    // and writing respectively.
+    FMT_API static void pipe(file &read_end, file &write_end);
 
-  // Creates a buffered_file object associated with this file and detaches
-  // this file object from the file.
-  FMT_API buffered_file fdopen(const char *mode);
+    // Creates a buffered_file object associated with this file and detaches
+    // this file object from the file.
+    FMT_API buffered_file fdopen(const char *mode);
 };
 
 // Returns the memory page size.
 long getpagesize();
 
-#if (defined(LC_NUMERIC_MASK) || defined(_MSC_VER)) && \
-    !defined(__ANDROID__) && !defined(__CYGWIN__) && !defined(__OpenBSD__)
-# define FMT_LOCALE
+#if (defined(LC_NUMERIC_MASK) || defined(_MSC_VER)) && !defined(__ANDROID__) && !defined(__CYGWIN__) && !defined(__OpenBSD__)
+#define FMT_LOCALE
 #endif
 
 #ifdef FMT_LOCALE
 // A "C" numeric locale.
-class Locale {
- private:
-# ifdef _MSC_VER
-  typedef _locale_t locale_t;
+class Locale
+{
+private:
+#ifdef _MSC_VER
+    typedef _locale_t locale_t;
 
-  enum { LC_NUMERIC_MASK = LC_NUMERIC };
+    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 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 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
+    static double strtod_l(const char *nptr, char **endptr, _locale_t locale)
+    {
+        return _strtod_l(nptr, endptr, locale);
+    }
+#endif
 
-  locale_t locale_;
+    locale_t locale_;
 
-  FMT_DISALLOW_COPY_AND_ASSIGN(Locale);
+    FMT_DISALLOW_COPY_AND_ASSIGN(Locale);
 
- public:
-  typedef locale_t Type;
+public:
+    typedef locale_t Type;
 
-  Locale() : locale_(newlocale(LC_NUMERIC_MASK, "C", FMT_NULL)) {
-    if (!locale_)
-      FMT_THROW(system_error(errno, "cannot create locale"));
-  }
-  ~Locale() { freelocale(locale_); }
+    Locale()
+        : locale_(newlocale(LC_NUMERIC_MASK, "C", FMT_NULL))
+    {
+        if (!locale_)
+            FMT_THROW(system_error(errno, "cannot create locale"));
+    }
+    ~Locale()
+    {
+        freelocale(locale_);
+    }
 
-  Type get() const { return 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 = FMT_NULL;
-    double result = strtod_l(str, &end, locale_);
-    str = end;
-    return result;
-  }
+    // Converts string to floating-point number and advances str past the end
+    // of the parsed input.
+    double strtod(const char *&str) const
+    {
+        char *end = FMT_NULL;
+        double result = strtod_l(str, &end, locale_);
+        str = end;
+        return result;
+    }
 };
-#endif  // FMT_LOCALE
+#endif // FMT_LOCALE
 FMT_END_NAMESPACE
 
 #if !FMT_USE_RVALUE_REFERENCES
 namespace std {
 // For compatibility with C++98.
-inline fmt::buffered_file &move(fmt::buffered_file &f) { return f; }
-inline fmt::file &move(fmt::file &f) { return f; }
+inline fmt::buffered_file &move(fmt::buffered_file &f)
+{
+    return f;
 }
+inline fmt::file &move(fmt::file &f)
+{
+    return f;
+}
+} // namespace std
 #endif
 
-#endif  // FMT_POSIX_H_
+#endif // FMT_POSIX_H_
diff --git a/include/spdlog/fmt/bundled/printf.h b/include/spdlog/fmt/bundled/printf.h
index dd2df386..1782c2ea 100644
--- a/include/spdlog/fmt/bundled/printf.h
+++ b/include/spdlog/fmt/bundled/printf.h
@@ -8,8 +8,8 @@
 #ifndef FMT_PRINTF_H_
 #define FMT_PRINTF_H_
 
-#include <algorithm>  // std::fill_n
-#include <limits>     // std::numeric_limits
+#include <algorithm> // std::fill_n
+#include <limits>    // std::numeric_limits
 
 #include "ostream.h"
 
@@ -18,193 +18,231 @@ namespace internal {
 
 // Checks if a value fits in int - used to avoid warnings about comparing
 // signed and unsigned integers.
-template <bool IsSigned>
-struct int_checker {
-  template <typename T>
-  static bool fits_in_int(T value) {
-    unsigned max = std::numeric_limits<int>::max();
-    return value <= max;
-  }
-  static bool fits_in_int(bool) { return true; }
+template<bool IsSigned>
+struct int_checker
+{
+    template<typename T>
+    static bool fits_in_int(T value)
+    {
+        unsigned max = std::numeric_limits<int>::max();
+        return value <= max;
+    }
+    static bool fits_in_int(bool)
+    {
+        return true;
+    }
 };
 
-template <>
-struct int_checker<true> {
-  template <typename T>
-  static bool fits_in_int(T value) {
-    return value >= std::numeric_limits<int>::min() &&
-           value <= std::numeric_limits<int>::max();
-  }
-  static bool fits_in_int(int) { return true; }
+template<>
+struct int_checker<true>
+{
+    template<typename T>
+    static bool fits_in_int(T value)
+    {
+        return value >= std::numeric_limits<int>::min() && value <= std::numeric_limits<int>::max();
+    }
+    static bool fits_in_int(int)
+    {
+        return true;
+    }
 };
 
-class printf_precision_handler: public function<int> {
- public:
-  template <typename T>
-  typename std::enable_if<std::is_integral<T>::value, int>::type
-      operator()(T value) {
-    if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
-      FMT_THROW(format_error("number is too big"));
-    return static_cast<int>(value);
-  }
+class printf_precision_handler : public function<int>
+{
+public:
+    template<typename T>
+    typename std::enable_if<std::is_integral<T>::value, int>::type operator()(T value)
+    {
+        if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
+            FMT_THROW(format_error("number is too big"));
+        return static_cast<int>(value);
+    }
 
-  template <typename T>
-  typename std::enable_if<!std::is_integral<T>::value, int>::type operator()(T) {
-    FMT_THROW(format_error("precision is not integer"));
-    return 0;
-  }
+    template<typename T>
+    typename std::enable_if<!std::is_integral<T>::value, int>::type operator()(T)
+    {
+        FMT_THROW(format_error("precision is not integer"));
+        return 0;
+    }
 };
 
 // An argument visitor that returns true iff arg is a zero integer.
-class is_zero_int: public function<bool> {
- public:
-  template <typename T>
-  typename std::enable_if<std::is_integral<T>::value, bool>::type
-      operator()(T value) { return value == 0; }
-
-  template <typename T>
-  typename std::enable_if<!std::is_integral<T>::value, bool>::type
-      operator()(T) { return false; }
-};
-
-template <typename T>
-struct make_unsigned_or_bool : std::make_unsigned<T> {};
-
-template <>
-struct make_unsigned_or_bool<bool> {
-  typedef bool type;
-};
-
-template <typename T, typename Context>
-class arg_converter: public function<void> {
- private:
-  typedef typename Context::char_type Char;
-
-  basic_format_arg<Context> &arg_;
-  typename Context::char_type type_;
-
- public:
-  arg_converter(basic_format_arg<Context> &arg, Char type)
-    : arg_(arg), type_(type) {}
-
-  void operator()(bool value) {
-    if (type_ != 's')
-      operator()<bool>(value);
-  }
-
-  template <typename U>
-  typename std::enable_if<std::is_integral<U>::value>::type
-      operator()(U value) {
-    bool is_signed = type_ == 'd' || type_ == 'i';
-    typedef typename std::conditional<
-        std::is_same<T, void>::value, U, T>::type TargetType;
-    if (const_check(sizeof(TargetType) <= sizeof(int))) {
-      // Extra casts are used to silence warnings.
-      if (is_signed) {
-        arg_ = internal::make_arg<Context>(
-          static_cast<int>(static_cast<TargetType>(value)));
-      } else {
-        typedef typename make_unsigned_or_bool<TargetType>::type Unsigned;
-        arg_ = internal::make_arg<Context>(
-          static_cast<unsigned>(static_cast<Unsigned>(value)));
-      }
-    } else {
-      if (is_signed) {
-        // 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_ = internal::make_arg<Context>(static_cast<long long>(value));
-      } else {
-        arg_ = internal::make_arg<Context>(
-          static_cast<typename make_unsigned_or_bool<U>::type>(value));
-      }
+class is_zero_int : public function<bool>
+{
+public:
+    template<typename T>
+    typename std::enable_if<std::is_integral<T>::value, bool>::type operator()(T value)
+    {
+        return value == 0;
     }
-  }
 
-  template <typename U>
-  typename std::enable_if<!std::is_integral<U>::value>::type operator()(U) {
-    // No coversion needed for non-integral types.
-  }
+    template<typename T>
+    typename std::enable_if<!std::is_integral<T>::value, bool>::type operator()(T)
+    {
+        return false;
+    }
+};
+
+template<typename T>
+struct make_unsigned_or_bool : std::make_unsigned<T>
+{
+};
+
+template<>
+struct make_unsigned_or_bool<bool>
+{
+    typedef bool type;
+};
+
+template<typename T, typename Context>
+class arg_converter : public function<void>
+{
+private:
+    typedef typename Context::char_type Char;
+
+    basic_format_arg<Context> &arg_;
+    typename Context::char_type type_;
+
+public:
+    arg_converter(basic_format_arg<Context> &arg, Char type)
+        : arg_(arg)
+        , type_(type)
+    {
+    }
+
+    void operator()(bool value)
+    {
+        if (type_ != 's')
+            operator()<bool>(value);
+    }
+
+    template<typename U>
+    typename std::enable_if<std::is_integral<U>::value>::type operator()(U value)
+    {
+        bool is_signed = type_ == 'd' || type_ == 'i';
+        typedef typename std::conditional<std::is_same<T, void>::value, U, T>::type TargetType;
+        if (const_check(sizeof(TargetType) <= sizeof(int)))
+        {
+            // Extra casts are used to silence warnings.
+            if (is_signed)
+            {
+                arg_ = internal::make_arg<Context>(static_cast<int>(static_cast<TargetType>(value)));
+            }
+            else
+            {
+                typedef typename make_unsigned_or_bool<TargetType>::type Unsigned;
+                arg_ = internal::make_arg<Context>(static_cast<unsigned>(static_cast<Unsigned>(value)));
+            }
+        }
+        else
+        {
+            if (is_signed)
+            {
+                // 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_ = internal::make_arg<Context>(static_cast<long long>(value));
+            }
+            else
+            {
+                arg_ = internal::make_arg<Context>(static_cast<typename make_unsigned_or_bool<U>::type>(value));
+            }
+        }
+    }
+
+    template<typename U>
+    typename std::enable_if<!std::is_integral<U>::value>::type operator()(U)
+    {
+        // No coversion needed for non-integral types.
+    }
 };
 
 // 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, typename Context, typename Char>
-void convert_arg(basic_format_arg<Context> &arg, Char type) {
-  visit(arg_converter<T, Context>(arg, type), arg);
+template<typename T, typename Context, typename Char>
+void convert_arg(basic_format_arg<Context> &arg, Char type)
+{
+    visit(arg_converter<T, Context>(arg, type), arg);
 }
 
 // Converts an integer argument to char for printf.
-template <typename Context>
-class char_converter: public function<void> {
- private:
-  basic_format_arg<Context> &arg_;
+template<typename Context>
+class char_converter : public function<void>
+{
+private:
+    basic_format_arg<Context> &arg_;
 
-  FMT_DISALLOW_COPY_AND_ASSIGN(char_converter);
+    FMT_DISALLOW_COPY_AND_ASSIGN(char_converter);
 
- public:
-  explicit char_converter(basic_format_arg<Context> &arg) : arg_(arg) {}
+public:
+    explicit char_converter(basic_format_arg<Context> &arg)
+        : arg_(arg)
+    {
+    }
 
-  template <typename T>
-  typename std::enable_if<std::is_integral<T>::value>::type
-      operator()(T value) {
-    typedef typename Context::char_type Char;
-    arg_ = internal::make_arg<Context>(static_cast<Char>(value));
-  }
+    template<typename T>
+    typename std::enable_if<std::is_integral<T>::value>::type operator()(T value)
+    {
+        typedef typename Context::char_type Char;
+        arg_ = internal::make_arg<Context>(static_cast<Char>(value));
+    }
 
-  template <typename T>
-  typename std::enable_if<!std::is_integral<T>::value>::type operator()(T) {
-    // No coversion needed for non-integral types.
-  }
+    template<typename T>
+    typename std::enable_if<!std::is_integral<T>::value>::type operator()(T)
+    {
+        // No coversion needed for non-integral types.
+    }
 };
 
 // Checks if an argument is a valid printf width specifier and sets
 // left alignment if it is negative.
-template <typename Char>
-class printf_width_handler: public function<unsigned> {
- private:
-  typedef basic_format_specs<Char> format_specs;
+template<typename Char>
+class printf_width_handler : public function<unsigned>
+{
+private:
+    typedef basic_format_specs<Char> format_specs;
 
-  format_specs &spec_;
+    format_specs &spec_;
 
-  FMT_DISALLOW_COPY_AND_ASSIGN(printf_width_handler);
+    FMT_DISALLOW_COPY_AND_ASSIGN(printf_width_handler);
 
- public:
-  explicit printf_width_handler(format_specs &spec) : spec_(spec) {}
-
-  template <typename T>
-  typename std::enable_if<std::is_integral<T>::value, unsigned>::type
-      operator()(T value) {
-    typedef typename internal::int_traits<T>::main_type UnsignedType;
-    UnsignedType width = static_cast<UnsignedType>(value);
-    if (internal::is_negative(value)) {
-      spec_.align_ = ALIGN_LEFT;
-      width = 0 - width;
+public:
+    explicit printf_width_handler(format_specs &spec)
+        : spec_(spec)
+    {
     }
-    unsigned int_max = std::numeric_limits<int>::max();
-    if (width > int_max)
-      FMT_THROW(format_error("number is too big"));
-    return static_cast<unsigned>(width);
-  }
 
-  template <typename T>
-  typename std::enable_if<!std::is_integral<T>::value, unsigned>::type
-      operator()(T) {
-    FMT_THROW(format_error("width is not integer"));
-    return 0;
-  }
+    template<typename T>
+    typename std::enable_if<std::is_integral<T>::value, unsigned>::type operator()(T value)
+    {
+        typedef typename internal::int_traits<T>::main_type UnsignedType;
+        UnsignedType width = static_cast<UnsignedType>(value);
+        if (internal::is_negative(value))
+        {
+            spec_.align_ = ALIGN_LEFT;
+            width = 0 - width;
+        }
+        unsigned int_max = std::numeric_limits<int>::max();
+        if (width > int_max)
+            FMT_THROW(format_error("number is too big"));
+        return static_cast<unsigned>(width);
+    }
+
+    template<typename T>
+    typename std::enable_if<!std::is_integral<T>::value, unsigned>::type operator()(T)
+    {
+        FMT_THROW(format_error("width is not integer"));
+        return 0;
+    }
 };
-}  // namespace internal
+} // namespace internal
 
-template <typename Range>
+template<typename Range>
 class printf_arg_formatter;
 
-template <
-    typename OutputIt, typename Char,
-    typename ArgFormatter =
-      printf_arg_formatter<back_insert_range<internal::basic_buffer<Char>>>>
+template<typename OutputIt, typename Char, typename ArgFormatter = printf_arg_formatter<back_insert_range<internal::basic_buffer<Char>>>>
 class basic_printf_context;
 
 /**
@@ -212,385 +250,427 @@ class basic_printf_context;
   The ``printf`` argument formatter.
   \endrst
  */
-template <typename Range>
-class printf_arg_formatter:
-  public internal::function<
-    typename internal::arg_formatter_base<Range>::iterator>,
-  public internal::arg_formatter_base<Range> {
- private:
-  typedef typename Range::value_type char_type;
-  typedef decltype(internal::declval<Range>().begin()) iterator;
-  typedef internal::arg_formatter_base<Range> base;
-  typedef basic_printf_context<iterator, char_type> context_type;
+template<typename Range>
+class printf_arg_formatter : public internal::function<typename internal::arg_formatter_base<Range>::iterator>,
+                             public internal::arg_formatter_base<Range>
+{
+private:
+    typedef typename Range::value_type char_type;
+    typedef decltype(internal::declval<Range>().begin()) iterator;
+    typedef internal::arg_formatter_base<Range> base;
+    typedef basic_printf_context<iterator, char_type> context_type;
 
-  context_type &context_;
+    context_type &context_;
 
-  void write_null_pointer(char) {
-    this->spec().type_ = 0;
-    this->write("(nil)");
-  }
-
-  void write_null_pointer(wchar_t) {
-    this->spec().type_ = 0;
-    this->write(L"(nil)");
-  }
-
- public:
-  typedef typename base::format_specs format_specs;
-
-  /**
-    \rst
-    Constructs an argument formatter object.
-    *buffer* is a reference to the output buffer and *spec* contains format
-    specifier information for standard argument types.
-    \endrst
-   */
-  printf_arg_formatter(internal::basic_buffer<char_type> &buffer,
-                       format_specs &spec, context_type &ctx)
-    : base(back_insert_range<internal::basic_buffer<char_type>>(buffer), spec),
-      context_(ctx) {}
-
-  template <typename T>
-  typename std::enable_if<std::is_integral<T>::value, iterator>::type
-      operator()(T value) {
-    // MSVC2013 fails to compile separate overloads for bool and char_type so
-    // use std::is_same instead.
-    if (std::is_same<T, bool>::value) {
-      format_specs &fmt_spec = this->spec();
-      if (fmt_spec.type_ != 's')
-        return base::operator()(value ? 1 : 0);
-      fmt_spec.type_ = 0;
-      this->write(value != 0);
-    } else if (std::is_same<T, char_type>::value) {
-      format_specs &fmt_spec = this->spec();
-      if (fmt_spec.type_ && fmt_spec.type_ != 'c')
-        return (*this)(static_cast<int>(value));
-      fmt_spec.flags_ = 0;
-      fmt_spec.align_ = ALIGN_RIGHT;
-      return base::operator()(value);
-    } else {
-      return base::operator()(value);
+    void write_null_pointer(char)
+    {
+        this->spec().type_ = 0;
+        this->write("(nil)");
     }
-    return this->out();
-  }
 
-  template <typename T>
-  typename std::enable_if<std::is_floating_point<T>::value, iterator>::type
-      operator()(T value) {
-    return base::operator()(value);
-  }
+    void write_null_pointer(wchar_t)
+    {
+        this->spec().type_ = 0;
+        this->write(L"(nil)");
+    }
 
-  /** Formats a null-terminated C string. */
-  iterator operator()(const char *value) {
-    if (value)
-      base::operator()(value);
-    else if (this->spec().type_ == 'p')
-      write_null_pointer(char_type());
-    else
-      this->write("(null)");
-    return this->out();
-  }
+public:
+    typedef typename base::format_specs format_specs;
 
-  /** Formats a null-terminated wide C string. */
-  iterator operator()(const wchar_t *value) {
-    if (value)
-      base::operator()(value);
-    else if (this->spec().type_ == 'p')
-      write_null_pointer(char_type());
-    else
-      this->write(L"(null)");
-    return this->out();
-  }
+    /**
+      \rst
+      Constructs an argument formatter object.
+      *buffer* is a reference to the output buffer and *spec* contains format
+      specifier information for standard argument types.
+      \endrst
+     */
+    printf_arg_formatter(internal::basic_buffer<char_type> &buffer, format_specs &spec, context_type &ctx)
+        : base(back_insert_range<internal::basic_buffer<char_type>>(buffer), spec)
+        , context_(ctx)
+    {
+    }
 
-  iterator operator()(basic_string_view<char_type> value) {
-    return base::operator()(value);
-  }
+    template<typename T>
+    typename std::enable_if<std::is_integral<T>::value, iterator>::type operator()(T value)
+    {
+        // MSVC2013 fails to compile separate overloads for bool and char_type so
+        // use std::is_same instead.
+        if (std::is_same<T, bool>::value)
+        {
+            format_specs &fmt_spec = this->spec();
+            if (fmt_spec.type_ != 's')
+                return base::operator()(value ? 1 : 0);
+            fmt_spec.type_ = 0;
+            this->write(value != 0);
+        }
+        else if (std::is_same<T, char_type>::value)
+        {
+            format_specs &fmt_spec = this->spec();
+            if (fmt_spec.type_ && fmt_spec.type_ != 'c')
+                return (*this)(static_cast<int>(value));
+            fmt_spec.flags_ = 0;
+            fmt_spec.align_ = ALIGN_RIGHT;
+            return base::operator()(value);
+        }
+        else
+        {
+            return base::operator()(value);
+        }
+        return this->out();
+    }
 
-  iterator operator()(monostate value) {
-    return base::operator()(value);
-  }
+    template<typename T>
+    typename std::enable_if<std::is_floating_point<T>::value, iterator>::type operator()(T value)
+    {
+        return base::operator()(value);
+    }
 
-  /** Formats a pointer. */
-  iterator operator()(const void *value) {
-    if (value)
-      return base::operator()(value);
-    this->spec().type_ = 0;
-    write_null_pointer(char_type());
-    return this->out();
-  }
+    /** Formats a null-terminated C string. */
+    iterator operator()(const char *value)
+    {
+        if (value)
+            base::operator()(value);
+        else if (this->spec().type_ == 'p')
+            write_null_pointer(char_type());
+        else
+            this->write("(null)");
+        return this->out();
+    }
 
-  /** Formats an argument of a custom (user-defined) type. */
-  iterator operator()(typename basic_format_arg<context_type>::handle handle) {
-    handle.format(context_);
-    return this->out();
-  }
+    /** Formats a null-terminated wide C string. */
+    iterator operator()(const wchar_t *value)
+    {
+        if (value)
+            base::operator()(value);
+        else if (this->spec().type_ == 'p')
+            write_null_pointer(char_type());
+        else
+            this->write(L"(null)");
+        return this->out();
+    }
+
+    iterator operator()(basic_string_view<char_type> value)
+    {
+        return base::operator()(value);
+    }
+
+    iterator operator()(monostate value)
+    {
+        return base::operator()(value);
+    }
+
+    /** Formats a pointer. */
+    iterator operator()(const void *value)
+    {
+        if (value)
+            return base::operator()(value);
+        this->spec().type_ = 0;
+        write_null_pointer(char_type());
+        return this->out();
+    }
+
+    /** Formats an argument of a custom (user-defined) type. */
+    iterator operator()(typename basic_format_arg<context_type>::handle handle)
+    {
+        handle.format(context_);
+        return this->out();
+    }
 };
 
-template <typename T>
-struct printf_formatter {
-  template <typename ParseContext>
-  auto parse(ParseContext &ctx) -> decltype(ctx.begin()) { return ctx.begin(); }
+template<typename T>
+struct printf_formatter
+{
+    template<typename ParseContext>
+    auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+    {
+        return ctx.begin();
+    }
 
-  template <typename FormatContext>
-  auto format(const T &value, FormatContext &ctx) -> decltype(ctx.out()) {
-    internal::format_value(internal::get_container(ctx.out()), value);
-    return ctx.out();
-  }
+    template<typename FormatContext>
+    auto format(const T &value, FormatContext &ctx) -> decltype(ctx.out())
+    {
+        internal::format_value(internal::get_container(ctx.out()), value);
+        return ctx.out();
+    }
 };
 
 /** This template formats data and writes the output to a writer. */
-template <typename OutputIt, typename Char, typename ArgFormatter>
-class basic_printf_context :
-  private internal::context_base<
-    OutputIt, basic_printf_context<OutputIt, Char, ArgFormatter>, Char> {
- public:
-  /** The character type for the output. */
-  typedef Char char_type;
+template<typename OutputIt, typename Char, typename ArgFormatter>
+class basic_printf_context : private internal::context_base<OutputIt, basic_printf_context<OutputIt, Char, ArgFormatter>, Char>
+{
+public:
+    /** The character type for the output. */
+    typedef Char char_type;
 
-  template <typename T>
-  struct formatter_type { typedef printf_formatter<T> type; };
+    template<typename T>
+    struct formatter_type
+    {
+        typedef printf_formatter<T> type;
+    };
 
- private:
-  typedef internal::context_base<OutputIt, basic_printf_context, Char> base;
-  typedef typename base::format_arg format_arg;
-  typedef basic_format_specs<char_type> format_specs;
-  typedef internal::null_terminating_iterator<char_type> iterator;
+private:
+    typedef internal::context_base<OutputIt, basic_printf_context, Char> base;
+    typedef typename base::format_arg format_arg;
+    typedef basic_format_specs<char_type> format_specs;
+    typedef internal::null_terminating_iterator<char_type> iterator;
 
-  void parse_flags(format_specs &spec, iterator &it);
+    void parse_flags(format_specs &spec, iterator &it);
 
-  // Returns the argument with specified index or, if arg_index is equal
-  // to the maximum unsigned value, the next argument.
-  format_arg get_arg(
-      iterator it,
-      unsigned arg_index = (std::numeric_limits<unsigned>::max)());
+    // Returns the argument with specified index or, if arg_index is equal
+    // to the maximum unsigned value, the next argument.
+    format_arg get_arg(iterator it, unsigned arg_index = (std::numeric_limits<unsigned>::max)());
 
-  // Parses argument index, flags and width and returns the argument index.
-  unsigned parse_header(iterator &it, format_specs &spec);
+    // Parses argument index, flags and width and returns the argument index.
+    unsigned parse_header(iterator &it, format_specs &spec);
 
- public:
-  /**
-   \rst
-   Constructs a ``printf_context`` object. References to the arguments and
-   the writer are stored in the context object so make sure they have
-   appropriate lifetimes.
-   \endrst
-   */
-  basic_printf_context(OutputIt out, basic_string_view<char_type> format_str,
-                       basic_format_args<basic_printf_context> args)
-    : base(out, format_str, args) {}
+public:
+    /**
+     \rst
+     Constructs a ``printf_context`` object. References to the arguments and
+     the writer are stored in the context object so make sure they have
+     appropriate lifetimes.
+     \endrst
+     */
+    basic_printf_context(OutputIt out, basic_string_view<char_type> format_str, basic_format_args<basic_printf_context> args)
+        : base(out, format_str, args)
+    {
+    }
 
-  using base::parse_context;
-  using base::out;
-  using base::advance_to;
+    using base::advance_to;
+    using base::out;
+    using base::parse_context;
 
-  /** Formats stored arguments and writes the output to the range. */
-  void format();
+    /** Formats stored arguments and writes the output to the range. */
+    void format();
 };
 
-template <typename OutputIt, typename Char, typename AF>
-void basic_printf_context<OutputIt, Char, AF>::parse_flags(
-    format_specs &spec, iterator &it) {
-  for (;;) {
-    switch (*it++) {
-      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:
-        --it;
-        return;
+template<typename OutputIt, typename Char, typename AF>
+void basic_printf_context<OutputIt, Char, AF>::parse_flags(format_specs &spec, iterator &it)
+{
+    for (;;)
+    {
+        switch (*it++)
+        {
+        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:
+            --it;
+            return;
+        }
     }
-  }
 }
 
-template <typename OutputIt, typename Char, typename AF>
-typename basic_printf_context<OutputIt, Char, AF>::format_arg
-  basic_printf_context<OutputIt, Char, AF>::get_arg(
-    iterator it, unsigned arg_index) {
-  (void)it;
-  if (arg_index == std::numeric_limits<unsigned>::max())
-    return this->do_get_arg(this->parse_context().next_arg_id());
-  return base::get_arg(arg_index - 1);
+template<typename OutputIt, typename Char, typename AF>
+typename basic_printf_context<OutputIt, Char, AF>::format_arg basic_printf_context<OutputIt, Char, AF>::get_arg(
+    iterator it, unsigned arg_index)
+{
+    (void)it;
+    if (arg_index == std::numeric_limits<unsigned>::max())
+        return this->do_get_arg(this->parse_context().next_arg_id());
+    return base::get_arg(arg_index - 1);
 }
 
-template <typename OutputIt, typename Char, typename AF>
-unsigned basic_printf_context<OutputIt, Char, AF>::parse_header(
-  iterator &it, format_specs &spec) {
-  unsigned arg_index = std::numeric_limits<unsigned>::max();
-  char_type c = *it;
-  if (c >= '0' && c <= '9') {
-    // Parse an argument index (if followed by '$') or a width possibly
-    // preceded with '0' flag(s).
-    internal::error_handler eh;
-    unsigned value = parse_nonnegative_int(it, eh);
-    if (*it == '$') {  // value is an argument index
-      ++it;
-      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, it);
-  // Parse width.
-  if (*it >= '0' && *it <= '9') {
-    internal::error_handler eh;
-    spec.width_ = parse_nonnegative_int(it, eh);
-  } else if (*it == '*') {
-    ++it;
-    spec.width_ =
-        visit(internal::printf_width_handler<char_type>(spec), get_arg(it));
-  }
-  return arg_index;
-}
-
-template <typename OutputIt, typename Char, typename AF>
-void basic_printf_context<OutputIt, Char, AF>::format() {
-  auto &buffer = internal::get_container(this->out());
-  auto start = iterator(this->parse_context());
-  auto it = start;
-  using internal::pointer_from;
-  while (*it) {
-    char_type c = *it++;
-    if (c != '%') continue;
-    if (*it == c) {
-      buffer.append(pointer_from(start), pointer_from(it));
-      start = ++it;
-      continue;
-    }
-    buffer.append(pointer_from(start), pointer_from(it) - 1);
-
-    format_specs spec;
-    spec.align_ = ALIGN_RIGHT;
-
-    // Parse argument index, flags and width.
-    unsigned arg_index = parse_header(it, spec);
-
-    // Parse precision.
-    if (*it == '.') {
-      ++it;
-      if ('0' <= *it && *it <= '9') {
+template<typename OutputIt, typename Char, typename AF>
+unsigned basic_printf_context<OutputIt, Char, AF>::parse_header(iterator &it, format_specs &spec)
+{
+    unsigned arg_index = std::numeric_limits<unsigned>::max();
+    char_type c = *it;
+    if (c >= '0' && c <= '9')
+    {
+        // Parse an argument index (if followed by '$') or a width possibly
+        // preceded with '0' flag(s).
         internal::error_handler eh;
-        spec.precision_ = static_cast<int>(parse_nonnegative_int(it, eh));
-      } else if (*it == '*') {
+        unsigned value = parse_nonnegative_int(it, eh);
+        if (*it == '$')
+        { // value is an argument index
+            ++it;
+            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, it);
+    // Parse width.
+    if (*it >= '0' && *it <= '9')
+    {
+        internal::error_handler eh;
+        spec.width_ = parse_nonnegative_int(it, eh);
+    }
+    else if (*it == '*')
+    {
         ++it;
-        spec.precision_ =
-            visit(internal::printf_precision_handler(), get_arg(it));
-      } else {
-        spec.precision_ = 0;
-      }
+        spec.width_ = visit(internal::printf_width_handler<char_type>(spec), get_arg(it));
     }
-
-    format_arg arg = get_arg(it, arg_index);
-    if (spec.flag(HASH_FLAG) && visit(internal::is_zero_int(), arg))
-      spec.flags_ &= ~internal::to_unsigned<int>(HASH_FLAG);
-    if (spec.fill_ == '0') {
-      if (arg.is_arithmetic())
-        spec.align_ = ALIGN_NUMERIC;
-      else
-        spec.fill_ = ' ';  // Ignore '0' flag for non-numeric types.
-    }
-
-    // Parse length and convert the argument to the required type.
-    using internal::convert_arg;
-    switch (*it++) {
-    case 'h':
-      if (*it == 'h')
-        convert_arg<signed char>(arg, *++it);
-      else
-        convert_arg<short>(arg, *it);
-      break;
-    case 'l':
-      if (*it == 'l')
-        convert_arg<long long>(arg, *++it);
-      else
-        convert_arg<long>(arg, *it);
-      break;
-    case 'j':
-      convert_arg<intmax_t>(arg, *it);
-      break;
-    case 'z':
-      convert_arg<std::size_t>(arg, *it);
-      break;
-    case 't':
-      convert_arg<std::ptrdiff_t>(arg, *it);
-      break;
-    case 'L':
-      // printf produces garbage when 'L' is omitted for long double, no
-      // need to do the same.
-      break;
-    default:
-      --it;
-      convert_arg<void>(arg, *it);
-    }
-
-    // Parse type.
-    if (!*it)
-      FMT_THROW(format_error("invalid format string"));
-    spec.type_ = static_cast<char>(*it++);
-    if (arg.is_integral()) {
-      // Normalize type.
-      switch (spec.type_) {
-      case 'i': case 'u':
-        spec.type_ = 'd';
-        break;
-      case 'c':
-        // TODO: handle wchar_t better?
-        visit(internal::char_converter<basic_printf_context>(arg), arg);
-        break;
-      }
-    }
-
-    start = it;
-
-    // Format argument.
-    visit(AF(buffer, spec, *this), arg);
-  }
-  buffer.append(pointer_from(start), pointer_from(it));
+    return arg_index;
 }
 
-template <typename Char, typename Context>
-void printf(internal::basic_buffer<Char> &buf, basic_string_view<Char> format,
-            basic_format_args<Context> args) {
-  Context(std::back_inserter(buf), format, args).format();
+template<typename OutputIt, typename Char, typename AF>
+void basic_printf_context<OutputIt, Char, AF>::format()
+{
+    auto &buffer = internal::get_container(this->out());
+    auto start = iterator(this->parse_context());
+    auto it = start;
+    using internal::pointer_from;
+    while (*it)
+    {
+        char_type c = *it++;
+        if (c != '%')
+            continue;
+        if (*it == c)
+        {
+            buffer.append(pointer_from(start), pointer_from(it));
+            start = ++it;
+            continue;
+        }
+        buffer.append(pointer_from(start), pointer_from(it) - 1);
+
+        format_specs spec;
+        spec.align_ = ALIGN_RIGHT;
+
+        // Parse argument index, flags and width.
+        unsigned arg_index = parse_header(it, spec);
+
+        // Parse precision.
+        if (*it == '.')
+        {
+            ++it;
+            if ('0' <= *it && *it <= '9')
+            {
+                internal::error_handler eh;
+                spec.precision_ = static_cast<int>(parse_nonnegative_int(it, eh));
+            }
+            else if (*it == '*')
+            {
+                ++it;
+                spec.precision_ = visit(internal::printf_precision_handler(), get_arg(it));
+            }
+            else
+            {
+                spec.precision_ = 0;
+            }
+        }
+
+        format_arg arg = get_arg(it, arg_index);
+        if (spec.flag(HASH_FLAG) && visit(internal::is_zero_int(), arg))
+            spec.flags_ &= ~internal::to_unsigned<int>(HASH_FLAG);
+        if (spec.fill_ == '0')
+        {
+            if (arg.is_arithmetic())
+                spec.align_ = ALIGN_NUMERIC;
+            else
+                spec.fill_ = ' '; // Ignore '0' flag for non-numeric types.
+        }
+
+        // Parse length and convert the argument to the required type.
+        using internal::convert_arg;
+        switch (*it++)
+        {
+        case 'h':
+            if (*it == 'h')
+                convert_arg<signed char>(arg, *++it);
+            else
+                convert_arg<short>(arg, *it);
+            break;
+        case 'l':
+            if (*it == 'l')
+                convert_arg<long long>(arg, *++it);
+            else
+                convert_arg<long>(arg, *it);
+            break;
+        case 'j':
+            convert_arg<intmax_t>(arg, *it);
+            break;
+        case 'z':
+            convert_arg<std::size_t>(arg, *it);
+            break;
+        case 't':
+            convert_arg<std::ptrdiff_t>(arg, *it);
+            break;
+        case 'L':
+            // printf produces garbage when 'L' is omitted for long double, no
+            // need to do the same.
+            break;
+        default:
+            --it;
+            convert_arg<void>(arg, *it);
+        }
+
+        // Parse type.
+        if (!*it)
+            FMT_THROW(format_error("invalid format string"));
+        spec.type_ = static_cast<char>(*it++);
+        if (arg.is_integral())
+        {
+            // Normalize type.
+            switch (spec.type_)
+            {
+            case 'i':
+            case 'u':
+                spec.type_ = 'd';
+                break;
+            case 'c':
+                // TODO: handle wchar_t better?
+                visit(internal::char_converter<basic_printf_context>(arg), arg);
+                break;
+            }
+        }
+
+        start = it;
+
+        // Format argument.
+        visit(AF(buffer, spec, *this), arg);
+    }
+    buffer.append(pointer_from(start), pointer_from(it));
 }
 
-template <typename Buffer>
-struct printf_context {
-  typedef basic_printf_context<
-    std::back_insert_iterator<Buffer>, typename Buffer::value_type> type;
+template<typename Char, typename Context>
+void printf(internal::basic_buffer<Char> &buf, basic_string_view<Char> format, basic_format_args<Context> args)
+{
+    Context(std::back_inserter(buf), format, args).format();
+}
+
+template<typename Buffer>
+struct printf_context
+{
+    typedef basic_printf_context<std::back_insert_iterator<Buffer>, typename Buffer::value_type> type;
 };
 
-template <typename ...Args>
-inline format_arg_store<printf_context<internal::buffer>::type, Args...>
-    make_printf_args(const Args & ... args) {
-  return format_arg_store<printf_context<internal::buffer>::type, Args...>(
-      args...);
+template<typename... Args>
+inline format_arg_store<printf_context<internal::buffer>::type, Args...> make_printf_args(const Args &... args)
+{
+    return format_arg_store<printf_context<internal::buffer>::type, Args...>(args...);
 }
 typedef basic_format_args<printf_context<internal::buffer>::type> printf_args;
 typedef basic_format_args<printf_context<internal::wbuffer>::type> wprintf_args;
 
-inline std::string vsprintf(string_view format, printf_args args) {
-  memory_buffer buffer;
-  printf(buffer, format, args);
-  return to_string(buffer);
+inline std::string vsprintf(string_view format, printf_args args)
+{
+    memory_buffer buffer;
+    printf(buffer, format, args);
+    return to_string(buffer);
 }
 
 /**
@@ -602,33 +682,33 @@ inline std::string vsprintf(string_view format, printf_args args) {
     std::string message = fmt::sprintf("The answer is %d", 42);
   \endrst
 */
-template <typename... Args>
-inline std::string sprintf(string_view format_str, const Args & ... args) {
-  return vsprintf(format_str,
-    make_format_args<typename printf_context<internal::buffer>::type>(args...));
+template<typename... Args>
+inline std::string sprintf(string_view format_str, const Args &... args)
+{
+    return vsprintf(format_str, make_format_args<typename printf_context<internal::buffer>::type>(args...));
 }
 
-inline std::wstring vsprintf(wstring_view format, wprintf_args args) {
-  wmemory_buffer buffer;
-  printf(buffer, format, args);
-  return to_string(buffer);
+inline std::wstring vsprintf(wstring_view format, wprintf_args args)
+{
+    wmemory_buffer buffer;
+    printf(buffer, format, args);
+    return to_string(buffer);
 }
 
-template <typename... Args>
-inline std::wstring sprintf(wstring_view format_str, const Args & ... args) {
-  return vsprintf(format_str,
-    make_format_args<typename printf_context<internal::wbuffer>::type>(args...));
+template<typename... Args>
+inline std::wstring sprintf(wstring_view format_str, const Args &... args)
+{
+    return vsprintf(format_str, make_format_args<typename printf_context<internal::wbuffer>::type>(args...));
 }
 
-template <typename Char>
-inline int vfprintf(std::FILE *f, basic_string_view<Char> format,
-                    basic_format_args<typename printf_context<
-                      internal::basic_buffer<Char>>::type> args) {
-  basic_memory_buffer<Char> buffer;
-  printf(buffer, format, args);
-  std::size_t size = buffer.size();
-  return std::fwrite(
-    buffer.data(), sizeof(Char), size, f) < size ? -1 : static_cast<int>(size);
+template<typename Char>
+inline int vfprintf(
+    std::FILE *f, basic_string_view<Char> format, basic_format_args<typename printf_context<internal::basic_buffer<Char>>::type> args)
+{
+    basic_memory_buffer<Char> buffer;
+    printf(buffer, format, args);
+    std::size_t size = buffer.size();
+    return std::fwrite(buffer.data(), sizeof(Char), size, f) < size ? -1 : static_cast<int>(size);
 }
 
 /**
@@ -640,26 +720,27 @@ inline int vfprintf(std::FILE *f, basic_string_view<Char> format,
     fmt::fprintf(stderr, "Don't %s!", "panic");
   \endrst
  */
-template <typename... Args>
-inline int fprintf(std::FILE *f, string_view format_str, const Args & ... args) {
-  auto vargs = make_format_args<
-    typename printf_context<internal::buffer>::type>(args...);
-  return vfprintf<char>(f, format_str, vargs);
+template<typename... Args>
+inline int fprintf(std::FILE *f, string_view format_str, const Args &... args)
+{
+    auto vargs = make_format_args<typename printf_context<internal::buffer>::type>(args...);
+    return vfprintf<char>(f, format_str, vargs);
 }
 
-template <typename... Args>
-inline int fprintf(std::FILE *f, wstring_view format_str,
-                   const Args & ... args) {
-  return vfprintf(f, format_str,
-    make_format_args<typename printf_context<internal::wbuffer>::type>(args...));
+template<typename... Args>
+inline int fprintf(std::FILE *f, wstring_view format_str, const Args &... args)
+{
+    return vfprintf(f, format_str, make_format_args<typename printf_context<internal::wbuffer>::type>(args...));
 }
 
-inline int vprintf(string_view format, printf_args args) {
-  return vfprintf(stdout, format, args);
+inline int vprintf(string_view format, printf_args args)
+{
+    return vfprintf(stdout, format, args);
 }
 
-inline int vprintf(wstring_view format, wprintf_args args) {
-  return vfprintf(stdout, format, args);
+inline int vprintf(wstring_view format, wprintf_args args)
+{
+    return vfprintf(stdout, format, args);
 }
 
 /**
@@ -671,32 +752,32 @@ inline int vprintf(wstring_view format, wprintf_args args) {
     fmt::printf("Elapsed time: %.2f seconds", 1.23);
   \endrst
  */
-template <typename... Args>
-inline int printf(string_view format_str, const Args & ... args) {
-  return vprintf(format_str,
-    make_format_args<typename printf_context<internal::buffer>::type>(args...));
+template<typename... Args>
+inline int printf(string_view format_str, const Args &... args)
+{
+    return vprintf(format_str, make_format_args<typename printf_context<internal::buffer>::type>(args...));
 }
 
-template <typename... Args>
-inline int printf(wstring_view format_str, const Args & ... args) {
-  return vprintf(format_str,
-    make_format_args<typename printf_context<internal::wbuffer>::type>(args...));
+template<typename... Args>
+inline int printf(wstring_view format_str, const Args &... args)
+{
+    return vprintf(format_str, make_format_args<typename printf_context<internal::wbuffer>::type>(args...));
 }
 
-inline int vfprintf(std::ostream &os, string_view format_str,
-                    printf_args args) {
-  memory_buffer buffer;
-  printf(buffer, format_str, args);
-  internal::write(os, buffer);
-  return static_cast<int>(buffer.size());
+inline int vfprintf(std::ostream &os, string_view format_str, printf_args args)
+{
+    memory_buffer buffer;
+    printf(buffer, format_str, args);
+    internal::write(os, buffer);
+    return static_cast<int>(buffer.size());
 }
 
-inline int vfprintf(std::wostream &os, wstring_view format_str,
-                    wprintf_args args) {
-  wmemory_buffer buffer;
-  printf(buffer, format_str, args);
-  internal::write(os, buffer);
-  return static_cast<int>(buffer.size());
+inline int vfprintf(std::wostream &os, wstring_view format_str, wprintf_args args)
+{
+    wmemory_buffer buffer;
+    printf(buffer, format_str, args);
+    internal::write(os, buffer);
+    return static_cast<int>(buffer.size());
 }
 
 /**
@@ -708,21 +789,19 @@ inline int vfprintf(std::wostream &os, wstring_view format_str,
     fmt::fprintf(cerr, "Don't %s!", "panic");
   \endrst
  */
-template <typename... Args>
-inline int fprintf(std::ostream &os, string_view format_str,
-                   const Args & ... args) {
-  auto vargs = make_format_args<
-    typename printf_context<internal::buffer>::type>(args...);
-  return vfprintf(os, format_str, vargs);
+template<typename... Args>
+inline int fprintf(std::ostream &os, string_view format_str, const Args &... args)
+{
+    auto vargs = make_format_args<typename printf_context<internal::buffer>::type>(args...);
+    return vfprintf(os, format_str, vargs);
 }
 
-template <typename... Args>
-inline int fprintf(std::wostream &os, wstring_view format_str,
-                   const Args & ... args) {
-  auto vargs = make_format_args<
-    typename printf_context<internal::buffer>::type>(args...);
-  return vfprintf(os, format_str, vargs);
+template<typename... Args>
+inline int fprintf(std::wostream &os, wstring_view format_str, const Args &... args)
+{
+    auto vargs = make_format_args<typename printf_context<internal::buffer>::type>(args...);
+    return vfprintf(os, format_str, vargs);
 }
 FMT_END_NAMESPACE
 
-#endif  // FMT_PRINTF_H_
+#endif // FMT_PRINTF_H_
diff --git a/include/spdlog/fmt/bundled/ranges.h b/include/spdlog/fmt/bundled/ranges.h
index df22f389..c5d8c356 100644
--- a/include/spdlog/fmt/bundled/ranges.h
+++ b/include/spdlog/fmt/bundled/ranges.h
@@ -17,289 +17,328 @@
 
 // output only up to N items from the range.
 #ifndef FMT_RANGE_OUTPUT_LENGTH_LIMIT
-# define FMT_RANGE_OUTPUT_LENGTH_LIMIT 256
+#define FMT_RANGE_OUTPUT_LENGTH_LIMIT 256
 #endif
 
 FMT_BEGIN_NAMESPACE
 
-template <typename Char>
-struct formatting_base {
-  template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
-    return ctx.begin();
-  }
+template<typename Char>
+struct formatting_base
+{
+    template<typename ParseContext>
+    FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+    {
+        return ctx.begin();
+    }
 };
 
-template <typename Char, typename Enable = void>
-struct formatting_range : formatting_base<Char> {
-  static FMT_CONSTEXPR_DECL const std::size_t range_length_limit =
-      FMT_RANGE_OUTPUT_LENGTH_LIMIT; // output only up to N items from the range.
-  Char prefix;
-  Char delimiter;
-  Char postfix;
-  formatting_range() : prefix('{'), delimiter(','), postfix('}') {}
-  static FMT_CONSTEXPR_DECL const bool add_delimiter_spaces = true;
-  static FMT_CONSTEXPR_DECL const bool add_prepostfix_space = false;
+template<typename Char, typename Enable = void>
+struct formatting_range : formatting_base<Char>
+{
+    static FMT_CONSTEXPR_DECL const std::size_t range_length_limit =
+        FMT_RANGE_OUTPUT_LENGTH_LIMIT; // output only up to N items from the range.
+    Char prefix;
+    Char delimiter;
+    Char postfix;
+    formatting_range()
+        : prefix('{')
+        , delimiter(',')
+        , postfix('}')
+    {
+    }
+    static FMT_CONSTEXPR_DECL const bool add_delimiter_spaces = true;
+    static FMT_CONSTEXPR_DECL const bool add_prepostfix_space = false;
 };
 
-template <typename Char, typename Enable = void>
-struct formatting_tuple : formatting_base<Char> {
-  Char prefix;
-  Char delimiter;
-  Char postfix;
-  formatting_tuple() : prefix('('), delimiter(','), postfix(')') {}
-  static FMT_CONSTEXPR_DECL const bool add_delimiter_spaces = true;
-  static FMT_CONSTEXPR_DECL const bool add_prepostfix_space = false;
+template<typename Char, typename Enable = void>
+struct formatting_tuple : formatting_base<Char>
+{
+    Char prefix;
+    Char delimiter;
+    Char postfix;
+    formatting_tuple()
+        : prefix('(')
+        , delimiter(',')
+        , postfix(')')
+    {
+    }
+    static FMT_CONSTEXPR_DECL const bool add_delimiter_spaces = true;
+    static FMT_CONSTEXPR_DECL const bool add_prepostfix_space = false;
 };
 
 namespace internal {
 
-template <typename RangeT, typename OutputIterator>
-void copy(const RangeT &range, OutputIterator out) {
-  for (auto it = range.begin(), end = range.end(); it != end; ++it)
-    *out++ = *it;
+template<typename RangeT, typename OutputIterator>
+void copy(const RangeT &range, OutputIterator out)
+{
+    for (auto it = range.begin(), end = range.end(); it != end; ++it)
+        *out++ = *it;
 }
 
-template <typename OutputIterator>
-void copy(const char *str, OutputIterator out) {
-  const char *p_curr = str;
-  while (*p_curr) {
-    *out++ = *p_curr++;
-  }
+template<typename OutputIterator>
+void copy(const char *str, OutputIterator out)
+{
+    const char *p_curr = str;
+    while (*p_curr)
+    {
+        *out++ = *p_curr++;
+    }
 }
 
-template <typename OutputIterator>
-void copy(char ch, OutputIterator out) {
-  *out++ = ch;
+template<typename OutputIterator>
+void copy(char ch, OutputIterator out)
+{
+    *out++ = ch;
 }
 
 /// Return true value if T has std::string interface, like std::string_view.
-template <typename T>
-class is_like_std_string {
-  template <typename U>
-  static auto check(U *p) ->
-    decltype(p->find('a'), p->length(), p->data(), int());
-  template <typename>
-  static void check(...);
+template<typename T>
+class is_like_std_string
+{
+    template<typename U>
+    static auto check(U *p) -> decltype(p->find('a'), p->length(), p->data(), int());
+    template<typename>
+    static void check(...);
 
- public:
-  static FMT_CONSTEXPR_DECL const bool value =
-    !std::is_void<decltype(check<T>(FMT_NULL))>::value;
+public:
+    static FMT_CONSTEXPR_DECL const bool value = !std::is_void<decltype(check<T>(FMT_NULL))>::value;
 };
 
-template <typename... Ts>
-struct conditional_helper {};
+template<typename... Ts>
+struct conditional_helper
+{
+};
 
-template <typename T, typename _ = void>
-struct is_range_ : std::false_type {};
+template<typename T, typename _ = void>
+struct is_range_ : std::false_type
+{
+};
 
 #if !FMT_MSC_VER || FMT_MSC_VER > 1800
-template <typename T>
-struct is_range_<T, typename std::conditional<
-                    false,
-                    conditional_helper<decltype(internal::declval<T>().begin()),
-                                       decltype(internal::declval<T>().end())>,
-                    void>::type> : std::true_type {};
+template<typename T>
+struct is_range_<T, typename std::conditional<false,
+                        conditional_helper<decltype(internal::declval<T>().begin()), decltype(internal::declval<T>().end())>, void>::type>
+    : std::true_type
+{
+};
 #endif
 
 /// tuple_size and tuple_element check.
-template <typename T>
-class is_tuple_like_ {
-  template <typename U>
-  static auto check(U *p) ->
-    decltype(std::tuple_size<U>::value,
-      internal::declval<typename std::tuple_element<0, U>::type>(), int());
-  template <typename>
-  static void check(...);
+template<typename T>
+class is_tuple_like_
+{
+    template<typename U>
+    static auto check(U *p) -> decltype(std::tuple_size<U>::value, internal::declval<typename std::tuple_element<0, U>::type>(), int());
+    template<typename>
+    static void check(...);
 
- public:
-  static FMT_CONSTEXPR_DECL const bool value =
-    !std::is_void<decltype(check<T>(FMT_NULL))>::value;
+public:
+    static FMT_CONSTEXPR_DECL const bool value = !std::is_void<decltype(check<T>(FMT_NULL))>::value;
 };
 
 // Check for integer_sequence
 #if defined(__cpp_lib_integer_sequence) || FMT_MSC_VER >= 1900
-template <typename T, T... N>
+template<typename T, T... N>
 using integer_sequence = std::integer_sequence<T, N...>;
-template <std::size_t... N>
+template<std::size_t... N>
 using index_sequence = std::index_sequence<N...>;
-template <std::size_t N>
+template<std::size_t N>
 using make_index_sequence = std::make_index_sequence<N>;
 #else
-template <typename T, T... N>
-struct integer_sequence {
-  typedef T value_type;
+template<typename T, T... N>
+struct integer_sequence
+{
+    typedef T value_type;
 
-  static FMT_CONSTEXPR std::size_t size() {
-    return sizeof...(N);
-  }
+    static FMT_CONSTEXPR std::size_t size()
+    {
+        return sizeof...(N);
+    }
 };
 
-template <std::size_t... N>
+template<std::size_t... N>
 using index_sequence = integer_sequence<std::size_t, N...>;
 
-template <typename T, std::size_t N, T... Ns>
-struct make_integer_sequence : make_integer_sequence<T, N - 1, N - 1, Ns...> {};
-template <typename T, T... Ns>
-struct make_integer_sequence<T, 0, Ns...> : integer_sequence<T, Ns...> {};
+template<typename T, std::size_t N, T... Ns>
+struct make_integer_sequence : make_integer_sequence<T, N - 1, N - 1, Ns...>
+{
+};
+template<typename T, T... Ns>
+struct make_integer_sequence<T, 0, Ns...> : integer_sequence<T, Ns...>
+{
+};
 
-template <std::size_t N>
+template<std::size_t N>
 using make_index_sequence = make_integer_sequence<std::size_t, N>;
 #endif
 
-template <class Tuple, class F, size_t... Is>
-void for_each(index_sequence<Is...>, Tuple &&tup, F &&f) FMT_NOEXCEPT {
-  using std::get;
-  // using free function get<I>(T) now.
-  const int _[] = {0, ((void)f(get<Is>(tup)), 0)...};
-  (void)_;  // blocks warnings
+template<class Tuple, class F, size_t... Is>
+void for_each(index_sequence<Is...>, Tuple &&tup, F &&f) FMT_NOEXCEPT
+{
+    using std::get;
+    // using free function get<I>(T) now.
+    const int _[] = {0, ((void)f(get<Is>(tup)), 0)...};
+    (void)_; // blocks warnings
 }
 
-template <class T>
-FMT_CONSTEXPR make_index_sequence<std::tuple_size<T>::value> 
-get_indexes(T const &) { return {}; }
+template<class T>
+FMT_CONSTEXPR make_index_sequence<std::tuple_size<T>::value> get_indexes(T const &)
+{
+    return {};
+}
 
-template <class Tuple, class F>
-void for_each(Tuple &&tup, F &&f) {
-  const auto indexes = get_indexes(tup);
-  for_each(indexes, std::forward<Tuple>(tup), std::forward<F>(f));
+template<class Tuple, class F>
+void for_each(Tuple &&tup, F &&f)
+{
+    const auto indexes = get_indexes(tup);
+    for_each(indexes, std::forward<Tuple>(tup), std::forward<F>(f));
 }
 
 template<typename Arg>
-FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const Arg&, 
-  typename std::enable_if<
-    !is_like_std_string<typename std::decay<Arg>::type>::value>::type* = nullptr) {
-  return add_space ? " {}" : "{}";
+FMT_CONSTEXPR const char *format_str_quoted(
+    bool add_space, const Arg &, typename std::enable_if<!is_like_std_string<typename std::decay<Arg>::type>::value>::type * = nullptr)
+{
+    return add_space ? " {}" : "{}";
 }
 
 template<typename Arg>
-FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const Arg&, 
-  typename std::enable_if<
-    is_like_std_string<typename std::decay<Arg>::type>::value>::type* = nullptr) {
-  return add_space ? " \"{}\"" : "\"{}\"";
+FMT_CONSTEXPR const char *format_str_quoted(
+    bool add_space, const Arg &, typename std::enable_if<is_like_std_string<typename std::decay<Arg>::type>::value>::type * = nullptr)
+{
+    return add_space ? " \"{}\"" : "\"{}\"";
 }
 
-FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const char*) {
-  return add_space ? " \"{}\"" : "\"{}\"";
+FMT_CONSTEXPR const char *format_str_quoted(bool add_space, const char *)
+{
+    return add_space ? " \"{}\"" : "\"{}\"";
 }
-FMT_CONSTEXPR const wchar_t* format_str_quoted(bool add_space, const wchar_t*) {
+FMT_CONSTEXPR const wchar_t *format_str_quoted(bool add_space, const wchar_t *)
+{
     return add_space ? L" \"{}\"" : L"\"{}\"";
 }
 
-FMT_CONSTEXPR const char* format_str_quoted(bool add_space, const char) {
+FMT_CONSTEXPR const char *format_str_quoted(bool add_space, const char)
+{
     return add_space ? " '{}'" : "'{}'";
 }
-FMT_CONSTEXPR const wchar_t* format_str_quoted(bool add_space, const wchar_t) {
+FMT_CONSTEXPR const wchar_t *format_str_quoted(bool add_space, const wchar_t)
+{
     return add_space ? L" '{}'" : L"'{}'";
 }
 
-}  // namespace internal
+} // namespace internal
 
-template <typename T>
-struct is_tuple_like {
-  static FMT_CONSTEXPR_DECL const bool value =
-    internal::is_tuple_like_<T>::value && !internal::is_range_<T>::value;
+template<typename T>
+struct is_tuple_like
+{
+    static FMT_CONSTEXPR_DECL const bool value = internal::is_tuple_like_<T>::value && !internal::is_range_<T>::value;
 };
 
-template <typename TupleT, typename Char>
-struct formatter<TupleT, Char, 
-    typename std::enable_if<fmt::is_tuple_like<TupleT>::value>::type> {
+template<typename TupleT, typename Char>
+struct formatter<TupleT, Char, typename std::enable_if<fmt::is_tuple_like<TupleT>::value>::type>
+{
 private:
-  // C++11 generic lambda for format()
-  template <typename FormatContext>
-  struct format_each {
-    template <typename T>
-    void operator()(const T& v) {
-      if (i > 0) {
-        if (formatting.add_prepostfix_space) {
-          *out++ = ' ';
+    // C++11 generic lambda for format()
+    template<typename FormatContext>
+    struct format_each
+    {
+        template<typename T>
+        void operator()(const T &v)
+        {
+            if (i > 0)
+            {
+                if (formatting.add_prepostfix_space)
+                {
+                    *out++ = ' ';
+                }
+                internal::copy(formatting.delimiter, out);
+            }
+            format_to(out, internal::format_str_quoted((formatting.add_delimiter_spaces && i > 0), v), v);
+            ++i;
         }
-        internal::copy(formatting.delimiter, out);
-      }
-      format_to(out,
-                internal::format_str_quoted(
-                    (formatting.add_delimiter_spaces && i > 0), v),
-                v);
-      ++i;
-    }
 
-    formatting_tuple<Char>& formatting;
-    std::size_t& i;
-    typename std::add_lvalue_reference<decltype(std::declval<FormatContext>().out())>::type out;
-  };
+        formatting_tuple<Char> &formatting;
+        std::size_t &i;
+        typename std::add_lvalue_reference<decltype(std::declval<FormatContext>().out())>::type out;
+    };
 
 public:
-  formatting_tuple<Char> formatting;
+    formatting_tuple<Char> formatting;
 
-  template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
-    return formatting.parse(ctx);
-  }
-
-  template <typename FormatContext = format_context>
-  auto format(const TupleT &values, FormatContext &ctx) -> decltype(ctx.out()) {
-    auto out = ctx.out();
-    std::size_t i = 0;
-    internal::copy(formatting.prefix, out);
-
-    internal::for_each(values, format_each<FormatContext>{formatting, i, out});
-    if (formatting.add_prepostfix_space) {
-      *out++ = ' ';
+    template<typename ParseContext>
+    FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+    {
+        return formatting.parse(ctx);
     }
-    internal::copy(formatting.postfix, out);
 
-    return ctx.out();
-  }
-};
+    template<typename FormatContext = format_context>
+    auto format(const TupleT &values, FormatContext &ctx) -> decltype(ctx.out())
+    {
+        auto out = ctx.out();
+        std::size_t i = 0;
+        internal::copy(formatting.prefix, out);
 
-template <typename T>
-struct is_range {
-  static FMT_CONSTEXPR_DECL const bool value =
-    internal::is_range_<T>::value && !internal::is_like_std_string<T>::value;
-};
-
-template <typename RangeT, typename Char>
-struct formatter<RangeT, Char,
-    typename std::enable_if<fmt::is_range<RangeT>::value>::type> {
-
-  formatting_range<Char> formatting;
-
-  template <typename ParseContext>
-  FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
-    return formatting.parse(ctx);
-  }
-
-  template <typename FormatContext>
-  typename FormatContext::iterator format(
-      const RangeT &values, FormatContext &ctx) {
-    auto out = ctx.out();
-    internal::copy(formatting.prefix, out);
-    std::size_t i = 0;
-    for (auto it = values.begin(), end = values.end(); it != end; ++it) {
-      if (i > 0) {
-        if (formatting.add_prepostfix_space) {
-          *out++ = ' ';
+        internal::for_each(values, format_each<FormatContext>{formatting, i, out});
+        if (formatting.add_prepostfix_space)
+        {
+            *out++ = ' ';
         }
-        internal::copy(formatting.delimiter, out);
-      }
-      format_to(out,
-                internal::format_str_quoted(
-                    (formatting.add_delimiter_spaces && i > 0), *it),
-                *it);
-      if (++i > formatting.range_length_limit) {
-        format_to(out, " ... <other elements>");
-        break;
-      }
+        internal::copy(formatting.postfix, out);
+
+        return ctx.out();
     }
-    if (formatting.add_prepostfix_space) {
-      *out++ = ' ';
+};
+
+template<typename T>
+struct is_range
+{
+    static FMT_CONSTEXPR_DECL const bool value = internal::is_range_<T>::value && !internal::is_like_std_string<T>::value;
+};
+
+template<typename RangeT, typename Char>
+struct formatter<RangeT, Char, typename std::enable_if<fmt::is_range<RangeT>::value>::type>
+{
+
+    formatting_range<Char> formatting;
+
+    template<typename ParseContext>
+    FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+    {
+        return formatting.parse(ctx);
+    }
+
+    template<typename FormatContext>
+    typename FormatContext::iterator format(const RangeT &values, FormatContext &ctx)
+    {
+        auto out = ctx.out();
+        internal::copy(formatting.prefix, out);
+        std::size_t i = 0;
+        for (auto it = values.begin(), end = values.end(); it != end; ++it)
+        {
+            if (i > 0)
+            {
+                if (formatting.add_prepostfix_space)
+                {
+                    *out++ = ' ';
+                }
+                internal::copy(formatting.delimiter, out);
+            }
+            format_to(out, internal::format_str_quoted((formatting.add_delimiter_spaces && i > 0), *it), *it);
+            if (++i > formatting.range_length_limit)
+            {
+                format_to(out, " ... <other elements>");
+                break;
+            }
+        }
+        if (formatting.add_prepostfix_space)
+        {
+            *out++ = ' ';
+        }
+        internal::copy(formatting.postfix, out);
+        return ctx.out();
     }
-    internal::copy(formatting.postfix, out);
-    return ctx.out();
-  }
 };
 
 FMT_END_NAMESPACE
 
 #endif // FMT_RANGES_H_
-
diff --git a/include/spdlog/fmt/bundled/time.h b/include/spdlog/fmt/bundled/time.h
index 515452a4..3e1443b8 100644
--- a/include/spdlog/fmt/bundled/time.h
+++ b/include/spdlog/fmt/bundled/time.h
@@ -13,140 +13,187 @@
 
 FMT_BEGIN_NAMESPACE
 
-namespace internal{
-inline null<> localtime_r(...) { return null<>(); }
-inline null<> localtime_s(...) { return null<>(); }
-inline null<> gmtime_r(...) { return null<>(); }
-inline null<> gmtime_s(...) { return null<>(); }
+namespace internal {
+inline null<> localtime_r(...)
+{
+    return null<>();
 }
+inline null<> localtime_s(...)
+{
+    return null<>();
+}
+inline null<> gmtime_r(...)
+{
+    return null<>();
+}
+inline null<> gmtime_s(...)
+{
+    return null<>();
+}
+} // namespace internal
 
 // Thread-safe replacement for std::localtime
-inline std::tm localtime(std::time_t time) {
-  struct dispatcher {
-    std::time_t time_;
-    std::tm tm_;
+inline std::tm localtime(std::time_t time)
+{
+    struct dispatcher
+    {
+        std::time_t time_;
+        std::tm tm_;
 
-    dispatcher(std::time_t t): time_(t) {}
+        dispatcher(std::time_t t)
+            : time_(t)
+        {
+        }
 
-    bool run() {
-      using namespace fmt::internal;
-      return handle(localtime_r(&time_, &tm_));
-    }
+        bool run()
+        {
+            using namespace fmt::internal;
+            return handle(localtime_r(&time_, &tm_));
+        }
 
-    bool handle(std::tm *tm) { return tm != FMT_NULL; }
+        bool handle(std::tm *tm)
+        {
+            return tm != FMT_NULL;
+        }
 
-    bool handle(internal::null<>) {
-      using namespace fmt::internal;
-      return fallback(localtime_s(&tm_, &time_));
-    }
+        bool handle(internal::null<>)
+        {
+            using namespace fmt::internal;
+            return fallback(localtime_s(&tm_, &time_));
+        }
 
-    bool fallback(int res) { return res == 0; }
+        bool fallback(int res)
+        {
+            return res == 0;
+        }
 
-    bool fallback(internal::null<>) {
-      using namespace fmt::internal;
-      std::tm *tm = std::localtime(&time_);
-      if (tm) tm_ = *tm;
-      return tm != FMT_NULL;
-    }
-  };
-  dispatcher lt(time);
-  if (lt.run())
-    return lt.tm_;
-  // Too big time values may be unsupported.
-  FMT_THROW(format_error("time_t value out of range"));
+        bool fallback(internal::null<>)
+        {
+            using namespace fmt::internal;
+            std::tm *tm = std::localtime(&time_);
+            if (tm)
+                tm_ = *tm;
+            return tm != FMT_NULL;
+        }
+    };
+    dispatcher lt(time);
+    if (lt.run())
+        return lt.tm_;
+    // Too big time values may be unsupported.
+    FMT_THROW(format_error("time_t value out of range"));
 }
 
 // Thread-safe replacement for std::gmtime
-inline std::tm gmtime(std::time_t time) {
-  struct dispatcher {
-    std::time_t time_;
-    std::tm tm_;
+inline std::tm gmtime(std::time_t time)
+{
+    struct dispatcher
+    {
+        std::time_t time_;
+        std::tm tm_;
 
-    dispatcher(std::time_t t): time_(t) {}
+        dispatcher(std::time_t t)
+            : time_(t)
+        {
+        }
 
-    bool run() {
-      using namespace fmt::internal;
-      return handle(gmtime_r(&time_, &tm_));
-    }
+        bool run()
+        {
+            using namespace fmt::internal;
+            return handle(gmtime_r(&time_, &tm_));
+        }
 
-    bool handle(std::tm *tm) { return tm != FMT_NULL; }
+        bool handle(std::tm *tm)
+        {
+            return tm != FMT_NULL;
+        }
 
-    bool handle(internal::null<>) {
-      using namespace fmt::internal;
-      return fallback(gmtime_s(&tm_, &time_));
-    }
+        bool handle(internal::null<>)
+        {
+            using namespace fmt::internal;
+            return fallback(gmtime_s(&tm_, &time_));
+        }
 
-    bool fallback(int res) { return res == 0; }
+        bool fallback(int res)
+        {
+            return res == 0;
+        }
 
-    bool fallback(internal::null<>) {
-      std::tm *tm = std::gmtime(&time_);
-      if (tm) tm_ = *tm;
-      return tm != FMT_NULL;
-    }
-  };
-  dispatcher gt(time);
-  if (gt.run())
-    return gt.tm_;
-  // Too big time values may be unsupported.
-  FMT_THROW(format_error("time_t value out of range"));
+        bool fallback(internal::null<>)
+        {
+            std::tm *tm = std::gmtime(&time_);
+            if (tm)
+                tm_ = *tm;
+            return tm != FMT_NULL;
+        }
+    };
+    dispatcher gt(time);
+    if (gt.run())
+        return gt.tm_;
+    // Too big time values may be unsupported.
+    FMT_THROW(format_error("time_t value out of range"));
 }
 
 namespace internal {
-inline std::size_t strftime(char *str, std::size_t count, const char *format,
-                            const std::tm *time) {
-  return std::strftime(str, count, format, time);
+inline std::size_t strftime(char *str, std::size_t count, const char *format, const std::tm *time)
+{
+    return std::strftime(str, count, format, time);
 }
 
-inline std::size_t strftime(wchar_t *str, std::size_t count,
-                            const wchar_t *format, const std::tm *time) {
-  return std::wcsftime(str, count, format, time);
-}
+inline std::size_t strftime(wchar_t *str, std::size_t count, const wchar_t *format, const std::tm *time)
+{
+    return std::wcsftime(str, count, format, time);
 }
+} // namespace internal
 
-template <typename Char>
-struct formatter<std::tm, Char> {
-  template <typename ParseContext>
-  auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
-    auto it = internal::null_terminating_iterator<Char>(ctx);
-    if (*it == ':')
-      ++it;
-    auto end = it;
-    while (*end && *end != '}')
-      ++end;
-    tm_format.reserve(end - it + 1);
-    using internal::pointer_from;
-    tm_format.append(pointer_from(it), pointer_from(end));
-    tm_format.push_back('\0');
-    return pointer_from(end);
-  }
-
-  template <typename FormatContext>
-  auto format(const std::tm &tm, FormatContext &ctx) -> decltype(ctx.out()) {
-    internal::basic_buffer<Char> &buf = internal::get_container(ctx.out());
-    std::size_t start = buf.size();
-    for (;;) {
-      std::size_t size = buf.capacity() - start;
-      std::size_t count =
-        internal::strftime(&buf[start], size, &tm_format[0], &tm);
-      if (count != 0) {
-        buf.resize(start + count);
-        break;
-      }
-      if (size >= tm_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;
-      buf.reserve(buf.capacity() + (size > MIN_GROWTH ? size : MIN_GROWTH));
+template<typename Char>
+struct formatter<std::tm, Char>
+{
+    template<typename ParseContext>
+    auto parse(ParseContext &ctx) -> decltype(ctx.begin())
+    {
+        auto it = internal::null_terminating_iterator<Char>(ctx);
+        if (*it == ':')
+            ++it;
+        auto end = it;
+        while (*end && *end != '}')
+            ++end;
+        tm_format.reserve(end - it + 1);
+        using internal::pointer_from;
+        tm_format.append(pointer_from(it), pointer_from(end));
+        tm_format.push_back('\0');
+        return pointer_from(end);
     }
-    return ctx.out();
-  }
 
-  basic_memory_buffer<Char> tm_format;
+    template<typename FormatContext>
+    auto format(const std::tm &tm, FormatContext &ctx) -> decltype(ctx.out())
+    {
+        internal::basic_buffer<Char> &buf = internal::get_container(ctx.out());
+        std::size_t start = buf.size();
+        for (;;)
+        {
+            std::size_t size = buf.capacity() - start;
+            std::size_t count = internal::strftime(&buf[start], size, &tm_format[0], &tm);
+            if (count != 0)
+            {
+                buf.resize(start + count);
+                break;
+            }
+            if (size >= tm_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;
+            buf.reserve(buf.capacity() + (size > MIN_GROWTH ? size : MIN_GROWTH));
+        }
+        return ctx.out();
+    }
+
+    basic_memory_buffer<Char> tm_format;
 };
 FMT_END_NAMESPACE
 
-#endif  // FMT_TIME_H_
+#endif // FMT_TIME_H_
diff --git a/include/spdlog/sinks/sink.h b/include/spdlog/sinks/sink.h
index bc044f3d..14557e8d 100644
--- a/include/spdlog/sinks/sink.h
+++ b/include/spdlog/sinks/sink.h
@@ -20,7 +20,6 @@ public:
     {
     }
 
-
     virtual ~sink() = default;
 
     virtual void log(const details::log_msg &msg) = 0;

From df779f66a251f0c6a87ce1ba0b58d5263bf18964 Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Sun, 8 Jul 2018 16:39:25 +0300
Subject: [PATCH 28/50] Updated readme

---
 README.md | 227 +++++++++++++++++++++++++-----------------------------
 1 file changed, 106 insertions(+), 121 deletions(-)

diff --git a/README.md b/README.md
index f52f7a01..93e7ce24 100644
--- a/README.md
+++ b/README.md
@@ -74,142 +74,106 @@ Time needed to log 1,000,000 lines in asynchronous mode, i.e. the time it takes
 ## Usage Example
 ```c++
 
-#define SPDLOG_TRACE_ON
-#define SPDLOG_DEBUG_ON
-
-// include only features that you use
-#include "spdlog/sinks/daily_file_sink.h"
-#include "spdlog/sinks/rotating_file_sink.h"
-#include "spdlog/sinks/simple_file_sink.h"
+#include "spdlog/spdlog.h"
 #include "spdlog/sinks/stdout_color_sinks.h"
-
-#include <iostream>
-#include <memory>
-
-void async_example();
-void user_defined_example();
-void err_handler_example();
-
-namespace spd = spdlog;
-int main(int, char *[])
+void stdout_example()
 {
+    // create color multi threaded logger
+    auto console = spdlog::stdout_color_mt("console");
+    console->info("Welcome to spdlog!");
+    console->error("Some error message with arg: {}", 1);
 
-    try
+    auto err_logger = spdlog::stderr_color_mt("stderr");
+    err_logger->error("Some error message");
+
+    // Formatting examples
+    console->warn("Easy padding in numbers like {:08d}", 12);
+    console->critical("Support for int: {0:d};  hex: {0:x};  oct: {0:o}; bin: {0:b}", 42);
+    console->info("Support for floats {:03.2f}", 1.23456);
+    console->info("Positional args are {1} {0}..", "too", "supported");
+    console->info("{:<30}", "left aligned");
+
+    spdlog::get("console")->info("loggers can be retrieved from a global registry using the spdlog::get(logger_name)");
+
+    // Runtime log levels
+    spdlog::set_level(spdlog::level::info); // Set global log level to info
+    console->debug("This message should not be displayed!");
+    console->set_level(spdlog::level::trace); // Set specific logger's log level
+    console->debug("This message should be displayed..");
+
+    // Customize msg format for all loggers
+    spdlog::set_pattern("[%H:%M:%S %z] [%n] [%^---%L---%$] [thread %t] %v");
+    console->info("This an info message with custom format");
+
+    // Compile time log levels
+    // define SPDLOG_DEBUG_ON or SPDLOG_TRACE_ON
+    SPDLOG_TRACE(console, "Enabled only #ifdef SPDLOG_TRACE_ON..{} ,{}", 1, 3.23);
+    SPDLOG_DEBUG(console, "Enabled only #ifdef SPDLOG_DEBUG_ON.. {} ,{}", 1, 3.23);
+}
+
+#include "spdlog/sinks/basic_file_sink.h"
+void basic_logfile_example()
+{
+    // Create basic file logger (not rotated)
+    try 
     {
-        auto console = spdlog::stdout_color_st("console");
-        console->info("Welcome to spdlog!");
-
-        console->info("Welcome to spdlog!");
-        console->error("Some error message with arg: {}", 1);
-        err_handler_example();
-        // Formatting examples
-        console->warn("Easy padding in numbers like {:08d}", 12);
-        console->critical("Support for int: {0:d};  hex: {0:x};  oct: {0:o}; bin: {0:b}", 42);
-        console->info("Support for floats {:03.2f}", 1.23456);
-        console->info("Positional args are {1} {0}..", "too", "supported");
-        console->info("{:<30}", "left aligned");
-
-        spd::get("console")->info("loggers can be retrieved from a global registry using the spdlog::get(logger_name) function");
-
-        // Create basic file logger (not rotated)
-        auto my_logger = spd::basic_logger_mt("basic_logger", "logs/basic-log.txt");
-        my_logger->info("Some log message");
-
-        // Create a file rotating logger with 5mb size max and 3 rotated files
-        auto rotating_logger = spd::rotating_logger_mt("some_logger_name", "logs/rotating.txt", 1048576 * 5, 3);
-        for (int i = 0; i < 10; ++i)
-        {
-            rotating_logger->info("{} * {} equals {:>10}", i, i, i * i);
-        }
-
-        // Create a daily logger - a new file is created every day on 2:30am
-        auto daily_logger = spd::daily_logger_mt("daily_logger", "logs/daily.txt", 2, 30);
-        // trigger flush if the log severity is error or higher
-        daily_logger->flush_on(spd::level::err);
-        daily_logger->info(123.44);
-
-        // Customize msg format for all messages
-        spd::set_pattern("[%^+++%$] [%H:%M:%S %z] [thread %t] %v");
-
-        console->info("This an info message with custom format");
-        console->error("This an error message with custom format");
-
-        // Change format back to to default
-        spd::set_pattern("%+");
-
-        // Runtime log levels
-        spd::set_level(spd::level::info); // Set global log level to info
-        console->debug("This message should not be displayed!");
-        console->set_level(spd::level::debug); // Set specific logger's log level
-        console->debug("This message should be displayed..");
-
-        // Compile time log levels
-        // define SPDLOG_DEBUG_ON or SPDLOG_TRACE_ON
-        SPDLOG_TRACE(console, "Enabled only #ifdef SPDLOG_TRACE_ON..{} ,{}", 1, 3.23);
-        SPDLOG_DEBUG(console, "Enabled only #ifdef SPDLOG_DEBUG_ON.. {} ,{}", 1, 3.23);
-
-        // Asynchronous logging is very fast..
-        // Just call spdlog::set_async_mode(q_size) and all created loggers from now on will be asynchronous..
-        async_example();
-
-        // Log user-defined types example
-        user_defined_example();
-
-        // Change default log error handler
-        err_handler_example();
-
-        // Apply a function on all registered loggers
-        spd::apply_all([&](std::shared_ptr<spdlog::logger> l) { l->info("End of example."); });
-
-        // Release and close all loggers
-        spdlog::drop_all();
+        auto my_logger = spdlog::basic_logger_mt("basic_logger", "logs/basic-log.txt");
     }
-    // Exceptions will only be thrown upon failed logger or sink construction (not during logging)
-    catch (const spd::spdlog_ex &ex)
+    catch (const spdlog::spdlog_ex &ex)
     {
         std::cout << "Log init failed: " << ex.what() << std::endl;
         return 1;
     }
 }
-// must be included to use async logger
+
+#include "spdlog/sinks/rotating_file_sink.h"
+void rotating_example()
+{
+    // Create a file rotating logger with 5mb size max and 3 rotated files
+    auto rotating_logger = spdlog::rotating_logger_mt("some_logger_name", "logs/rotating.txt", 1048576 * 5, 3);
+}
+
+#include "spdlog/sinks/daily_file_sink.h"
+void daily_example()
+{
+    // Create a daily logger - a new file is created every day on 2:30am
+    auto daily_logger = spdlog::daily_logger_mt("daily_logger", "logs/daily.txt", 2, 30);
+}
+
 #include "spdlog/async.h"
 void async_example()
 {
-    auto async_file = spd::basic_logger_mt<spdlog::create_async>("async_file_logger", "logs/async_log.txt");
-    for (int i = 0; i < 100; ++i)
+    // default thread pool settings can be modified *before* creating the async logger:
+    // spdlog::init_thread_pool(32768, 1); // queue with max 32k items 1 backing thread.
+    auto async_file = spdlog::basic_logger_mt<spdlog::async_factory>("async_file_logger", "logs/async_log.txt");
+    // alternatively:
+    // auto async_file = spdlog::create_async<spdlog::sinks::basic_file_sink_mt>("async_file_logger", "logs/async_log.txt");
+
+    for (int i = 1; i < 101; ++i)
     {
         async_file->info("Async message #{}", i);
     }
-
-    // you can also modify thread pool settings *before* creating the logger:
-    // spdlog::init_thread_pool(32768, 4); // queue with 32k of pre allocated items and 4 backing threads.
-    // if not called a defaults are: preallocated 8192 queue items and 1 worker thread.
 }
 
-// syslog example (linux/osx/freebsd)
-#ifndef _WIN32
-#include "spdlog/sinks/syslog_sink.h"
-void syslog_example()
+// create logger with 2 targets with different log levels and formats
+// the console will show only warnings or errors, while the file will log all
+
+void multi_sink_example()
 {
-    std::string ident = "spdlog-example";
-    auto syslog_logger = spd::syslog_logger("syslog", ident, LOG_PID);
-    syslog_logger->warn("This is warning that will end up in syslog.");
+    auto console_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
+    console_sink->set_level(spdlog::level::warn);
+    console_sink->set_pattern("[multi_sink_example] [%^%l%$] %v");
+
+    auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>("logs/multisink.txt", true);
+    file_sink->set_level(spdlog::level::trace);
+
+    spdlog::logger logger("multi_sink", {console_sink, file_sink});
+    logger.set_level(spdlog::level::debug);
+    logger.warn("this should appear in both console and file");
+    logger.info("this message should not appear in the console, only in the file");
 }
-#endif
-
-// Android example
-#if defined(__ANDROID__)
-#incude "spdlog/sinks/android_sink.h"
-void android_example()
-{
-    std::string tag = "spdlog-android";
-    auto android_logger = spd::android_logger("android", tag);
-    android_logger->critical("Use \"adb shell logcat\" to view this message.");
-}
-
-#endif
-
 // user defined types logging by implementing operator<<
+#include "spdlog/fmt/ostr.h" // must be included
 struct my_type
 {
     int i;
@@ -220,10 +184,9 @@ struct my_type
     }
 };
 
-#include "spdlog/fmt/ostr.h" // must be included
 void user_defined_example()
 {
-    spd::get("console")->info("user defined type: {}", my_type{14});
+    spdlog::get("console")->info("user defined type: {}", my_type{14});
 }
 
 //
@@ -231,12 +194,34 @@ void user_defined_example()
 //
 void err_handler_example()
 {
-    // can be set globaly or per logger(logger->set_error_handler(..))
-    spdlog::set_error_handler([](const std::string &msg) { spd::get("console")->error("*******my err handler: {}", msg); });
-    spd::get("console")->info("some invalid message to trigger an error {}{}{}{}", 3);
-    // spd::get("console")->info("some invalid message to trigger an error {}{}{}{}", 3);
+    // can be set globally or per logger(logger->set_error_handler(..))
+    spdlog::set_error_handler([](const std::string &msg) { spdlog::get("console")->error("*** LOGGER ERROR ***: {}", msg); });
+    spdlog::get("console")->info("some invalid message to trigger an error {}{}{}{}", 3);
 }
 
+// syslog example (linux/osx/freebsd)
+#ifndef _WIN32
+#include "spdlog/sinks/syslog_sink.h"
+void syslog_example()
+{
+    std::string ident = "spdlog-example";
+    auto syslog_logger = spdlog::syslog_logger("syslog", ident, LOG_PID);
+    syslog_logger->warn("This is warning that will end up in syslog.");
+}
+#endif
+
+// Android example
+#if defined(__ANDROID__)
+#incude "spdlog/sinks/android_sink.h"
+void android_example()
+{
+    std::string tag = "spdlog-android";
+    auto android_logger = spdlog::android_logger("android", tag);
+    android_logger->critical("Use \"adb shell logcat\" to view this message.");
+}
+
+#endif
+
 ```
 
 ## Documentation

From 3ea1d27aaca18c47d62b572ae53d43d1726b076d Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Sun, 8 Jul 2018 16:42:21 +0300
Subject: [PATCH 29/50] Updated readme

---
 README.md | 36 ++++++++++++++++++++----------------
 1 file changed, 20 insertions(+), 16 deletions(-)

diff --git a/README.md b/README.md
index 93e7ce24..38198ae7 100644
--- a/README.md
+++ b/README.md
@@ -50,25 +50,29 @@ Very fast, header only, C++ logging library. [![Build Status](https://travis-ci.
 Below are some [benchmarks](bench) comparing popular log libraries under Ubuntu 64 bit, Intel i7-4770 CPU @ 3.40GHz
 
 #### Synchronous mode
-Time needed to log 1,000,000 lines in synchronous mode (in seconds, the best of 3 runs):
-
-|threads|boost log 1.54|glog   |easylogging |spdlog|
-|-------|:-------:|:-----:|----------:|------:|
-|1|       4.169s  |1.066s |0.975s     |0.302s|
-|10|     6.180s   |3.032s |2.857s     |0.968s|
-|100|     5.981s  |1.139s |4.512s     |0.497s|
+*******************************************************************************
+Single thread, 1,000,000 iterations
+*******************************************************************************
+basic_st...		Elapsed: 0.231041	4,328,228/sec
+rotating_st     Elapsed: 0.233466	4,283,282/sec
+daily_st...		Elapsed: 0.244491	4,090,136/sec
+null_st...		Elapsed: 0.162708	6,145,995/sec
 
+*******************************************************************************
+10 threads sharing same logger, 1,000,000 iterations
+*******************************************************************************
+basic_mt...		Elapsed: 0.854029	1,170,920/sec
+rotating_mt		Elapsed: 0.867038	1,153,351/sec
+daily_mt...		Elapsed: 0.869593	1,149,963/sec
+null_mt...		Elapsed: 0.171215	5,840,602/sec
 
 #### Asynchronous mode
-Time needed to log 1,000,000 lines in asynchronous mode, i.e. the time it takes to put them in the async queue (in seconds, the best of 3 runs):
-
-|threads|g2log <sup>async logger</sup>   |spdlog <sup>async mode</sup>|
-|:-------|:-----:|-------------------------:|
-|1|       1.850s |0.216s |
-|10|      0.943s  |0.173s|
-|100|      0.959s |0.202s|
-
-
+*******************************************************************************
+async logging.. 10 threads sharing same logger, 1,000,000 iterations 
+*******************************************************************************
+async...		Elapsed: 0.442731	2,258,706/sec
+async...		Elapsed: 0.427072	2,341,527/sec
+async...		Elapsed: 0.449768	2,223,369/sec
 
 
 ## Usage Example

From 2292f7a27af21a7de323042540bdd4f3b37efe00 Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Sun, 8 Jul 2018 16:43:04 +0300
Subject: [PATCH 30/50] Updated readme

---
 README.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 38198ae7..22af40e0 100644
--- a/README.md
+++ b/README.md
@@ -50,6 +50,7 @@ Very fast, header only, C++ logging library. [![Build Status](https://travis-ci.
 Below are some [benchmarks](bench) comparing popular log libraries under Ubuntu 64 bit, Intel i7-4770 CPU @ 3.40GHz
 
 #### Synchronous mode
+```
 *******************************************************************************
 Single thread, 1,000,000 iterations
 *******************************************************************************
@@ -73,7 +74,7 @@ async logging.. 10 threads sharing same logger, 1,000,000 iterations
 async...		Elapsed: 0.442731	2,258,706/sec
 async...		Elapsed: 0.427072	2,341,527/sec
 async...		Elapsed: 0.449768	2,223,369/sec
-
+```
 
 ## Usage Example
 ```c++

From a8b026bd700616645df7ac0fc423a26aa7f10f39 Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Sun, 8 Jul 2018 16:43:55 +0300
Subject: [PATCH 31/50] Updated readme

---
 README.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 22af40e0..6eee6224 100644
--- a/README.md
+++ b/README.md
@@ -66,8 +66,9 @@ basic_mt...		Elapsed: 0.854029	1,170,920/sec
 rotating_mt		Elapsed: 0.867038	1,153,351/sec
 daily_mt...		Elapsed: 0.869593	1,149,963/sec
 null_mt...		Elapsed: 0.171215	5,840,602/sec
-
+```
 #### Asynchronous mode
+```
 *******************************************************************************
 async logging.. 10 threads sharing same logger, 1,000,000 iterations 
 *******************************************************************************

From ca2724d82e27816c206b73c5cb5693f0ef5721db Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Sun, 8 Jul 2018 16:45:35 +0300
Subject: [PATCH 32/50] Updated readme

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 6eee6224..66080525 100644
--- a/README.md
+++ b/README.md
@@ -47,7 +47,7 @@ Very fast, header only, C++ logging library. [![Build Status](https://travis-ci.
 
 ## Benchmarks
 
-Below are some [benchmarks](bench) comparing popular log libraries under Ubuntu 64 bit, Intel i7-4770 CPU @ 3.40GHz
+Below are some [benchmarks](https://github.com/gabime/spdlog/blob/v1.x/bench/bench.cpp) comparing popular log libraries under Ubuntu 64 bit, Intel i7-4770 CPU @ 3.40GHz
 
 #### Synchronous mode
 ```
@@ -70,7 +70,7 @@ null_mt...		Elapsed: 0.171215	5,840,602/sec
 #### Asynchronous mode
 ```
 *******************************************************************************
-async logging.. 10 threads sharing same logger, 1,000,000 iterations 
+10 threads sharing same logger, 1,000,000 iterations 
 *******************************************************************************
 async...		Elapsed: 0.442731	2,258,706/sec
 async...		Elapsed: 0.427072	2,341,527/sec

From f766b6d8821741732152e0fe6acab5c38191b57e Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Sun, 8 Jul 2018 16:46:12 +0300
Subject: [PATCH 33/50] Updated bench.cpp

---
 bench/bench.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/bench/bench.cpp b/bench/bench.cpp
index ec2b91e4..0a7b0fb5 100644
--- a/bench/bench.cpp
+++ b/bench/bench.cpp
@@ -84,9 +84,9 @@ int main(int argc, char *argv[])
         for (int i = 0; i < 3; ++i)
         {
             spdlog::init_thread_pool(queue_size, 1);
-            auto as = spdlog::basic_logger_mt<spdlog::async_factory>("as", "logs/basic_async.log", true);
+            auto as = spdlog::basic_logger_mt<spdlog::async_factory>("async", "logs/basic_async.log", true);
             bench_mt(howmany, as, threads);
-            spdlog::drop("as");
+            spdlog::drop("async");
         }
     }
     catch (std::exception &ex)

From 7f26ad29a06cd93c02b3ea11628141670f1b9293 Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Sun, 8 Jul 2018 16:46:52 +0300
Subject: [PATCH 34/50] Updated bench.cpp

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

diff --git a/README.md b/README.md
index 66080525..8551398f 100644
--- a/README.md
+++ b/README.md
@@ -47,7 +47,7 @@ Very fast, header only, C++ logging library. [![Build Status](https://travis-ci.
 
 ## Benchmarks
 
-Below are some [benchmarks](https://github.com/gabime/spdlog/blob/v1.x/bench/bench.cpp) comparing popular log libraries under Ubuntu 64 bit, Intel i7-4770 CPU @ 3.40GHz
+Below are some [benchmarks](https://github.com/gabime/spdlog/blob/v1.x/bench/bench.cpp) done in Ubuntu 64 bit, Intel i7-4770 CPU @ 3.40GHz
 
 #### Synchronous mode
 ```

From 866e593138d1a6dae851c86d1eb217c925f3dbcb Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Sun, 8 Jul 2018 16:48:58 +0300
Subject: [PATCH 35/50] Updated readme.md

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

diff --git a/README.md b/README.md
index 8551398f..7db1baa3 100644
--- a/README.md
+++ b/README.md
@@ -55,7 +55,7 @@ Below are some [benchmarks](https://github.com/gabime/spdlog/blob/v1.x/bench/ben
 Single thread, 1,000,000 iterations
 *******************************************************************************
 basic_st...		Elapsed: 0.231041	4,328,228/sec
-rotating_st     Elapsed: 0.233466	4,283,282/sec
+rotating...             Elapsed: 0.233466	4,283,282/sec
 daily_st...		Elapsed: 0.244491	4,090,136/sec
 null_st...		Elapsed: 0.162708	6,145,995/sec
 

From 5851fb9de9ae56d7ac247782c15c1d7a3323a8e6 Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Sun, 8 Jul 2018 16:49:57 +0300
Subject: [PATCH 36/50] Updated readme.md

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

diff --git a/README.md b/README.md
index 7db1baa3..10996db8 100644
--- a/README.md
+++ b/README.md
@@ -30,7 +30,7 @@ Very fast, header only, C++ logging library. [![Build Status](https://travis-ci.
 * Headers only, just copy and use.
 * Feature rich [call style](#usage-example) using the excellent [fmt](https://github.com/fmtlib/fmt) library.
 * Optional printf syntax support.
-* Extremely fast asynchronous mode (optional) - using lockfree queues and other tricks to reach millions of calls/sec.
+* Fast asynchronous mode (optional)
 * [Custom](https://github.com/gabime/spdlog/wiki/3.-Custom-formatting) formatting.
 * Conditional Logging
 * Multi/Single threaded loggers.

From 80855329e7fa51e62af9b9d4c8ff999318d9fe1e Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Sun, 8 Jul 2018 16:50:56 +0300
Subject: [PATCH 37/50] Updated readme.md

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

diff --git a/README.md b/README.md
index 10996db8..794623bf 100644
--- a/README.md
+++ b/README.md
@@ -20,7 +20,7 @@ Very fast, header only, C++ logging library. [![Build Status](https://travis-ci.
  
 
 ## Platforms
- * Linux, FreeBSD, Solaris
+ * Linux, FreeBSD, Solaris, AIX
  * Windows (vc 2013+, cygwin)
  * Mac OSX (clang 3.5+)
  * Android

From 9cc731001b2a79ae2c7293744f837a581be03289 Mon Sep 17 00:00:00 2001
From: Gabi Melman <gmelman1@gmail.com>
Date: Sun, 8 Jul 2018 17:00:57 +0300
Subject: [PATCH 38/50] Update README.md

---
 README.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/README.md b/README.md
index 794623bf..7b30f616 100644
--- a/README.md
+++ b/README.md
@@ -29,7 +29,6 @@ Very fast, header only, C++ logging library. [![Build Status](https://travis-ci.
 * Very fast - performance is the primary goal (see [benchmarks](#benchmarks) below).
 * Headers only, just copy and use.
 * Feature rich [call style](#usage-example) using the excellent [fmt](https://github.com/fmtlib/fmt) library.
-* Optional printf syntax support.
 * Fast asynchronous mode (optional)
 * [Custom](https://github.com/gabime/spdlog/wiki/3.-Custom-formatting) formatting.
 * Conditional Logging

From 2277fdc80d313104eda3a7595717275e68d5f60a Mon Sep 17 00:00:00 2001
From: Gabi Melman <gmelman1@gmail.com>
Date: Sun, 8 Jul 2018 17:02:26 +0300
Subject: [PATCH 39/50] Update README.md

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

diff --git a/README.md b/README.md
index 7b30f616..eb10a740 100644
--- a/README.md
+++ b/README.md
@@ -149,7 +149,7 @@ void daily_example()
 void async_example()
 {
     // default thread pool settings can be modified *before* creating the async logger:
-    // spdlog::init_thread_pool(32768, 1); // queue with max 32k items 1 backing thread.
+    // spdlog::init_thread_pool(32768, 1); // queue with 32k items and 1 backing thread.
     auto async_file = spdlog::basic_logger_mt<spdlog::async_factory>("async_file_logger", "logs/async_log.txt");
     // alternatively:
     // auto async_file = spdlog::create_async<spdlog::sinks::basic_file_sink_mt>("async_file_logger", "logs/async_log.txt");

From 8266dde55602cdd6e45377b3ab0420d2e062fcbd Mon Sep 17 00:00:00 2001
From: Gabi Melman <gmelman1@gmail.com>
Date: Sun, 8 Jul 2018 17:03:13 +0300
Subject: [PATCH 40/50] Update README.md

---
 README.md | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index eb10a740..be79838c 100644
--- a/README.md
+++ b/README.md
@@ -160,9 +160,8 @@ void async_example()
     }
 }
 
-// create logger with 2 targets with different log levels and formats
-// the console will show only warnings or errors, while the file will log all
-
+// create logger with 2 targets with different log levels and formats.
+// the console will show only warnings or errors, while the file will log all.
 void multi_sink_example()
 {
     auto console_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();

From 99cc35384bd0e9321e228c5f0361d803e2b35dab Mon Sep 17 00:00:00 2001
From: Gabi Melman <gmelman1@gmail.com>
Date: Sun, 8 Jul 2018 19:24:26 +0300
Subject: [PATCH 41/50] Update common.h

---
 include/spdlog/common.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/spdlog/common.h b/include/spdlog/common.h
index 521ee1e3..c18d203e 100644
--- a/include/spdlog/common.h
+++ b/include/spdlog/common.h
@@ -5,7 +5,7 @@
 
 #pragma once
 
-#define SPDLOG_VERSION "0.16.4-rc"
+#define SPDLOG_VERSION "1.0.0-rc"
 
 #include "spdlog/tweakme.h"
 

From bbff8abf5824c6edcbc05ab9626c39fcb0be73ee Mon Sep 17 00:00:00 2001
From: Gabi Melman <gmelman1@gmail.com>
Date: Sun, 8 Jul 2018 19:25:15 +0300
Subject: [PATCH 42/50] Update CMakeLists.txt

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

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 873979dc..6d55b8ef 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -4,7 +4,7 @@
 #
 
 cmake_minimum_required(VERSION 3.1)
-project(spdlog VERSION 0.16.3 LANGUAGES CXX)
+project(spdlog VERSION 1.0.0 LANGUAGES CXX)
 include(CTest)
 include(CMakeDependentOption)
 include(GNUInstallDirs)

From 21524c16fadaab4c5c8b852325685651e3048c57 Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Mon, 9 Jul 2018 15:05:48 +0300
Subject: [PATCH 43/50] faster reset of cached buffer

---
 include/spdlog/details/pattern_formatter.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/spdlog/details/pattern_formatter.h b/include/spdlog/details/pattern_formatter.h
index f06a29d4..d372a337 100644
--- a/include/spdlog/details/pattern_formatter.h
+++ b/include/spdlog/details/pattern_formatter.h
@@ -460,9 +460,9 @@ class full_formatter SPDLOG_FINAL : public flag_formatter
         // each second cache the header
         auto duration = msg.time.time_since_epoch();
         auto seconds = std::chrono::duration_cast<std::chrono::seconds>(duration).count();
-        if (cached_header_.size() == 0 || cached_seconds_ts_ != seconds)
+        if (true || cached_header_.size() == 0 || cached_seconds_ts_ != seconds)
         {
-            cached_header_ = fmt::memory_buffer();
+            cached_header_.resize(0);
             cached_header_.push_back('[');
             fmt_helper::append_int(tm_time.tm_year + 1900, cached_header_);
             cached_header_.push_back('-');

From b4dcd592d85438f328c5b41f1a591a2cfb7cd182 Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Mon, 9 Jul 2018 15:10:24 +0300
Subject: [PATCH 44/50] faster reset of cached buffer

---
 include/spdlog/details/pattern_formatter.h | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/include/spdlog/details/pattern_formatter.h b/include/spdlog/details/pattern_formatter.h
index d372a337..2bf8ea3e 100644
--- a/include/spdlog/details/pattern_formatter.h
+++ b/include/spdlog/details/pattern_formatter.h
@@ -29,6 +29,16 @@ class flag_formatter
 public:
     virtual ~flag_formatter() = default;
     virtual void format(const details::log_msg &msg, const std::tm &tm_time, fmt::memory_buffer &dest) = 0;
+
+protected:
+    fmt::memory_buffer cached_buf_;
+    std::tm cached_tm_;
+    bool from_cache(const std::tm &tm_time, fmt::memory_buffer &dest)
+    {
+
+    }
+
+
 };
 
 ///////////////////////////////////////////////////////////////////////
@@ -460,7 +470,7 @@ class full_formatter SPDLOG_FINAL : public flag_formatter
         // each second cache the header
         auto duration = msg.time.time_since_epoch();
         auto seconds = std::chrono::duration_cast<std::chrono::seconds>(duration).count();
-        if (true || cached_header_.size() == 0 || cached_seconds_ts_ != seconds)
+        if (cached_header_.size() == 0 || cached_seconds_ts_ != seconds)
         {
             cached_header_.resize(0);
             cached_header_.push_back('[');

From c887907d4a48dc689c26c1db6c864ce2cb94fe56 Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Mon, 9 Jul 2018 15:10:43 +0300
Subject: [PATCH 45/50] faster reset of cached buffer

---
 include/spdlog/details/pattern_formatter.h | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/include/spdlog/details/pattern_formatter.h b/include/spdlog/details/pattern_formatter.h
index 2bf8ea3e..585e3661 100644
--- a/include/spdlog/details/pattern_formatter.h
+++ b/include/spdlog/details/pattern_formatter.h
@@ -29,16 +29,6 @@ class flag_formatter
 public:
     virtual ~flag_formatter() = default;
     virtual void format(const details::log_msg &msg, const std::tm &tm_time, fmt::memory_buffer &dest) = 0;
-
-protected:
-    fmt::memory_buffer cached_buf_;
-    std::tm cached_tm_;
-    bool from_cache(const std::tm &tm_time, fmt::memory_buffer &dest)
-    {
-
-    }
-
-
 };
 
 ///////////////////////////////////////////////////////////////////////

From bc495bbc630b6eddb895f048c02cdefd00b271ea Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Mon, 9 Jul 2018 21:06:15 +0300
Subject: [PATCH 46/50] Added latency bench

---
 bench/Makefile    |   8 ++-
 bench/latency.cpp | 159 ++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 165 insertions(+), 2 deletions(-)
 create mode 100644 bench/latency.cpp

diff --git a/bench/Makefile b/bench/Makefile
index 98fcccb7..534c55c3 100644
--- a/bench/Makefile
+++ b/bench/Makefile
@@ -1,14 +1,18 @@
 CXX	= g++
-CXXFLAGS	= -march=native -Wall -Wextra -pedantic -std=c++11 -pthread -I../include
+CXXFLAGS	= -march=native -Wall -Wextra -pedantic -std=c++11 -pthread -I../include -fmax-errors=1
 CXX_RELEASE_FLAGS = -O3 -flto
 
 
-binaries=bench
+binaries=bench latency
 
 all: $(binaries)
 
 bench: bench.cpp
 	$(CXX) bench.cpp -o bench $(CXXFLAGS) $(CXX_RELEASE_FLAGS)
+	
+	
+latency: latency.cpp
+	$(CXX) latency.cpp -o latency $(CXXFLAGS) $(CXX_RELEASE_FLAGS)
 				
 
 .PHONY: clean
diff --git a/bench/latency.cpp b/bench/latency.cpp
new file mode 100644
index 00000000..55ed8e49
--- /dev/null
+++ b/bench/latency.cpp
@@ -0,0 +1,159 @@
+//
+// Copyright(c) 2018 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
+//
+// latency.cpp : spdlog latency benchmarks
+//
+#include "spdlog/async.h"
+#include "spdlog/sinks/basic_file_sink.h"
+#include "spdlog/sinks/daily_file_sink.h"
+#include "spdlog/sinks/null_sink.h"
+#include "spdlog/sinks/rotating_file_sink.h"
+#include "spdlog/spdlog.h"
+#include "utils.h"
+#include <atomic>
+#include <cstdlib>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <thread>
+
+using namespace std;
+using namespace std::chrono;
+using namespace spdlog;
+using namespace spdlog::sinks;
+using namespace utils;
+
+void bench(int howmany, std::shared_ptr<spdlog::logger> log);
+void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count);
+
+int main(int , char *[])
+{
+    std::srand(std::time(nullptr)); // use current time as seed for random generator
+    int howmany = 50;
+    int queue_size = howmany + 2;
+    int threads = 10;
+    int file_size = 30 * 1024 * 1024;
+    int rotating_files = 5;
+
+    try
+    {
+
+        cout << "*******************************************************************************\n";
+        cout << "Single thread\n";
+        cout << "*******************************************************************************\n";
+
+        auto basic_st = spdlog::basic_logger_mt("basic_st", "logs/basic_st.log", true);
+        bench(howmany, basic_st);
+
+        auto rotating_st = spdlog::rotating_logger_st("rotating_st", "logs/rotating_st.log", file_size, rotating_files);
+        bench(howmany, rotating_st);
+
+        auto daily_st = spdlog::daily_logger_st("daily_st", "logs/daily_st.log");
+        bench(howmany, daily_st);
+
+        bench(howmany, spdlog::create<null_sink_st>("null_st"));
+
+        cout << "\n*******************************************************************************\n";
+        cout << threads << " threads sharing same logger\n";
+        cout << "*******************************************************************************\n";
+
+        auto basic_mt = spdlog::basic_logger_mt("basic_mt", "logs/basic_mt.log", true);
+        bench_mt(howmany, basic_mt, threads);
+
+        auto rotating_mt = spdlog::rotating_logger_mt("rotating_mt", "logs/rotating_mt.log", file_size, rotating_files);
+        bench_mt(howmany, rotating_mt, threads);
+
+        auto daily_mt = spdlog::daily_logger_mt("daily_mt", "logs/daily_mt.log");
+        bench_mt(howmany, daily_mt, threads);
+        bench(howmany, spdlog::create<null_sink_st>("null_mt"));
+
+        cout << "\n*******************************************************************************\n";
+        cout << "async logging.. " << threads << " threads sharing same logger\n";
+        cout << "*******************************************************************************\n";
+
+        for (int i = 0; i < 3; ++i)
+        {
+            spdlog::init_thread_pool(queue_size, 1);
+            auto as = spdlog::basic_logger_mt<spdlog::async_factory>("async", "logs/basic_async.log", true);
+            bench_mt(howmany, as, threads);
+            spdlog::drop("async");
+        }
+    }
+    catch (std::exception &ex)
+    {
+        std::cerr << "Error: " << ex.what() << std::endl;
+        perror("Last error");
+        return EXIT_FAILURE;
+    }
+    return EXIT_SUCCESS;
+}
+
+void rand_sleep()
+{
+
+    auto sleep_ms= std::chrono::milliseconds(std::rand() % 50);
+    std::this_thread::sleep_for(sleep_ms);
+}
+
+void bench(int howmany, std::shared_ptr<spdlog::logger> log)
+{
+    using namespace std::chrono;
+    using chrono::high_resolution_clock;
+    using chrono::milliseconds;
+    using chrono::nanoseconds;
+
+    cout << log->name() << "...\t\t" << flush;
+    nanoseconds total_nanos = nanoseconds::zero();
+    for (auto i = 0; i < howmany; ++i)
+    {
+        auto start = high_resolution_clock::now();
+        log->info("Hello logger: msg number {}", i);
+        auto delta_nanos = chrono::duration_cast<nanoseconds>(high_resolution_clock::now() - start);
+        total_nanos+= delta_nanos;
+        rand_sleep();
+    }
+
+    auto avg = total_nanos.count()/howmany;
+    cout << format(avg) << " ns/call" << endl;
+}
+
+void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count)
+{
+    using namespace std::chrono;
+    using chrono::high_resolution_clock;
+    using chrono::milliseconds;
+    using chrono::nanoseconds;
+
+    cout << log->name() << "...\t\t" << flush;
+    vector<thread> threads;
+    nanoseconds::rep total_nanos = 0;
+    for (int t = 0; t < thread_count; ++t)
+    {
+        threads.push_back(std::thread([&]() {
+            nanoseconds thr_total_nanos = nanoseconds::zero();
+            for (int j = 0; j < howmany / thread_count; j++)
+            {
+                auto start = high_resolution_clock::now();
+                log->info("Hello logger: msg number {}", j);
+                auto delta_nanos = chrono::duration_cast<nanoseconds>(high_resolution_clock::now() - start);
+                thr_total_nanos+= delta_nanos;
+                rand_sleep();
+            }
+            total_nanos+= thr_total_nanos.count();
+        }));
+    }
+
+    for (auto &t : threads)
+    {
+        t.join();
+    };
+
+    auto avg = total_nanos/howmany;
+    cout << format(avg) << " ns/call" << endl;
+
+
+
+}

From 374a22b4b934b3f0d1ebd2ebc2d7c773cf18d200 Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Mon, 9 Jul 2018 21:06:59 +0300
Subject: [PATCH 47/50] bench fix

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

diff --git a/bench/bench.cpp b/bench/bench.cpp
index 0a7b0fb5..c5e8a5a4 100644
--- a/bench/bench.cpp
+++ b/bench/bench.cpp
@@ -32,8 +32,9 @@ void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count
 int main(int argc, char *argv[])
 {
 
-    int queue_size = 1000000;
+
     int howmany = 1000000;
+    int queue_size = howmany + 2;
     int threads = 10;
     int file_size = 30 * 1024 * 1024;
     int rotating_files = 5;

From a776a774e11d84cd94d28197cfe1b2e5e054dce2 Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Mon, 9 Jul 2018 21:07:44 +0300
Subject: [PATCH 48/50] cache millis in full_formatter

---
 include/spdlog/details/fmt_helper.h        | 24 +++++---
 include/spdlog/details/pattern_formatter.h | 72 ++++++++++++++--------
 2 files changed, 60 insertions(+), 36 deletions(-)

diff --git a/include/spdlog/details/fmt_helper.h b/include/spdlog/details/fmt_helper.h
index 743d9a3c..4f9a9fc4 100644
--- a/include/spdlog/details/fmt_helper.h
+++ b/include/spdlog/details/fmt_helper.h
@@ -8,13 +8,16 @@
 namespace spdlog {
 namespace details {
 namespace fmt_helper {
-inline void append_str(const std::string &str, fmt::memory_buffer &dest)
+
+template <size_t Buffer_Size>
+inline void append_str(const std::string &str, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
 {
     auto *str_ptr = str.data();
     dest.append(str_ptr, str_ptr + str.size());
 }
 
-inline void append_c_str(const char *c_str, fmt::memory_buffer &dest)
+template <size_t Buffer_Size>
+inline void append_c_str(const char *c_str, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
 {
     char ch;
     while ((ch = *c_str) != '\0')
@@ -24,21 +27,22 @@ inline void append_c_str(const char *c_str, fmt::memory_buffer &dest)
     }
 }
 
-template<size_t N1, size_t N2>
-inline void append_buf(const fmt::basic_memory_buffer<char, N1> &buf, fmt::basic_memory_buffer<char, N2> &dest)
+template<size_t Buffer_Size1, size_t Buffer_Size2>
+inline void append_buf(const fmt::basic_memory_buffer<char, Buffer_Size1> &buf, fmt::basic_memory_buffer<char, Buffer_Size2> &dest)
 {
     auto *buf_ptr = buf.data();
     dest.append(buf_ptr, buf_ptr + buf.size());
 }
 
-template<typename T>
-inline void append_int(T n, fmt::memory_buffer &dest)
+template<typename T, size_t Buffer_Size>
+inline void append_int(T n, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
 {
     fmt::format_int i(n);
     dest.append(i.data(), i.data() + i.size());
 }
 
-inline void pad2(int n, fmt::memory_buffer &dest)
+template <size_t Buffer_Size>
+inline void pad2(int n, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
 {
     if (n > 99)
     {
@@ -61,7 +65,8 @@ inline void pad2(int n, fmt::memory_buffer &dest)
     fmt::format_to(dest, "{:02}", n);
 }
 
-inline void pad3(int n, fmt::memory_buffer &dest)
+template <size_t Buffer_Size>
+inline void pad3(int n, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
 {
     if (n > 99)
     {
@@ -86,7 +91,8 @@ inline void pad3(int n, fmt::memory_buffer &dest)
     fmt::format_to(dest, "{:03}", n);
 }
 
-inline void pad6(size_t n, fmt::memory_buffer &dest)
+template <size_t Buffer_Size>
+inline void pad6(size_t n, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
 {
     // todo: maybe replace this implementation with
     // pad3(n / 1000, dest);
diff --git a/include/spdlog/details/pattern_formatter.h b/include/spdlog/details/pattern_formatter.h
index 585e3661..c4109d85 100644
--- a/include/spdlog/details/pattern_formatter.h
+++ b/include/spdlog/details/pattern_formatter.h
@@ -120,7 +120,16 @@ class c_formatter SPDLOG_FINAL : public flag_formatter
 {
     void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
     {
-        fmt::format_to(dest, "{} {} {} ", days[tm_time.tm_wday], months[tm_time.tm_mon], tm_time.tm_mday); //
+        //fmt::format_to(dest, "{} {} {} ", days[tm_time.tm_wday], months[tm_time.tm_mon], tm_time.tm_mday);
+        // date
+        fmt_helper::append_str(days[tm_time.tm_wday], dest);
+        dest.push_back(' ');
+        fmt_helper::append_str(months[tm_time.tm_mon], dest);
+        dest.push_back(' ');
+        fmt_helper::append_int(tm_time.tm_mday, dest);
+        dest.push_back(' ');
+        // time
+
         fmt_helper::pad2(tm_time.tm_hour, dest);
         dest.push_back(':');
         fmt_helper::pad2(tm_time.tm_min, dest);
@@ -366,7 +375,6 @@ class t_formatter SPDLOG_FINAL : public flag_formatter
 {
     void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
     {
-
         fmt_helper::pad6(msg.thread_id, dest);
     }
 };
@@ -385,7 +393,6 @@ class i_formatter SPDLOG_FINAL : public flag_formatter
 {
     void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
     {
-
         fmt_helper::pad6(msg.msg_id, dest);
     }
 };
@@ -457,39 +464,48 @@ class full_formatter SPDLOG_FINAL : public flag_formatter
     {
 #ifndef SPDLOG_NO_DATETIME
 
-        // each second cache the header
+        // cache the date/time part for the next second.
         auto duration = msg.time.time_since_epoch();
-        auto seconds = std::chrono::duration_cast<std::chrono::seconds>(duration).count();
-        if (cached_header_.size() == 0 || cached_seconds_ts_ != seconds)
+        std::chrono::seconds seconds = std::chrono::duration_cast<std::chrono::seconds>(duration);
+
+        if (cache_timestamp_ != seconds || cached_datetime_.size() == 0)
         {
-            cached_header_.resize(0);
-            cached_header_.push_back('[');
-            fmt_helper::append_int(tm_time.tm_year + 1900, cached_header_);
-            cached_header_.push_back('-');
+            cached_datetime_.resize(0);
+            cached_datetime_.push_back('[');
+            fmt_helper::append_int(tm_time.tm_year + 1900, cached_datetime_);
+            cached_datetime_.push_back('-');
 
-            fmt_helper::pad2(tm_time.tm_mon + 1, cached_header_);
-            cached_header_.push_back('-');
+            fmt_helper::pad2(tm_time.tm_mon + 1, cached_datetime_);
+            cached_datetime_.push_back('-');
 
-            fmt_helper::pad2(tm_time.tm_mday, cached_header_);
-            cached_header_.push_back(' ');
+            fmt_helper::pad2(tm_time.tm_mday, cached_datetime_);
+            cached_datetime_.push_back(' ');
 
-            fmt_helper::pad2(tm_time.tm_hour, cached_header_);
-            cached_header_.push_back(':');
+            fmt_helper::pad2(tm_time.tm_hour, cached_datetime_);
+            cached_datetime_.push_back(':');
 
-            fmt_helper::pad2(tm_time.tm_min, cached_header_);
-            cached_header_.push_back(':');
+            fmt_helper::pad2(tm_time.tm_min, cached_datetime_);
+            cached_datetime_.push_back(':');
 
-            fmt_helper::pad2(tm_time.tm_sec, cached_header_);
-            cached_header_.push_back('.');
+            fmt_helper::pad2(tm_time.tm_sec, cached_datetime_);
+            cached_datetime_.push_back('.');
 
-            cached_seconds_ts_ = seconds;
+            cache_timestamp_ = seconds;
         }
-        fmt_helper::append_buf(cached_header_, dest);
+        fmt_helper::append_buf(cached_datetime_, dest);
 
+        // cache the millis part for the next milli.
         auto millis = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count() % 1000;
-        fmt_helper::pad3(static_cast<int>(millis), dest);
-        dest.push_back(']');
-        dest.push_back(' ');
+        if(millis != millis_cache_timestamp_ || cached_millis_.size() == 0)
+        {
+            cached_millis_.resize(0);
+            fmt_helper::pad3(millis, cached_millis_);
+            cached_millis_.push_back(']');
+            cached_millis_.push_back(' ');
+            millis_cache_timestamp_ = millis;
+        }
+
+        fmt_helper::append_buf(cached_millis_, dest);
 #else // no datetime needed
         (void)tm_time;
 #endif
@@ -512,8 +528,10 @@ class full_formatter SPDLOG_FINAL : public flag_formatter
     }
 
 private:
-    std::chrono::seconds::rep cached_seconds_ts_{0};
-    fmt::memory_buffer cached_header_;
+    std::chrono::seconds cache_timestamp_ {0};
+    std::chrono::milliseconds::rep millis_cache_timestamp_ {0};
+    fmt::basic_memory_buffer<char, 128> cached_datetime_;
+    fmt::basic_memory_buffer<char, 8> cached_millis_;
 };
 
 } // namespace details

From 8baa8cf8ea8b8c3b93923501d80e0a7788fb343d Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Mon, 9 Jul 2018 23:55:17 +0300
Subject: [PATCH 49/50] fixed latency test

---
 bench/latency.cpp | 16 +++-------------
 1 file changed, 3 insertions(+), 13 deletions(-)

diff --git a/bench/latency.cpp b/bench/latency.cpp
index 55ed8e49..47e699d1 100644
--- a/bench/latency.cpp
+++ b/bench/latency.cpp
@@ -32,7 +32,7 @@ void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count
 int main(int , char *[])
 {
     std::srand(std::time(nullptr)); // use current time as seed for random generator
-    int howmany = 50;
+    int howmany = 10000;
     int queue_size = howmany + 2;
     int threads = 10;
     int file_size = 30 * 1024 * 1024;
@@ -91,12 +91,6 @@ int main(int , char *[])
     return EXIT_SUCCESS;
 }
 
-void rand_sleep()
-{
-
-    auto sleep_ms= std::chrono::milliseconds(std::rand() % 50);
-    std::this_thread::sleep_for(sleep_ms);
-}
 
 void bench(int howmany, std::shared_ptr<spdlog::logger> log)
 {
@@ -113,7 +107,6 @@ void bench(int howmany, std::shared_ptr<spdlog::logger> log)
         log->info("Hello logger: msg number {}", i);
         auto delta_nanos = chrono::duration_cast<nanoseconds>(high_resolution_clock::now() - start);
         total_nanos+= delta_nanos;
-        rand_sleep();
     }
 
     auto avg = total_nanos.count()/howmany;
@@ -129,20 +122,17 @@ void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count
 
     cout << log->name() << "...\t\t" << flush;
     vector<thread> threads;
-    nanoseconds::rep total_nanos = 0;
+    std::atomic<nanoseconds::rep> total_nanos{0};
     for (int t = 0; t < thread_count; ++t)
     {
         threads.push_back(std::thread([&]() {
-            nanoseconds thr_total_nanos = nanoseconds::zero();
             for (int j = 0; j < howmany / thread_count; j++)
             {
                 auto start = high_resolution_clock::now();
                 log->info("Hello logger: msg number {}", j);
                 auto delta_nanos = chrono::duration_cast<nanoseconds>(high_resolution_clock::now() - start);
-                thr_total_nanos+= delta_nanos;
-                rand_sleep();
+                total_nanos+= delta_nanos.count();
             }
-            total_nanos+= thr_total_nanos.count();
         }));
     }
 

From 60ca07c2d529a92e1290c23e65355c2655730d0d Mon Sep 17 00:00:00 2001
From: gabime <gmelman1@gmail.com>
Date: Mon, 9 Jul 2018 23:56:07 +0300
Subject: [PATCH 50/50] fixed latency test

---
 bench/latency.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bench/latency.cpp b/bench/latency.cpp
index 47e699d1..687565a8 100644
--- a/bench/latency.cpp
+++ b/bench/latency.cpp
@@ -32,7 +32,7 @@ void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count
 int main(int , char *[])
 {
     std::srand(std::time(nullptr)); // use current time as seed for random generator
-    int howmany = 10000;
+    int howmany = 1000000;
     int queue_size = howmany + 2;
     int threads = 10;
     int file_size = 30 * 1024 * 1024;