diff --git a/include/spdlog/details/mpmc_bounded_q.h b/include/spdlog/details/mpmc_bounded_q.h
index d788d794..03129756 100644
--- a/include/spdlog/details/mpmc_bounded_q.h
+++ b/include/spdlog/details/mpmc_bounded_q.h
@@ -1,168 +1,176 @@
-/*
-A modified version of Bounded MPMC queue by Dmitry Vyukov.
-
-Original code from:
-http://www.1024cores.net/home/lock-free-algorithms/queues/bounded-mpmc-queue
-
-licensed by Dmitry Vyukov under the terms below:
-
-Simplified BSD license
-
-Copyright (c) 2010-2011 Dmitry Vyukov. All rights reserved.
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-1. Redistributions of source code must retain the above copyright notice, this list of
-conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice, this list
-of conditions and the following disclaimer in the documentation and/or other materials
-provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY DMITRY VYUKOV "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
-SHALL DMITRY VYUKOV OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
-OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
-OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
-ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-The views and conclusions contained in the software and documentation are those of the authors and
-should not be interpreted as representing official policies, either expressed or implied, of Dmitry Vyukov.
-*/
-
-/*
-The code in its current form adds the license below:
-
-Copyright(c) 2015 Gabi Melman.
-Distributed under the MIT License (http://opensource.org/licenses/MIT)
-
-*/
-
-#pragma once
-
-#include "spdlog/common.h"
-
-#include <atomic>
-#include <utility>
-
-namespace spdlog
-{
-	namespace details
-	{
-
-		template<typename T>
-		class mpmc_bounded_queue
-		{
-		public:
-
-			using item_type = T;
-			mpmc_bounded_queue(size_t buffer_size)
-				:max_size_(buffer_size),
-				buffer_(new cell_t[buffer_size]),
-				buffer_mask_(buffer_size - 1)
-			{
-				//queue size must be power of two
-				if (!((buffer_size >= 2) && ((buffer_size & (buffer_size - 1)) == 0)))
-					throw spdlog_ex("async logger queue size must be power of two");
-
-				for (size_t i = 0; i != buffer_size; i += 1)
-					buffer_[i].sequence_.store(i, std::memory_order_relaxed);
-				enqueue_pos_.store(0, std::memory_order_relaxed);
-				dequeue_pos_.store(0, std::memory_order_relaxed);
-			}
-
-			~mpmc_bounded_queue()
-			{
-				delete[] buffer_;
-			}
-
-
-			bool enqueue(T&& data)
-			{
-				cell_t* cell;
-				size_t pos = enqueue_pos_.load(std::memory_order_relaxed);
-				for (;;) {
-					cell = &buffer_[pos & buffer_mask_];
-					size_t seq = cell->sequence_.load(std::memory_order_acquire);
-					intptr_t dif = static_cast<intptr_t>(seq) - static_cast<intptr_t>(pos);
-					if (dif == 0) {
-						if (enqueue_pos_.compare_exchange_weak(pos, pos + 1, std::memory_order_relaxed))
-							break;
-					}
-					else if (dif < 0) {
-						return false;
-					}
-					else {
-						pos = enqueue_pos_.load(std::memory_order_relaxed);
-					}
-				}
-				cell->data_ = std::move(data);
-				cell->sequence_.store(pos + 1, std::memory_order_release);
-				return true;
-			}
-
-			bool dequeue(T& data)
-			{
-				cell_t* cell;
-				size_t pos = dequeue_pos_.load(std::memory_order_relaxed);
-				for (;;) {
-					cell = &buffer_[pos & buffer_mask_];
-					size_t seq =
-						cell->sequence_.load(std::memory_order_acquire);
-					intptr_t dif = static_cast<intptr_t>(seq) - static_cast<intptr_t>(pos + 1);
-					if (dif == 0) {
-						if (dequeue_pos_.compare_exchange_weak(pos, pos + 1, std::memory_order_relaxed))
-							break;
-					}
-					else if (dif < 0)
-						return false;
-					else
-						pos = dequeue_pos_.load(std::memory_order_relaxed);
-				}
-				data = std::move(cell->data_);
-				cell->sequence_.store(pos + buffer_mask_ + 1, std::memory_order_release);
-				return true;
-			}
-
-			bool is_empty()
-			{				
-				size_t front, front1, back;
-				// try to take a consistent snapshot of front/tail.
-				do {					
-					front = enqueue_pos_.load(std::memory_order_acquire);
-					back = dequeue_pos_.load(std::memory_order_acquire);
-					front1 = enqueue_pos_.load(std::memory_order_relaxed);
-				} while (front != front1);
-				return back == front;
-			}
-
-		private:
-			struct cell_t
-			{
-				std::atomic<size_t>   sequence_;
-				T                     data_;
-			};
-
-			size_t const max_size_;
-
-			static size_t const     cacheline_size = 64;
-			typedef char            cacheline_pad_t[cacheline_size];
-
-			cacheline_pad_t         pad0_;
-			cell_t* const           buffer_;
-			size_t const            buffer_mask_;
-			cacheline_pad_t         pad1_;
-			std::atomic<size_t>     enqueue_pos_;
-			cacheline_pad_t         pad2_;
-			std::atomic<size_t>     dequeue_pos_;
-			cacheline_pad_t         pad3_;
-
-			mpmc_bounded_queue(mpmc_bounded_queue const&) = delete;
-			void operator= (mpmc_bounded_queue const&) = delete;
-		};
-
-	} // ns details
-} // ns spdlog
+/*
+A modified version of Bounded MPMC queue by Dmitry Vyukov.
+
+Original code from:
+http://www.1024cores.net/home/lock-free-algorithms/queues/bounded-mpmc-queue
+
+licensed by Dmitry Vyukov under the terms below:
+
+Simplified BSD license
+
+Copyright (c) 2010-2011 Dmitry Vyukov. All rights reserved.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+1. Redistributions of source code must retain the above copyright notice, this list of
+conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list
+of conditions and the following disclaimer in the documentation and/or other materials
+provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY DMITRY VYUKOV "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
+SHALL DMITRY VYUKOV OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+The views and conclusions contained in the software and documentation are those of the authors and
+should not be interpreted as representing official policies, either expressed or implied, of Dmitry Vyukov.
+*/
+
+/*
+The code in its current form adds the license below:
+
+Copyright(c) 2015 Gabi Melman.
+Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+*/
+
+#pragma once
+
+#include "spdlog/common.h"
+
+#include <atomic>
+#include <utility>
+
+namespace spdlog
+{
+namespace details
+{
+
+template<typename T>
+class mpmc_bounded_queue
+{
+public:
+
+    using item_type = T;
+    mpmc_bounded_queue(size_t buffer_size)
+        :max_size_(buffer_size),
+         buffer_(new cell_t[buffer_size]),
+         buffer_mask_(buffer_size - 1)
+    {
+        //queue size must be power of two
+        if (!((buffer_size >= 2) && ((buffer_size & (buffer_size - 1)) == 0)))
+            throw spdlog_ex("async logger queue size must be power of two");
+
+        for (size_t i = 0; i != buffer_size; i += 1)
+            buffer_[i].sequence_.store(i, std::memory_order_relaxed);
+        enqueue_pos_.store(0, std::memory_order_relaxed);
+        dequeue_pos_.store(0, std::memory_order_relaxed);
+    }
+
+    ~mpmc_bounded_queue()
+    {
+        delete[] buffer_;
+    }
+
+
+    bool enqueue(T&& data)
+    {
+        cell_t* cell;
+        size_t pos = enqueue_pos_.load(std::memory_order_relaxed);
+        for (;;)
+        {
+            cell = &buffer_[pos & buffer_mask_];
+            size_t seq = cell->sequence_.load(std::memory_order_acquire);
+            intptr_t dif = static_cast<intptr_t>(seq) - static_cast<intptr_t>(pos);
+            if (dif == 0)
+            {
+                if (enqueue_pos_.compare_exchange_weak(pos, pos + 1, std::memory_order_relaxed))
+                    break;
+            }
+            else if (dif < 0)
+            {
+                return false;
+            }
+            else
+            {
+                pos = enqueue_pos_.load(std::memory_order_relaxed);
+            }
+        }
+        cell->data_ = std::move(data);
+        cell->sequence_.store(pos + 1, std::memory_order_release);
+        return true;
+    }
+
+    bool dequeue(T& data)
+    {
+        cell_t* cell;
+        size_t pos = dequeue_pos_.load(std::memory_order_relaxed);
+        for (;;)
+        {
+            cell = &buffer_[pos & buffer_mask_];
+            size_t seq =
+                cell->sequence_.load(std::memory_order_acquire);
+            intptr_t dif = static_cast<intptr_t>(seq) - static_cast<intptr_t>(pos + 1);
+            if (dif == 0)
+            {
+                if (dequeue_pos_.compare_exchange_weak(pos, pos + 1, std::memory_order_relaxed))
+                    break;
+            }
+            else if (dif < 0)
+                return false;
+            else
+                pos = dequeue_pos_.load(std::memory_order_relaxed);
+        }
+        data = std::move(cell->data_);
+        cell->sequence_.store(pos + buffer_mask_ + 1, std::memory_order_release);
+        return true;
+    }
+
+    bool is_empty()
+    {
+        size_t front, front1, back;
+        // try to take a consistent snapshot of front/tail.
+        do
+        {
+            front = enqueue_pos_.load(std::memory_order_acquire);
+            back = dequeue_pos_.load(std::memory_order_acquire);
+            front1 = enqueue_pos_.load(std::memory_order_relaxed);
+        }
+        while (front != front1);
+        return back == front;
+    }
+
+private:
+    struct cell_t
+    {
+        std::atomic<size_t>   sequence_;
+        T                     data_;
+    };
+
+    size_t const max_size_;
+
+    static size_t const     cacheline_size = 64;
+    typedef char            cacheline_pad_t[cacheline_size];
+
+    cacheline_pad_t         pad0_;
+    cell_t* const           buffer_;
+    size_t const            buffer_mask_;
+    cacheline_pad_t         pad1_;
+    std::atomic<size_t>     enqueue_pos_;
+    cacheline_pad_t         pad2_;
+    std::atomic<size_t>     dequeue_pos_;
+    cacheline_pad_t         pad3_;
+
+    mpmc_bounded_queue(mpmc_bounded_queue const&) = delete;
+    void operator= (mpmc_bounded_queue const&) = delete;
+};
+
+} // ns details
+} // ns spdlog
diff --git a/include/spdlog/details/os.h b/include/spdlog/details/os.h
index dceecdf2..ca6450b0 100644
--- a/include/spdlog/details/os.h
+++ b/include/spdlog/details/os.h
@@ -1,469 +1,469 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-#pragma once
-
-#include "spdlog/common.h"
-
-#include <cstdio>
-#include <ctime>
-#include <functional>
-#include <string>
-#include <chrono>
-#include <thread>
-#include <algorithm>
-#include <cstring>
-#include <cstdlib>
-#include <sys/stat.h>
-#include <sys/types.h>
-
-#ifdef _WIN32
-
-#ifndef NOMINMAX
-#define NOMINMAX //prevent windows redefining min/max
-#endif
-
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN
-#endif
-#include <windows.h>
-#include <process.h> //  _get_pid support
-#include <io.h> // _get_osfhandle and _isatty support
-
-#ifdef __MINGW32__
-#include <share.h>
-#endif
-
-#else // unix
-
-#include <unistd.h>
-#include <fcntl.h>
-
-#ifdef __linux__
-#include <sys/syscall.h> //Use gettid() syscall under linux to get thread id
-
-#elif __FreeBSD__
-#include <sys/thr.h> //Use thr_self() syscall under FreeBSD to get thread id
-#endif
-
-#endif //unix
-
-#ifndef __has_feature       // Clang - feature checking macros.
-#define __has_feature(x) 0  // Compatibility with non-clang compilers.
-#endif
-
-
-namespace spdlog
-{
-namespace details
-{
-namespace os
-{
-
-inline spdlog::log_clock::time_point now()
-{
-
-#if defined __linux__ && defined SPDLOG_CLOCK_COARSE
-    timespec ts;
-    ::clock_gettime(CLOCK_REALTIME_COARSE, &ts);
-    return std::chrono::time_point<log_clock, typename log_clock::duration>(
-               std::chrono::duration_cast<typename log_clock::duration>(
-                   std::chrono::seconds(ts.tv_sec) + std::chrono::nanoseconds(ts.tv_nsec)));
-
-
-#else
-    return log_clock::now();
-#endif
-
-}
-inline std::tm localtime(const std::time_t &time_tt)
-{
-
-#ifdef _WIN32
-    std::tm tm;
-    localtime_s(&tm, &time_tt);
-#else
-    std::tm tm;
-    localtime_r(&time_tt, &tm);
-#endif
-    return tm;
-}
-
-inline std::tm localtime()
-{
-    std::time_t now_t = time(nullptr);
-    return localtime(now_t);
-}
-
-
-inline std::tm gmtime(const std::time_t &time_tt)
-{
-
-#ifdef _WIN32
-    std::tm tm;
-    gmtime_s(&tm, &time_tt);
-#else
-    std::tm tm;
-    gmtime_r(&time_tt, &tm);
-#endif
-    return tm;
-}
-
-inline std::tm gmtime()
-{
-    std::time_t now_t = time(nullptr);
-    return gmtime(now_t);
-}
-inline bool operator==(const std::tm& tm1, const std::tm& tm2)
-{
-    return (tm1.tm_sec == tm2.tm_sec &&
-            tm1.tm_min == tm2.tm_min &&
-            tm1.tm_hour == tm2.tm_hour &&
-            tm1.tm_mday == tm2.tm_mday &&
-            tm1.tm_mon == tm2.tm_mon &&
-            tm1.tm_year == tm2.tm_year &&
-            tm1.tm_isdst == tm2.tm_isdst);
-}
-
-inline bool operator!=(const std::tm& tm1, const std::tm& tm2)
-{
-    return !(tm1 == tm2);
-}
-
-// eol definition
-#if !defined (SPDLOG_EOL)
-#ifdef _WIN32
-#define SPDLOG_EOL "\r\n"
-#else
-#define SPDLOG_EOL "\n"
-#endif
-#endif
-
-SPDLOG_CONSTEXPR static const char* eol = SPDLOG_EOL;
-SPDLOG_CONSTEXPR static int eol_size = sizeof(SPDLOG_EOL) - 1;
-
-inline void prevent_child_fd(FILE *f)
-{
-#ifdef _WIN32
-    auto file_handle = (HANDLE)_get_osfhandle(_fileno(f));
-    if (!::SetHandleInformation(file_handle, HANDLE_FLAG_INHERIT, 0))
-        throw spdlog_ex("SetHandleInformation failed", errno);
-#else
-    auto fd = fileno(f);
-    if (fcntl(fd, F_SETFD, FD_CLOEXEC) == -1)
-        throw spdlog_ex("fcntl with FD_CLOEXEC failed", errno);
-#endif
-}
-
-
-//fopen_s on non windows for writing
-inline int fopen_s(FILE** fp, const filename_t& filename, const filename_t& mode)
-{
-#ifdef _WIN32
-#ifdef SPDLOG_WCHAR_FILENAMES
-    *fp = _wfsopen((filename.c_str()), mode.c_str(), _SH_DENYWR);
-#else
-    *fp = _fsopen((filename.c_str()), mode.c_str(), _SH_DENYWR);
-#endif
-#else //unix
-    *fp = fopen((filename.c_str()), mode.c_str());
-#endif
-
-#ifdef SPDLOG_PREVENT_CHILD_FD
-    if (*fp != nullptr)
-        prevent_child_fd(*fp);
-#endif
-    return *fp == nullptr;
-}
-
-
-inline int remove(const filename_t &filename)
-{
-#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
-    return _wremove(filename.c_str());
-#else
-    return std::remove(filename.c_str());
-#endif
-}
-
-inline int rename(const filename_t& filename1, const filename_t& filename2)
-{
-#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
-    return _wrename(filename1.c_str(), filename2.c_str());
-#else
-    return std::rename(filename1.c_str(), filename2.c_str());
-#endif
-}
-
-
-//Return if file exists
-inline bool file_exists(const filename_t& filename)
-{
-#ifdef _WIN32
-#ifdef SPDLOG_WCHAR_FILENAMES
-    auto attribs = GetFileAttributesW(filename.c_str());
-#else
-    auto attribs = GetFileAttributesA(filename.c_str());
-#endif
-    return (attribs != INVALID_FILE_ATTRIBUTES && !(attribs & FILE_ATTRIBUTE_DIRECTORY));
-#else //common linux/unix all have the stat system call
-    struct stat buffer;
-    return (stat(filename.c_str(), &buffer) == 0);
-#endif
-}
-
-
-
-
-//Return file size according to open FILE* object
-inline size_t filesize(FILE *f)
-{
-    if (f == nullptr)
-        throw spdlog_ex("Failed getting file size. fd is null");
-#if defined ( _WIN32) && !defined(__CYGWIN__)
-    int fd = _fileno(f);
-#if _WIN64 //64 bits
-    struct _stat64 st;
-    if (_fstat64(fd, &st) == 0)
-        return st.st_size;
-
-#else //windows 32 bits
-    long ret = _filelength(fd);
-    if (ret >= 0)
-        return static_cast<size_t>(ret);
-#endif
-
-#else // unix
-    int fd = fileno(f);
-    //64 bits(but not in osx or cygwin, where fstat64 is deprecated)
-#if !defined(__FreeBSD__) && !defined(__APPLE__) && (defined(__x86_64__) || defined(__ppc64__)) && !defined(__CYGWIN__)
-    struct stat64 st;
-    if (fstat64(fd, &st) == 0)
-        return static_cast<size_t>(st.st_size);
-#else // unix 32 bits or cygwin
-    struct stat st;
-    if (fstat(fd, &st) == 0)
-        return static_cast<size_t>(st.st_size);
-#endif
-#endif
-    throw spdlog_ex("Failed getting file size from fd", errno);
-}
-
-
-
-
-//Return utc offset in minutes or throw spdlog_ex on failure
-inline int utc_minutes_offset(const std::tm& tm = details::os::localtime())
-{
-
-#ifdef _WIN32
-#if _WIN32_WINNT < _WIN32_WINNT_WS08
-    TIME_ZONE_INFORMATION tzinfo;
-    auto rv = GetTimeZoneInformation(&tzinfo);
-#else
-    DYNAMIC_TIME_ZONE_INFORMATION tzinfo;
-    auto rv = GetDynamicTimeZoneInformation(&tzinfo);
-#endif
-    if (rv == TIME_ZONE_ID_INVALID)
-        throw spdlog::spdlog_ex("Failed getting timezone info. ", errno);
-
-    int offset = -tzinfo.Bias;
-    if (tm.tm_isdst)
-        offset -= tzinfo.DaylightBias;
-    else
-        offset -= tzinfo.StandardBias;
-    return offset;
-#else
-
-#if defined(sun) || defined(__sun)
-    // 'tm_gmtoff' field is BSD extension and it's missing on SunOS/Solaris
-    struct helper
-    {
-        static long int calculate_gmt_offset(const std::tm & localtm = details::os::localtime(), const std::tm & gmtm = details::os::gmtime())
-        {
-            int local_year = localtm.tm_year + (1900 - 1);
-            int gmt_year = gmtm.tm_year + (1900 - 1);
-
-            long int days = (
-                                // difference in day of year
-                                localtm.tm_yday - gmtm.tm_yday
-
-                                // + intervening leap days
-                                + ((local_year >> 2) - (gmt_year >> 2))
-                                - (local_year / 100 - gmt_year / 100)
-                                + ((local_year / 100 >> 2) - (gmt_year / 100 >> 2))
-
-                                // + difference in years * 365 */
-                                + (long int)(local_year - gmt_year) * 365
-                            );
-
-            long int hours = (24 * days) + (localtm.tm_hour - gmtm.tm_hour);
-            long int mins = (60 * hours) + (localtm.tm_min - gmtm.tm_min);
-            long int secs = (60 * mins) + (localtm.tm_sec - gmtm.tm_sec);
-
-            return secs;
-        }
-    };
-
-    long int offset_seconds = helper::calculate_gmt_offset(tm);
-#else
-    long int offset_seconds = tm.tm_gmtoff;
-#endif
-
-    return static_cast<int>(offset_seconds / 60);
-#endif
-}
-
-//Return current thread id as size_t
-//It exists because the std::this_thread::get_id() is much slower(espcially under VS 2013)
-inline size_t _thread_id()
-{
-#ifdef _WIN32
-    return  static_cast<size_t>(::GetCurrentThreadId());
-#elif __linux__
-# if defined(__ANDROID__) && defined(__ANDROID_API__) && (__ANDROID_API__ < 21)
-#  define SYS_gettid __NR_gettid
-# endif
-    return  static_cast<size_t>(syscall(SYS_gettid));
-#elif __FreeBSD__
-    long tid;
-    thr_self(&tid);
-    return static_cast<size_t>(tid);
-#elif __APPLE__
-    uint64_t tid;
-    pthread_threadid_np(nullptr, &tid);
-    return static_cast<size_t>(tid);
-#else //Default to standard C++11 (other Unix)
-    return static_cast<size_t>(std::hash<std::thread::id>()(std::this_thread::get_id()));
-#endif
-}
-
-//Return current thread id as size_t (from thread local storage)
-inline size_t thread_id()
-{
-#if defined(_MSC_VER) && (_MSC_VER < 1900) || defined(__clang__) && !__has_feature(cxx_thread_local)
-    return _thread_id();
-#else
-    static thread_local const size_t tid = _thread_id();
-    return tid;
-#endif
-}
-
-
-
-
-// wchar support for windows file names (SPDLOG_WCHAR_FILENAMES must be defined)
-#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
-#define SPDLOG_FILENAME_T(s) L ## s
-inline std::string filename_to_str(const filename_t& filename)
-{
-    std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t> c;
-    return c.to_bytes(filename);
-}
-#else
-#define SPDLOG_FILENAME_T(s) s
-inline std::string filename_to_str(const filename_t& filename)
-{
-    return filename;
-}
-#endif
-
-inline std::string errno_to_string(char[256], char* res)
-{
-    return std::string(res);
-}
-
-inline std::string errno_to_string(char buf[256], int res)
-{
-    if (res == 0)
-    {
-        return std::string(buf);
-    }
-    else
-    {
-        return "Unknown error";
-    }
-}
-
-// Return errno string (thread safe)
-inline std::string errno_str(int err_num)
-{
-    char buf[256];
-    SPDLOG_CONSTEXPR auto buf_size = sizeof(buf);
-
-#ifdef _WIN32
-    if (strerror_s(buf, buf_size, err_num) == 0)
-        return std::string(buf);
-    else
-        return "Unknown error";
-
-#elif defined(__FreeBSD__) || defined(__APPLE__) || defined(ANDROID) || defined(__SUNPRO_CC) || \
-      ((_POSIX_C_SOURCE >= 200112L) && ! defined(_GNU_SOURCE)) // posix version
-
-    if (strerror_r(err_num, buf, buf_size) == 0)
-        return std::string(buf);
-    else
-        return "Unknown error";
-
-#else  // gnu version (might not use the given buf, so its retval pointer must be used)
-    auto err = strerror_r(err_num, buf, buf_size); // let compiler choose type
-    return errno_to_string(buf, err); // use overloading to select correct stringify function
-#endif
-}
-
-inline int pid()
-{
-
-#ifdef _WIN32
-    return ::_getpid();
-#else
-    return static_cast<int>(::getpid());
-#endif
-
-}
-
-
-// Detrmine if the terminal supports colors
-// Source: https://github.com/agauniyal/rang/
-inline bool is_color_terminal()
-{
-#ifdef _WIN32
-    return true;
-#else
-    static constexpr const char* Terms[] =
-    {
-        "ansi", "color", "console", "cygwin", "gnome", "konsole", "kterm",
-        "linux", "msys", "putty", "rxvt", "screen", "vt100", "xterm"
-    };
-
-    const char *env_p = std::getenv("TERM");
-    if (env_p == nullptr)
-    {
-        return false;
-    }
-
-    static const bool result = std::any_of(
-                                   std::begin(Terms), std::end(Terms), [&](const char* term)
-    {
-        return std::strstr(env_p, term) != nullptr;
-    });
-    return result;
-#endif
-}
-
-
-// Detrmine if the terminal attached
-// Source: https://github.com/agauniyal/rang/
-inline bool in_terminal(FILE* file)
-{
-
-#ifdef _WIN32
-    return _isatty(_fileno(file)) ? true : false;
-#else
-    return isatty(fileno(file)) ? true : false;
-#endif
-}
-} //os
-} //details
-} //spdlog
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+#pragma once
+
+#include "spdlog/common.h"
+
+#include <cstdio>
+#include <ctime>
+#include <functional>
+#include <string>
+#include <chrono>
+#include <thread>
+#include <algorithm>
+#include <cstring>
+#include <cstdlib>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#ifdef _WIN32
+
+#ifndef NOMINMAX
+#define NOMINMAX //prevent windows redefining min/max
+#endif
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#include <process.h> //  _get_pid support
+#include <io.h> // _get_osfhandle and _isatty support
+
+#ifdef __MINGW32__
+#include <share.h>
+#endif
+
+#else // unix
+
+#include <unistd.h>
+#include <fcntl.h>
+
+#ifdef __linux__
+#include <sys/syscall.h> //Use gettid() syscall under linux to get thread id
+
+#elif __FreeBSD__
+#include <sys/thr.h> //Use thr_self() syscall under FreeBSD to get thread id
+#endif
+
+#endif //unix
+
+#ifndef __has_feature       // Clang - feature checking macros.
+#define __has_feature(x) 0  // Compatibility with non-clang compilers.
+#endif
+
+
+namespace spdlog
+{
+namespace details
+{
+namespace os
+{
+
+inline spdlog::log_clock::time_point now()
+{
+
+#if defined __linux__ && defined SPDLOG_CLOCK_COARSE
+    timespec ts;
+    ::clock_gettime(CLOCK_REALTIME_COARSE, &ts);
+    return std::chrono::time_point<log_clock, typename log_clock::duration>(
+               std::chrono::duration_cast<typename log_clock::duration>(
+                   std::chrono::seconds(ts.tv_sec) + std::chrono::nanoseconds(ts.tv_nsec)));
+
+
+#else
+    return log_clock::now();
+#endif
+
+}
+inline std::tm localtime(const std::time_t &time_tt)
+{
+
+#ifdef _WIN32
+    std::tm tm;
+    localtime_s(&tm, &time_tt);
+#else
+    std::tm tm;
+    localtime_r(&time_tt, &tm);
+#endif
+    return tm;
+}
+
+inline std::tm localtime()
+{
+    std::time_t now_t = time(nullptr);
+    return localtime(now_t);
+}
+
+
+inline std::tm gmtime(const std::time_t &time_tt)
+{
+
+#ifdef _WIN32
+    std::tm tm;
+    gmtime_s(&tm, &time_tt);
+#else
+    std::tm tm;
+    gmtime_r(&time_tt, &tm);
+#endif
+    return tm;
+}
+
+inline std::tm gmtime()
+{
+    std::time_t now_t = time(nullptr);
+    return gmtime(now_t);
+}
+inline bool operator==(const std::tm& tm1, const std::tm& tm2)
+{
+    return (tm1.tm_sec == tm2.tm_sec &&
+            tm1.tm_min == tm2.tm_min &&
+            tm1.tm_hour == tm2.tm_hour &&
+            tm1.tm_mday == tm2.tm_mday &&
+            tm1.tm_mon == tm2.tm_mon &&
+            tm1.tm_year == tm2.tm_year &&
+            tm1.tm_isdst == tm2.tm_isdst);
+}
+
+inline bool operator!=(const std::tm& tm1, const std::tm& tm2)
+{
+    return !(tm1 == tm2);
+}
+
+// eol definition
+#if !defined (SPDLOG_EOL)
+#ifdef _WIN32
+#define SPDLOG_EOL "\r\n"
+#else
+#define SPDLOG_EOL "\n"
+#endif
+#endif
+
+SPDLOG_CONSTEXPR static const char* eol = SPDLOG_EOL;
+SPDLOG_CONSTEXPR static int eol_size = sizeof(SPDLOG_EOL) - 1;
+
+inline void prevent_child_fd(FILE *f)
+{
+#ifdef _WIN32
+    auto file_handle = (HANDLE)_get_osfhandle(_fileno(f));
+    if (!::SetHandleInformation(file_handle, HANDLE_FLAG_INHERIT, 0))
+        throw spdlog_ex("SetHandleInformation failed", errno);
+#else
+    auto fd = fileno(f);
+    if (fcntl(fd, F_SETFD, FD_CLOEXEC) == -1)
+        throw spdlog_ex("fcntl with FD_CLOEXEC failed", errno);
+#endif
+}
+
+
+//fopen_s on non windows for writing
+inline int fopen_s(FILE** fp, const filename_t& filename, const filename_t& mode)
+{
+#ifdef _WIN32
+#ifdef SPDLOG_WCHAR_FILENAMES
+    *fp = _wfsopen((filename.c_str()), mode.c_str(), _SH_DENYWR);
+#else
+    *fp = _fsopen((filename.c_str()), mode.c_str(), _SH_DENYWR);
+#endif
+#else //unix
+    *fp = fopen((filename.c_str()), mode.c_str());
+#endif
+
+#ifdef SPDLOG_PREVENT_CHILD_FD
+    if (*fp != nullptr)
+        prevent_child_fd(*fp);
+#endif
+    return *fp == nullptr;
+}
+
+
+inline int remove(const filename_t &filename)
+{
+#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
+    return _wremove(filename.c_str());
+#else
+    return std::remove(filename.c_str());
+#endif
+}
+
+inline int rename(const filename_t& filename1, const filename_t& filename2)
+{
+#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
+    return _wrename(filename1.c_str(), filename2.c_str());
+#else
+    return std::rename(filename1.c_str(), filename2.c_str());
+#endif
+}
+
+
+//Return if file exists
+inline bool file_exists(const filename_t& filename)
+{
+#ifdef _WIN32
+#ifdef SPDLOG_WCHAR_FILENAMES
+    auto attribs = GetFileAttributesW(filename.c_str());
+#else
+    auto attribs = GetFileAttributesA(filename.c_str());
+#endif
+    return (attribs != INVALID_FILE_ATTRIBUTES && !(attribs & FILE_ATTRIBUTE_DIRECTORY));
+#else //common linux/unix all have the stat system call
+    struct stat buffer;
+    return (stat(filename.c_str(), &buffer) == 0);
+#endif
+}
+
+
+
+
+//Return file size according to open FILE* object
+inline size_t filesize(FILE *f)
+{
+    if (f == nullptr)
+        throw spdlog_ex("Failed getting file size. fd is null");
+#if defined ( _WIN32) && !defined(__CYGWIN__)
+    int fd = _fileno(f);
+#if _WIN64 //64 bits
+    struct _stat64 st;
+    if (_fstat64(fd, &st) == 0)
+        return st.st_size;
+
+#else //windows 32 bits
+    long ret = _filelength(fd);
+    if (ret >= 0)
+        return static_cast<size_t>(ret);
+#endif
+
+#else // unix
+    int fd = fileno(f);
+    //64 bits(but not in osx or cygwin, where fstat64 is deprecated)
+#if !defined(__FreeBSD__) && !defined(__APPLE__) && (defined(__x86_64__) || defined(__ppc64__)) && !defined(__CYGWIN__)
+    struct stat64 st;
+    if (fstat64(fd, &st) == 0)
+        return static_cast<size_t>(st.st_size);
+#else // unix 32 bits or cygwin
+    struct stat st;
+    if (fstat(fd, &st) == 0)
+        return static_cast<size_t>(st.st_size);
+#endif
+#endif
+    throw spdlog_ex("Failed getting file size from fd", errno);
+}
+
+
+
+
+//Return utc offset in minutes or throw spdlog_ex on failure
+inline int utc_minutes_offset(const std::tm& tm = details::os::localtime())
+{
+
+#ifdef _WIN32
+#if _WIN32_WINNT < _WIN32_WINNT_WS08
+    TIME_ZONE_INFORMATION tzinfo;
+    auto rv = GetTimeZoneInformation(&tzinfo);
+#else
+    DYNAMIC_TIME_ZONE_INFORMATION tzinfo;
+    auto rv = GetDynamicTimeZoneInformation(&tzinfo);
+#endif
+    if (rv == TIME_ZONE_ID_INVALID)
+        throw spdlog::spdlog_ex("Failed getting timezone info. ", errno);
+
+    int offset = -tzinfo.Bias;
+    if (tm.tm_isdst)
+        offset -= tzinfo.DaylightBias;
+    else
+        offset -= tzinfo.StandardBias;
+    return offset;
+#else
+
+#if defined(sun) || defined(__sun)
+    // 'tm_gmtoff' field is BSD extension and it's missing on SunOS/Solaris
+    struct helper
+    {
+        static long int calculate_gmt_offset(const std::tm & localtm = details::os::localtime(), const std::tm & gmtm = details::os::gmtime())
+        {
+            int local_year = localtm.tm_year + (1900 - 1);
+            int gmt_year = gmtm.tm_year + (1900 - 1);
+
+            long int days = (
+                                // difference in day of year
+                                localtm.tm_yday - gmtm.tm_yday
+
+                                // + intervening leap days
+                                + ((local_year >> 2) - (gmt_year >> 2))
+                                - (local_year / 100 - gmt_year / 100)
+                                + ((local_year / 100 >> 2) - (gmt_year / 100 >> 2))
+
+                                // + difference in years * 365 */
+                                + (long int)(local_year - gmt_year) * 365
+                            );
+
+            long int hours = (24 * days) + (localtm.tm_hour - gmtm.tm_hour);
+            long int mins = (60 * hours) + (localtm.tm_min - gmtm.tm_min);
+            long int secs = (60 * mins) + (localtm.tm_sec - gmtm.tm_sec);
+
+            return secs;
+        }
+    };
+
+    long int offset_seconds = helper::calculate_gmt_offset(tm);
+#else
+    long int offset_seconds = tm.tm_gmtoff;
+#endif
+
+    return static_cast<int>(offset_seconds / 60);
+#endif
+}
+
+//Return current thread id as size_t
+//It exists because the std::this_thread::get_id() is much slower(espcially under VS 2013)
+inline size_t _thread_id()
+{
+#ifdef _WIN32
+    return  static_cast<size_t>(::GetCurrentThreadId());
+#elif __linux__
+# if defined(__ANDROID__) && defined(__ANDROID_API__) && (__ANDROID_API__ < 21)
+#  define SYS_gettid __NR_gettid
+# endif
+    return  static_cast<size_t>(syscall(SYS_gettid));
+#elif __FreeBSD__
+    long tid;
+    thr_self(&tid);
+    return static_cast<size_t>(tid);
+#elif __APPLE__
+    uint64_t tid;
+    pthread_threadid_np(nullptr, &tid);
+    return static_cast<size_t>(tid);
+#else //Default to standard C++11 (other Unix)
+    return static_cast<size_t>(std::hash<std::thread::id>()(std::this_thread::get_id()));
+#endif
+}
+
+//Return current thread id as size_t (from thread local storage)
+inline size_t thread_id()
+{
+#if defined(_MSC_VER) && (_MSC_VER < 1900) || defined(__clang__) && !__has_feature(cxx_thread_local)
+    return _thread_id();
+#else
+    static thread_local const size_t tid = _thread_id();
+    return tid;
+#endif
+}
+
+
+
+
+// wchar support for windows file names (SPDLOG_WCHAR_FILENAMES must be defined)
+#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
+#define SPDLOG_FILENAME_T(s) L ## s
+inline std::string filename_to_str(const filename_t& filename)
+{
+    std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t> c;
+    return c.to_bytes(filename);
+}
+#else
+#define SPDLOG_FILENAME_T(s) s
+inline std::string filename_to_str(const filename_t& filename)
+{
+    return filename;
+}
+#endif
+
+inline std::string errno_to_string(char[256], char* res)
+{
+    return std::string(res);
+}
+
+inline std::string errno_to_string(char buf[256], int res)
+{
+    if (res == 0)
+    {
+        return std::string(buf);
+    }
+    else
+    {
+        return "Unknown error";
+    }
+}
+
+// Return errno string (thread safe)
+inline std::string errno_str(int err_num)
+{
+    char buf[256];
+    SPDLOG_CONSTEXPR auto buf_size = sizeof(buf);
+
+#ifdef _WIN32
+    if (strerror_s(buf, buf_size, err_num) == 0)
+        return std::string(buf);
+    else
+        return "Unknown error";
+
+#elif defined(__FreeBSD__) || defined(__APPLE__) || defined(ANDROID) || defined(__SUNPRO_CC) || \
+      ((_POSIX_C_SOURCE >= 200112L) && ! defined(_GNU_SOURCE)) // posix version
+
+    if (strerror_r(err_num, buf, buf_size) == 0)
+        return std::string(buf);
+    else
+        return "Unknown error";
+
+#else  // gnu version (might not use the given buf, so its retval pointer must be used)
+    auto err = strerror_r(err_num, buf, buf_size); // let compiler choose type
+    return errno_to_string(buf, err); // use overloading to select correct stringify function
+#endif
+}
+
+inline int pid()
+{
+
+#ifdef _WIN32
+    return ::_getpid();
+#else
+    return static_cast<int>(::getpid());
+#endif
+
+}
+
+
+// Detrmine if the terminal supports colors
+// Source: https://github.com/agauniyal/rang/
+inline bool is_color_terminal()
+{
+#ifdef _WIN32
+    return true;
+#else
+    static constexpr const char* Terms[] =
+    {
+        "ansi", "color", "console", "cygwin", "gnome", "konsole", "kterm",
+        "linux", "msys", "putty", "rxvt", "screen", "vt100", "xterm"
+    };
+
+    const char *env_p = std::getenv("TERM");
+    if (env_p == nullptr)
+    {
+        return false;
+    }
+
+    static const bool result = std::any_of(
+                                   std::begin(Terms), std::end(Terms), [&](const char* term)
+    {
+        return std::strstr(env_p, term) != nullptr;
+    });
+    return result;
+#endif
+}
+
+
+// Detrmine if the terminal attached
+// Source: https://github.com/agauniyal/rang/
+inline bool in_terminal(FILE* file)
+{
+
+#ifdef _WIN32
+    return _isatty(_fileno(file)) ? true : false;
+#else
+    return isatty(fileno(file)) ? true : false;
+#endif
+}
+} //os
+} //details
+} //spdlog
diff --git a/include/spdlog/fmt/bundled/format.h b/include/spdlog/fmt/bundled/format.h
index 6ee9d2a2..91f43481 100644
--- a/include/spdlog/fmt/bundled/format.h
+++ b/include/spdlog/fmt/bundled/format.h
@@ -303,19 +303,22 @@ typedef __int64          intmax_t;
 #if FMT_MSC_VER && !defined(FMT_BUILTIN_CLZLL) && !defined(_MANAGED)
 # include <intrin.h>  // _BitScanReverse, _BitScanReverse64
 
-namespace fmt {
-namespace internal {
+namespace fmt
+{
+namespace internal
+{
 # pragma intrinsic(_BitScanReverse)
-inline uint32_t clz(uint32_t x) {
-  unsigned long r = 0;
-  _BitScanReverse(&r, x);
+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.
+    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;
+    return 31 - r;
 }
 # define FMT_BUILTIN_CLZ(n) fmt::internal::clz(n)
 
@@ -323,106 +326,143 @@ inline uint32_t clz(uint32_t x) {
 #  pragma intrinsic(_BitScanReverse64)
 # endif
 
-inline uint32_t clzll(uint64_t x) {
-  unsigned long r = 0;
+inline uint32_t clzll(uint64_t x)
+{
+    unsigned long r = 0;
 # ifdef _WIN64
-  _BitScanReverse64(&r, x);
+    _BitScanReverse64(&r, x);
 # else
-  // Scan the high 32 bits.
-  if (_BitScanReverse(&r, static_cast<uint32_t>(x >> 32)))
-    return 63 - (r + 32);
+    // 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));
+    // 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.
+    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;
+    return 63 - r;
 }
 # define FMT_BUILTIN_CLZLL(n) fmt::internal::clzll(n)
 }
 }
 #endif
 
-namespace fmt {
-namespace internal {
-struct DummyInt {
-  int data[2];
-  operator int() const { return 0; }
+namespace fmt
+{
+namespace internal
+{
+struct DummyInt
+{
+    int data[2];
+    operator int() const
+    {
+        return 0;
+    }
 };
 typedef std::numeric_limits<fmt::internal::DummyInt> FPUtil;
 
 // Dummy implementations of system functions such as signbit and ecvt called
 // if the latter are not available.
-inline DummyInt signbit(...) { return DummyInt(); }
-inline DummyInt _ecvt_s(...) { return DummyInt(); }
-inline DummyInt isinf(...) { return DummyInt(); }
-inline DummyInt _finite(...) { return DummyInt(); }
-inline DummyInt isnan(...) { return DummyInt(); }
-inline DummyInt _isnan(...) { return DummyInt(); }
+inline DummyInt signbit(...)
+{
+    return DummyInt();
+}
+inline DummyInt _ecvt_s(...)
+{
+    return DummyInt();
+}
+inline DummyInt isinf(...)
+{
+    return DummyInt();
+}
+inline DummyInt _finite(...)
+{
+    return DummyInt();
+}
+inline DummyInt isnan(...)
+{
+    return DummyInt();
+}
+inline DummyInt _isnan(...)
+{
+    return DummyInt();
+}
 
 // A helper function to suppress bogus "conditional expression is constant"
 // warnings.
 template <typename T>
-inline T const_check(T value) { return value; }
+inline T const_check(T value)
+{
+    return value;
+}
 }
 }  // namespace fmt
 
-namespace std {
+namespace std
+{
 // Standard permits specialization of std::numeric_limits. This specialization
 // is used to resolve ambiguity between isinf and std::isinf in glibc:
 // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=48891
 // and the same for isnan and signbit.
 template <>
 class numeric_limits<fmt::internal::DummyInt> :
-    public std::numeric_limits<int> {
- public:
-  // Portable version of isinf.
-  template <typename T>
-  static bool isinfinity(T x) {
-    using namespace fmt::internal;
-    // The resolution "priority" is:
-    // isinf macro > std::isinf > ::isinf > fmt::internal::isinf
-    if (const_check(sizeof(isinf(x)) == sizeof(bool) ||
-                    sizeof(isinf(x)) == sizeof(int))) {
-      return isinf(x) != 0;
+    public std::numeric_limits<int>
+{
+public:
+    // Portable version of isinf.
+    template <typename T>
+    static bool isinfinity(T x)
+    {
+        using namespace fmt::internal;
+        // The resolution "priority" is:
+        // isinf macro > std::isinf > ::isinf > fmt::internal::isinf
+        if (const_check(sizeof(isinf(x)) == sizeof(bool) ||
+                        sizeof(isinf(x)) == sizeof(int)))
+        {
+            return isinf(x) != 0;
+        }
+        return !_finite(static_cast<double>(x));
     }
-    return !_finite(static_cast<double>(x));
-  }
 
-  // Portable version of isnan.
-  template <typename T>
-  static bool isnotanumber(T x) {
-    using namespace fmt::internal;
-    if (const_check(sizeof(isnan(x)) == sizeof(bool) ||
-                    sizeof(isnan(x)) == sizeof(int))) {
-      return isnan(x) != 0;
+    // Portable version of isnan.
+    template <typename T>
+    static bool isnotanumber(T x)
+    {
+        using namespace fmt::internal;
+        if (const_check(sizeof(isnan(x)) == sizeof(bool) ||
+                        sizeof(isnan(x)) == sizeof(int)))
+        {
+            return isnan(x) != 0;
+        }
+        return _isnan(static_cast<double>(x)) != 0;
     }
-    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(bool) ||
-                    sizeof(signbit(x)) == sizeof(int))) {
-      return signbit(x) != 0;
+    // Portable version of signbit.
+    static bool isnegative(double x)
+    {
+        using namespace fmt::internal;
+        if (const_check(sizeof(signbit(x)) == sizeof(bool) ||
+                        sizeof(signbit(x)) == sizeof(int)))
+        {
+            return signbit(x) != 0;
+        }
+        if (x < 0) return true;
+        if (!isnotanumber(x)) return false;
+        int dec = 0, sign = 0;
+        char buffer[2];  // The buffer size must be >= 2 or _ecvt_s will fail.
+        _ecvt_s(buffer, sizeof(buffer), x, 0, &dec, &sign);
+        return sign != 0;
     }
-    if (x < 0) return true;
-    if (!isnotanumber(x)) return false;
-    int dec = 0, sign = 0;
-    char buffer[2];  // The buffer size must be >= 2 or _ecvt_s will fail.
-    _ecvt_s(buffer, sizeof(buffer), x, 0, &dec, &sign);
-    return sign != 0;
-  }
 };
 }  // namespace std
 
-namespace fmt {
+namespace fmt
+{
 
 // Fix the warning about long long on older versions of GCC
 // that don't support the diagnostic pragma.
@@ -477,76 +517,91 @@ class BasicFormatter;
   \endrst
  */
 template <typename Char>
-class BasicStringRef {
- private:
-  const Char *data_;
-  std::size_t size_;
+class BasicStringRef
+{
+private:
+    const Char *data_;
+    std::size_t size_;
 
- public:
-  /** Constructs a string reference object from a C string and a size. */
-  BasicStringRef(const Char *s, std::size_t size) : data_(s), size_(size) {}
+public:
+    /** Constructs a string reference object from a C string and a size. */
+    BasicStringRef(const Char *s, std::size_t size) : data_(s), size_(size) {}
 
-  /**
-    \rst
-    Constructs a string reference object from a C string computing
-    the size with ``std::char_traits<Char>::length``.
-    \endrst
-   */
-  BasicStringRef(const Char *s)
-    : data_(s), size_(std::char_traits<Char>::length(s)) {}
+    /**
+      \rst
+      Constructs a string reference object from a C string computing
+      the size with ``std::char_traits<Char>::length``.
+      \endrst
+     */
+    BasicStringRef(const Char *s)
+        : data_(s), size_(std::char_traits<Char>::length(s)) {}
 
-  /**
-    \rst
-    Constructs a string reference from a ``std::basic_string`` object.
-    \endrst
-   */
-  template <typename Allocator>
-  BasicStringRef(
-      const std::basic_string<Char, std::char_traits<Char>, Allocator> &s)
-  : data_(s.c_str()), size_(s.size()) {}
+    /**
+      \rst
+      Constructs a string reference from a ``std::basic_string`` object.
+      \endrst
+     */
+    template <typename Allocator>
+    BasicStringRef(
+        const std::basic_string<Char, std::char_traits<Char>, Allocator> &s)
+        : data_(s.c_str()), size_(s.size()) {}
 
-  /**
-    \rst
-    Converts a string reference to an ``std::string`` object.
-    \endrst
-   */
-  std::basic_string<Char> to_string() const {
-    return std::basic_string<Char>(data_, size_);
-  }
+    /**
+      \rst
+      Converts a string reference to an ``std::string`` object.
+      \endrst
+     */
+    std::basic_string<Char> to_string() const
+    {
+        return std::basic_string<Char>(data_, size_);
+    }
 
-  /** Returns a pointer to the string data. */
-  const Char *data() const { return data_; }
+    /** Returns a pointer to the string data. */
+    const Char *data() const
+    {
+        return data_;
+    }
 
-  /** Returns the string size. */
-  std::size_t size() const { return size_; }
+    /** Returns the string size. */
+    std::size_t size() const
+    {
+        return size_;
+    }
 
-  // Lexicographically compare this string reference to other.
-  int compare(BasicStringRef other) const {
-    std::size_t size = size_ < other.size_ ? size_ : other.size_;
-    int result = std::char_traits<Char>::compare(data_, other.data_, size);
-    if (result == 0)
-      result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);
-    return result;
-  }
+    // Lexicographically compare this string reference to other.
+    int compare(BasicStringRef other) const
+    {
+        std::size_t size = size_ < other.size_ ? size_ : other.size_;
+        int result = std::char_traits<Char>::compare(data_, other.data_, size);
+        if (result == 0)
+            result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);
+        return result;
+    }
 
-  friend bool operator==(BasicStringRef lhs, BasicStringRef rhs) {
-    return lhs.compare(rhs) == 0;
-  }
-  friend bool operator!=(BasicStringRef lhs, BasicStringRef rhs) {
-    return lhs.compare(rhs) != 0;
-  }
-  friend bool operator<(BasicStringRef lhs, BasicStringRef rhs) {
-    return lhs.compare(rhs) < 0;
-  }
-  friend bool operator<=(BasicStringRef lhs, BasicStringRef rhs) {
-    return lhs.compare(rhs) <= 0;
-  }
-  friend bool operator>(BasicStringRef lhs, BasicStringRef rhs) {
-    return lhs.compare(rhs) > 0;
-  }
-  friend bool operator>=(BasicStringRef lhs, BasicStringRef rhs) {
-    return lhs.compare(rhs) >= 0;
-  }
+    friend bool operator==(BasicStringRef lhs, BasicStringRef rhs)
+    {
+        return lhs.compare(rhs) == 0;
+    }
+    friend bool operator!=(BasicStringRef lhs, BasicStringRef rhs)
+    {
+        return lhs.compare(rhs) != 0;
+    }
+    friend bool operator<(BasicStringRef lhs, BasicStringRef rhs)
+    {
+        return lhs.compare(rhs) < 0;
+    }
+    friend bool operator<=(BasicStringRef lhs, BasicStringRef rhs)
+    {
+        return lhs.compare(rhs) <= 0;
+    }
+    friend bool operator>(BasicStringRef lhs, BasicStringRef rhs)
+    {
+        return lhs.compare(rhs) > 0;
+    }
+    friend bool operator>=(BasicStringRef lhs, BasicStringRef rhs)
+    {
+        return lhs.compare(rhs) >= 0;
+    }
 };
 
 typedef BasicStringRef<char> StringRef;
@@ -578,45 +633,54 @@ typedef BasicStringRef<wchar_t> WStringRef;
   \endrst
  */
 template <typename Char>
-class BasicCStringRef {
- private:
-  const Char *data_;
+class BasicCStringRef
+{
+private:
+    const Char *data_;
 
- public:
-  /** Constructs a string reference object from a C string. */
-  BasicCStringRef(const Char *s) : data_(s) {}
+public:
+    /** Constructs a string reference object from a C string. */
+    BasicCStringRef(const Char *s) : data_(s) {}
 
-  /**
-    \rst
-    Constructs a string reference from a ``std::basic_string`` object.
-    \endrst
-   */
-  template <typename Allocator>
-  BasicCStringRef(
-      const std::basic_string<Char, std::char_traits<Char>, Allocator> &s)
-  : data_(s.c_str()) {}
+    /**
+      \rst
+      Constructs a string reference from a ``std::basic_string`` object.
+      \endrst
+     */
+    template <typename Allocator>
+    BasicCStringRef(
+        const std::basic_string<Char, std::char_traits<Char>, Allocator> &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 BasicCStringRef<char> CStringRef;
 typedef BasicCStringRef<wchar_t> WCStringRef;
 
 /** A formatting error such as invalid format string. */
-class FormatError : public std::runtime_error {
- public:
-  explicit FormatError(CStringRef message)
-  : std::runtime_error(message.c_str()) {}
-  FormatError(const FormatError &ferr) : std::runtime_error(ferr) {}
-  FMT_API ~FormatError() FMT_DTOR_NOEXCEPT;
+class FormatError : public std::runtime_error
+{
+public:
+    explicit FormatError(CStringRef message)
+        : std::runtime_error(message.c_str()) {}
+    FormatError(const FormatError &ferr) : std::runtime_error(ferr) {}
+    FMT_API ~FormatError() FMT_DTOR_NOEXCEPT;
 };
 
-namespace internal {
+namespace internal
+{
 
 // MakeUnsigned<T>::Type gives an unsigned type corresponding to integer type T.
 template <typename T>
-struct MakeUnsigned { typedef T Type; };
+struct MakeUnsigned
+{
+    typedef T Type;
+};
 
 #define FMT_SPECIALIZE_MAKE_UNSIGNED(T, U) \
   template <> \
@@ -631,9 +695,10 @@ FMT_SPECIALIZE_MAKE_UNSIGNED(LongLong, ULongLong);
 
 // Casts nonnegative integer to unsigned.
 template <typename Int>
-inline typename MakeUnsigned<Int>::Type to_unsigned(Int value) {
-  FMT_ASSERT(value >= 0, "negative value");
-  return static_cast<typename MakeUnsigned<Int>::Type>(value);
+inline typename MakeUnsigned<Int>::Type to_unsigned(Int value)
+{
+    FMT_ASSERT(value >= 0, "negative value");
+    return static_cast<typename MakeUnsigned<Int>::Type>(value);
 }
 
 // The number of characters to store in the MemoryBuffer object itself
@@ -643,12 +708,16 @@ enum { INLINE_BUFFER_SIZE = 500 };
 #if FMT_SECURE_SCL
 // Use checked iterator to avoid warnings on MSVC.
 template <typename T>
-inline stdext::checked_array_iterator<T*> make_ptr(T *ptr, std::size_t size) {
-  return stdext::checked_array_iterator<T*>(ptr, size);
+inline stdext::checked_array_iterator<T*> make_ptr(T *ptr, std::size_t size)
+{
+    return stdext::checked_array_iterator<T*>(ptr, size);
 }
 #else
 template <typename T>
-inline T *make_ptr(T *ptr, std::size_t) { return ptr; }
+inline T *make_ptr(T *ptr, std::size_t)
+{
+    return ptr;
+}
 #endif
 }  // namespace internal
 
@@ -658,261 +727,326 @@ inline T *make_ptr(T *ptr, std::size_t) { return ptr; }
   \endrst
  */
 template <typename T>
-class Buffer {
- private:
-  FMT_DISALLOW_COPY_AND_ASSIGN(Buffer);
+class Buffer
+{
+private:
+    FMT_DISALLOW_COPY_AND_ASSIGN(Buffer);
 
- protected:
-  T *ptr_;
-  std::size_t size_;
-  std::size_t capacity_;
+protected:
+    T *ptr_;
+    std::size_t size_;
+    std::size_t capacity_;
 
-  Buffer(T *ptr = FMT_NULL, std::size_t capacity = 0)
-    : ptr_(ptr), size_(0), capacity_(capacity) {}
+    Buffer(T *ptr = FMT_NULL, std::size_t capacity = 0)
+        : ptr_(ptr), size_(0), capacity_(capacity) {}
 
-  /**
-    \rst
-    Increases the buffer capacity to hold at least *size* elements updating
-    ``ptr_`` and ``capacity_``.
-    \endrst
-   */
-  virtual void grow(std::size_t size) = 0;
+    /**
+      \rst
+      Increases the buffer capacity to hold at least *size* elements updating
+      ``ptr_`` and ``capacity_``.
+      \endrst
+     */
+    virtual void grow(std::size_t size) = 0;
 
- public:
-  virtual ~Buffer() {}
+public:
+    virtual ~Buffer() {}
 
-  /** Returns the size of this buffer. */
-  std::size_t size() const { return size_; }
+    /** Returns the size of this buffer. */
+    std::size_t size() const
+    {
+        return size_;
+    }
 
-  /** Returns the capacity of this buffer. */
-  std::size_t capacity() const { return capacity_; }
+    /** Returns the capacity of this buffer. */
+    std::size_t capacity() const
+    {
+        return capacity_;
+    }
 
-  /**
-    Resizes the buffer. If T is a POD type new elements may not be initialized.
-   */
-  void resize(std::size_t new_size) {
-    if (new_size > capacity_)
-      grow(new_size);
-    size_ = new_size;
-  }
+    /**
+      Resizes the buffer. If T is a POD type new elements may not be initialized.
+     */
+    void resize(std::size_t new_size)
+    {
+        if (new_size > capacity_)
+            grow(new_size);
+        size_ = new_size;
+    }
 
-  /**
-    \rst
-    Reserves space to store at least *capacity* elements.
-    \endrst
-   */
-  void reserve(std::size_t capacity) {
-    if (capacity > capacity_)
-      grow(capacity);
-  }
+    /**
+      \rst
+      Reserves space to store at least *capacity* elements.
+      \endrst
+     */
+    void reserve(std::size_t capacity)
+    {
+        if (capacity > capacity_)
+            grow(capacity);
+    }
 
-  void clear() FMT_NOEXCEPT { size_ = 0; }
+    void clear() FMT_NOEXCEPT { size_ = 0; }
 
-  void push_back(const T &value) {
-    if (size_ == capacity_)
-      grow(size_ + 1);
-    ptr_[size_++] = value;
-  }
+    void push_back(const T &value)
+    {
+        if (size_ == capacity_)
+            grow(size_ + 1);
+        ptr_[size_++] = value;
+    }
 
-  /** Appends data to the end of the buffer. */
-  template <typename U>
-  void append(const U *begin, const U *end);
+    /** 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];
+    }
 };
 
 template <typename T>
 template <typename U>
-void Buffer<T>::append(const U *begin, const U *end) {
-  FMT_ASSERT(end >= begin, "negative value");
-  std::size_t new_size = size_ + (end - begin);
-  if (new_size > capacity_)
-    grow(new_size);
-  std::uninitialized_copy(begin, end,
-                          internal::make_ptr(ptr_, capacity_) + size_);
-  size_ = new_size;
+void Buffer<T>::append(const U *begin, const U *end)
+{
+    FMT_ASSERT(end >= begin, "negative value");
+    std::size_t new_size = size_ + (end - begin);
+    if (new_size > capacity_)
+        grow(new_size);
+    std::uninitialized_copy(begin, end,
+                            internal::make_ptr(ptr_, capacity_) + size_);
+    size_ = new_size;
 }
 
-namespace internal {
+namespace internal
+{
 
 // A memory buffer for trivially copyable/constructible types with the first
 // SIZE elements stored in the object itself.
 template <typename T, std::size_t SIZE, typename Allocator = std::allocator<T> >
-class MemoryBuffer : private Allocator, public Buffer<T> {
- private:
-  T data_[SIZE];
+class MemoryBuffer : private Allocator, public Buffer<T>
+{
+private:
+    T data_[SIZE];
 
-  // Deallocate memory allocated by the buffer.
-  void deallocate() {
-    if (this->ptr_ != data_) Allocator::deallocate(this->ptr_, this->capacity_);
-  }
+    // Deallocate memory allocated by the buffer.
+    void deallocate()
+    {
+        if (this->ptr_ != data_) Allocator::deallocate(this->ptr_, this->capacity_);
+    }
 
- protected:
-  void grow(std::size_t size) FMT_OVERRIDE;
+protected:
+    void grow(std::size_t size) FMT_OVERRIDE;
 
- public:
-  explicit MemoryBuffer(const Allocator &alloc = Allocator())
-      : Allocator(alloc), Buffer<T>(data_, SIZE) {}
-  ~MemoryBuffer() { deallocate(); }
+public:
+    explicit MemoryBuffer(const Allocator &alloc = Allocator())
+        : Allocator(alloc), Buffer<T>(data_, SIZE) {}
+    ~MemoryBuffer()
+    {
+        deallocate();
+    }
 
 #if FMT_USE_RVALUE_REFERENCES
- private:
-  // Move data from other to this buffer.
-  void move(MemoryBuffer &other) {
-    Allocator &this_alloc = *this, &other_alloc = other;
-    this_alloc = std::move(other_alloc);
-    this->size_ = other.size_;
-    this->capacity_ = other.capacity_;
-    if (other.ptr_ == other.data_) {
-      this->ptr_ = data_;
-      std::uninitialized_copy(other.data_, other.data_ + this->size_,
-                              make_ptr(data_, this->capacity_));
-    } else {
-      this->ptr_ = other.ptr_;
-      // Set pointer to the inline array so that delete is not called
-      // when deallocating.
-      other.ptr_ = other.data_;
+private:
+    // Move data from other to this buffer.
+    void move(MemoryBuffer &other)
+    {
+        Allocator &this_alloc = *this, &other_alloc = other;
+        this_alloc = std::move(other_alloc);
+        this->size_ = other.size_;
+        this->capacity_ = other.capacity_;
+        if (other.ptr_ == other.data_)
+        {
+            this->ptr_ = data_;
+            std::uninitialized_copy(other.data_, other.data_ + this->size_,
+                                    make_ptr(data_, this->capacity_));
+        }
+        else
+        {
+            this->ptr_ = other.ptr_;
+            // Set pointer to the inline array so that delete is not called
+            // when deallocating.
+            other.ptr_ = other.data_;
+        }
     }
-  }
 
- public:
-  MemoryBuffer(MemoryBuffer &&other) {
-    move(other);
-  }
+public:
+    MemoryBuffer(MemoryBuffer &&other)
+    {
+        move(other);
+    }
 
-  MemoryBuffer &operator=(MemoryBuffer &&other) {
-    assert(this != &other);
-    deallocate();
-    move(other);
-    return *this;
-  }
+    MemoryBuffer &operator=(MemoryBuffer &&other)
+    {
+        assert(this != &other);
+        deallocate();
+        move(other);
+        return *this;
+    }
 #endif
 
-  // Returns a copy of the allocator associated with this buffer.
-  Allocator get_allocator() const { return *this; }
+    // Returns a copy of the allocator associated with this buffer.
+    Allocator get_allocator() const
+    {
+        return *this;
+    }
 };
 
 template <typename T, std::size_t SIZE, typename Allocator>
-void MemoryBuffer<T, SIZE, Allocator>::grow(std::size_t size) {
-  std::size_t new_capacity = this->capacity_ + this->capacity_ / 2;
-  if (size > new_capacity)
-      new_capacity = size;
-  T *new_ptr = this->allocate(new_capacity, FMT_NULL);
-  // The following code doesn't throw, so the raw pointer above doesn't leak.
-  std::uninitialized_copy(this->ptr_, this->ptr_ + this->size_,
-                          make_ptr(new_ptr, new_capacity));
-  std::size_t old_capacity = this->capacity_;
-  T *old_ptr = this->ptr_;
-  this->capacity_ = new_capacity;
-  this->ptr_ = new_ptr;
-  // deallocate may throw (at least in principle), but it doesn't matter since
-  // the buffer already uses the new storage and will deallocate it in case
-  // of exception.
-  if (old_ptr != data_)
-    Allocator::deallocate(old_ptr, old_capacity);
+void MemoryBuffer<T, SIZE, Allocator>::grow(std::size_t size)
+{
+    std::size_t new_capacity = this->capacity_ + this->capacity_ / 2;
+    if (size > new_capacity)
+        new_capacity = size;
+    T *new_ptr = this->allocate(new_capacity, FMT_NULL);
+    // The following code doesn't throw, so the raw pointer above doesn't leak.
+    std::uninitialized_copy(this->ptr_, this->ptr_ + this->size_,
+                            make_ptr(new_ptr, new_capacity));
+    std::size_t old_capacity = this->capacity_;
+    T *old_ptr = this->ptr_;
+    this->capacity_ = new_capacity;
+    this->ptr_ = new_ptr;
+    // deallocate may throw (at least in principle), but it doesn't matter since
+    // the buffer already uses the new storage and will deallocate it in case
+    // of exception.
+    if (old_ptr != data_)
+        Allocator::deallocate(old_ptr, old_capacity);
 }
 
 // A fixed-size buffer.
 template <typename Char>
-class FixedBuffer : public fmt::Buffer<Char> {
- public:
-  FixedBuffer(Char *array, std::size_t size) : fmt::Buffer<Char>(array, size) {}
+class FixedBuffer : public fmt::Buffer<Char>
+{
+public:
+    FixedBuffer(Char *array, std::size_t size) : fmt::Buffer<Char>(array, size) {}
 
- protected:
-  FMT_API void grow(std::size_t size) FMT_OVERRIDE;
+protected:
+    FMT_API void grow(std::size_t size) FMT_OVERRIDE;
 };
 
 template <typename Char>
-class BasicCharTraits {
- public:
+class BasicCharTraits
+{
+public:
 #if FMT_SECURE_SCL
-  typedef stdext::checked_array_iterator<Char*> CharPtr;
+    typedef stdext::checked_array_iterator<Char*> CharPtr;
 #else
-  typedef Char *CharPtr;
+    typedef Char *CharPtr;
 #endif
-  static Char cast(int value) { return static_cast<Char>(value); }
+    static Char cast(int value)
+    {
+        return static_cast<Char>(value);
+    }
 };
 
 template <typename Char>
 class CharTraits;
 
 template <>
-class CharTraits<char> : public BasicCharTraits<char> {
- private:
-  // Conversion from wchar_t to char is not allowed.
-  static char convert(wchar_t);
+class CharTraits<char> : public BasicCharTraits<char>
+{
+private:
+    // Conversion from wchar_t to char is not allowed.
+    static char convert(wchar_t);
 
- public:
-  static char convert(char value) { return value; }
+public:
+    static char convert(char value)
+    {
+        return value;
+    }
 
-  // Formats a floating-point number.
-  template <typename T>
-  FMT_API static int format_float(char *buffer, std::size_t size,
-      const char *format, unsigned width, int precision, T value);
+    // Formats a floating-point number.
+    template <typename T>
+    FMT_API static int format_float(char *buffer, std::size_t size,
+                                    const char *format, unsigned width, int precision, T value);
 };
 
 #if FMT_USE_EXTERN_TEMPLATES
 extern template int CharTraits<char>::format_float<double>
-        (char *buffer, std::size_t size,
-         const char* format, unsigned width, int precision, double value);
+(char *buffer, std::size_t size,
+ const char* format, unsigned width, int precision, double value);
 extern template int CharTraits<char>::format_float<long double>
-        (char *buffer, std::size_t size,
-         const char* format, unsigned width, int precision, long double value);
+(char *buffer, std::size_t size,
+ const char* format, unsigned width, int precision, long double value);
 #endif
 
 template <>
-class CharTraits<wchar_t> : public BasicCharTraits<wchar_t> {
- public:
-  static wchar_t convert(char value) { return value; }
-  static wchar_t convert(wchar_t value) { return value; }
+class CharTraits<wchar_t> : public BasicCharTraits<wchar_t>
+{
+public:
+    static wchar_t convert(char value)
+    {
+        return value;
+    }
+    static wchar_t convert(wchar_t value)
+    {
+        return value;
+    }
 
-  template <typename T>
-  FMT_API static int format_float(wchar_t *buffer, std::size_t size,
-      const wchar_t *format, unsigned width, int precision, T value);
+    template <typename T>
+    FMT_API static int format_float(wchar_t *buffer, std::size_t size,
+                                    const wchar_t *format, unsigned width, int precision, T value);
 };
 
 #if FMT_USE_EXTERN_TEMPLATES
 extern template int CharTraits<wchar_t>::format_float<double>
-        (wchar_t *buffer, std::size_t size,
-         const wchar_t* format, unsigned width, int precision, double value);
+(wchar_t *buffer, std::size_t size,
+ const wchar_t* format, unsigned width, int precision, double value);
 extern template int CharTraits<wchar_t>::format_float<long double>
-        (wchar_t *buffer, std::size_t size,
-         const wchar_t* format, unsigned width, int precision, long double value);
+(wchar_t *buffer, std::size_t size,
+ const wchar_t* format, unsigned width, int precision, long double value);
 #endif
 
 // Checks if a number is negative - used to avoid warnings.
 template <bool IsSigned>
-struct SignChecker {
-  template <typename T>
-  static bool is_negative(T value) { return value < 0; }
+struct SignChecker
+{
+    template <typename T>
+    static bool is_negative(T value)
+    {
+        return value < 0;
+    }
 };
 
 template <>
-struct SignChecker<false> {
-  template <typename T>
-  static bool is_negative(T) { return false; }
+struct SignChecker<false>
+{
+    template <typename T>
+    static bool is_negative(T)
+    {
+        return false;
+    }
 };
 
 // Returns true if value is negative, false otherwise.
 // Same as (value < 0) but doesn't produce warnings if T is an unsigned type.
 template <typename T>
-inline bool is_negative(T value) {
-  return SignChecker<std::numeric_limits<T>::is_signed>::is_negative(value);
+inline bool is_negative(T value)
+{
+    return SignChecker<std::numeric_limits<T>::is_signed>::is_negative(value);
 }
 
 // Selects uint32_t if FitsIn32Bits is true, uint64_t otherwise.
 template <bool FitsIn32Bits>
-struct TypeSelector { typedef uint32_t Type; };
+struct TypeSelector
+{
+    typedef uint32_t Type;
+};
 
 template <>
-struct TypeSelector<false> { typedef uint64_t Type; };
+struct TypeSelector<false>
+{
+    typedef uint64_t Type;
+};
 
 template <typename T>
-struct IntTraits {
-  // Smallest of uint32_t and uint64_t that is large enough to represent
-  // all values of T.
-  typedef typename
+struct IntTraits
+{
+    // Smallest of uint32_t and uint64_t that is large enough to represent
+    // all values of T.
+    typedef typename
     TypeSelector<std::numeric_limits<T>::digits <= 32>::Type MainType;
 };
 
@@ -921,10 +1055,11 @@ FMT_API void report_unknown_type(char code, const char *type);
 // Static data is placed in this class template to allow header-only
 // configuration.
 template <typename T = void>
-struct FMT_API BasicData {
-  static const uint32_t POWERS_OF_10_32[];
-  static const uint64_t POWERS_OF_10_64[];
-  static const char DIGITS[];
+struct FMT_API BasicData
+{
+    static const uint32_t POWERS_OF_10_32[];
+    static const uint64_t POWERS_OF_10_64[];
+    static const char DIGITS[];
 };
 
 #if FMT_USE_EXTERN_TEMPLATES
@@ -936,63 +1071,70 @@ typedef BasicData<> Data;
 #ifdef FMT_BUILTIN_CLZLL
 // Returns the number of decimal digits in n. Leading zeros are not counted
 // except for n == 0 in which case count_digits returns 1.
-inline unsigned count_digits(uint64_t n) {
-  // Based on http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10
-  // and the benchmark https://github.com/localvoid/cxx-benchmark-count-digits.
-  int t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12;
-  return to_unsigned(t) - (n < Data::POWERS_OF_10_64[t]) + 1;
+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
 
 #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 NoThousandsSep {
-  template <typename Char>
-  void operator()(Char *) {}
+struct NoThousandsSep
+{
+    template <typename Char>
+    void operator()(Char *) {}
 };
 
 // A functor that adds a thousands separator.
-class ThousandsSep {
- private:
-  fmt::StringRef sep_;
+class ThousandsSep
+{
+private:
+    fmt::StringRef 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:
-  explicit ThousandsSep(fmt::StringRef sep) : sep_(sep), digit_index_(0) {}
+public:
+    explicit ThousandsSep(fmt::StringRef sep) : sep_(sep), digit_index_(0) {}
 
-  template <typename Char>
-  void operator()(Char *&buffer) {
-    if (++digit_index_ % 3 != 0)
-      return;
-    buffer -= sep_.size();
-    std::uninitialized_copy(sep_.data(), sep_.data() + sep_.size(),
-                            internal::make_ptr(buffer, sep_.size()));
-  }
+    template <typename Char>
+    void operator()(Char *&buffer)
+    {
+        if (++digit_index_ % 3 != 0)
+            return;
+        buffer -= sep_.size();
+        std::uninitialized_copy(sep_.data(), sep_.data() + sep_.size(),
+                                internal::make_ptr(buffer, sep_.size()));
+    }
 };
 
 // Formats a decimal unsigned integer value writing into buffer.
@@ -1000,33 +1142,37 @@ class ThousandsSep {
 // add a thousands separator if necessary.
 template <typename UInt, typename Char, typename ThousandsSep>
 inline void format_decimal(Char *buffer, UInt value, unsigned num_digits,
-                           ThousandsSep thousands_sep) {
-  buffer += num_digits;
-  while (value >= 100) {
-    // Integer division is slow so do it for a group of two digits instead
-    // of for every digit. The idea comes from the talk by Alexandrescu
-    // "Three Optimization Tips for C++". See speed-test for a comparison.
-    unsigned index = static_cast<unsigned>((value % 100) * 2);
-    value /= 100;
+                           ThousandsSep thousands_sep)
+{
+    buffer += num_digits;
+    while (value >= 100)
+    {
+        // Integer division is slow so do it for a group of two digits instead
+        // of for every digit. The idea comes from the talk by Alexandrescu
+        // "Three Optimization Tips for C++". See speed-test for a comparison.
+        unsigned index = static_cast<unsigned>((value % 100) * 2);
+        value /= 100;
+        *--buffer = Data::DIGITS[index + 1];
+        thousands_sep(buffer);
+        *--buffer = Data::DIGITS[index];
+        thousands_sep(buffer);
+    }
+    if (value < 10)
+    {
+        *--buffer = static_cast<char>('0' + value);
+        return;
+    }
+    unsigned index = static_cast<unsigned>(value * 2);
     *--buffer = Data::DIGITS[index + 1];
     thousands_sep(buffer);
     *--buffer = Data::DIGITS[index];
-    thousands_sep(buffer);
-  }
-  if (value < 10) {
-    *--buffer = static_cast<char>('0' + value);
-    return;
-  }
-  unsigned index = static_cast<unsigned>(value * 2);
-  *--buffer = Data::DIGITS[index + 1];
-  thousands_sep(buffer);
-  *--buffer = Data::DIGITS[index];
 }
 
 template <typename UInt, typename Char>
-inline void format_decimal(Char *buffer, UInt value, unsigned num_digits) {
-  format_decimal(buffer, value, num_digits, NoThousandsSep());
-  return;
+inline void format_decimal(Char *buffer, UInt value, unsigned num_digits)
+{
+    format_decimal(buffer, value, num_digits, NoThousandsSep());
+    return;
 }
 
 #ifndef _WIN32
@@ -1040,36 +1186,62 @@ inline void format_decimal(Char *buffer, 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 UTF8ToUTF16 {
- private:
-  MemoryBuffer<wchar_t, INLINE_BUFFER_SIZE> buffer_;
+class UTF8ToUTF16
+{
+private:
+    MemoryBuffer<wchar_t, INLINE_BUFFER_SIZE> buffer_;
 
- public:
-  FMT_API explicit UTF8ToUTF16(StringRef s);
-  operator WStringRef() const { return WStringRef(&buffer_[0], size()); }
-  size_t size() const { return buffer_.size() - 1; }
-  const wchar_t *c_str() const { return &buffer_[0]; }
-  std::wstring str() const { return std::wstring(&buffer_[0], size()); }
+public:
+    FMT_API explicit UTF8ToUTF16(StringRef s);
+    operator WStringRef() const
+    {
+        return WStringRef(&buffer_[0], size());
+    }
+    size_t size() const
+    {
+        return buffer_.size() - 1;
+    }
+    const wchar_t *c_str() const
+    {
+        return &buffer_[0];
+    }
+    std::wstring str() const
+    {
+        return std::wstring(&buffer_[0], size());
+    }
 };
 
 // A converter from UTF-16 to UTF-8.
 // It is only provided for Windows since other systems support UTF-8 natively.
-class UTF16ToUTF8 {
- private:
-  MemoryBuffer<char, INLINE_BUFFER_SIZE> buffer_;
+class UTF16ToUTF8
+{
+private:
+    MemoryBuffer<char, INLINE_BUFFER_SIZE> buffer_;
 
- public:
-  UTF16ToUTF8() {}
-  FMT_API explicit UTF16ToUTF8(WStringRef s);
-  operator StringRef() const { return StringRef(&buffer_[0], size()); }
-  size_t size() const { return buffer_.size() - 1; }
-  const char *c_str() const { return &buffer_[0]; }
-  std::string str() const { return std::string(&buffer_[0], size()); }
+public:
+    UTF16ToUTF8() {}
+    FMT_API explicit UTF16ToUTF8(WStringRef s);
+    operator StringRef() const
+    {
+        return StringRef(&buffer_[0], size());
+    }
+    size_t size() const
+    {
+        return buffer_.size() - 1;
+    }
+    const char *c_str() const
+    {
+        return &buffer_[0];
+    }
+    std::string str() const
+    {
+        return std::string(&buffer_[0], size());
+    }
 
-  // Performs conversion returning a system error code instead of
-  // throwing exception on conversion error. This method may still throw
-  // in case of memory allocation error.
-  FMT_API int convert(WStringRef s);
+    // Performs conversion returning a system error code instead of
+    // throwing exception on conversion error. This method may still throw
+    // in case of memory allocation error.
+    FMT_API int convert(WStringRef s);
 };
 
 FMT_API void format_windows_error(fmt::Writer &out, int error_code,
@@ -1077,50 +1249,56 @@ FMT_API void format_windows_error(fmt::Writer &out, int error_code,
 #endif
 
 // A formatting argument value.
-struct Value {
-  template <typename Char>
-  struct StringValue {
-    const Char *value;
-    std::size_t size;
-  };
+struct Value
+{
+    template <typename Char>
+    struct StringValue
+    {
+        const Char *value;
+        std::size_t size;
+    };
 
-  typedef void (*FormatFunc)(
-      void *formatter, const void *arg, void *format_str_ptr);
+    typedef void (*FormatFunc)(
+        void *formatter, const void *arg, void *format_str_ptr);
 
-  struct CustomValue {
-    const void *value;
-    FormatFunc format;
-  };
+    struct CustomValue
+    {
+        const void *value;
+        FormatFunc format;
+    };
 
-  union {
-    int int_value;
-    unsigned uint_value;
-    LongLong long_long_value;
-    ULongLong ulong_long_value;
-    double double_value;
-    long double long_double_value;
-    const void *pointer;
-    StringValue<char> string;
-    StringValue<signed char> sstring;
-    StringValue<unsigned char> ustring;
-    StringValue<wchar_t> wstring;
-    CustomValue custom;
-  };
+    union
+    {
+        int int_value;
+        unsigned uint_value;
+        LongLong long_long_value;
+        ULongLong ulong_long_value;
+        double double_value;
+        long double long_double_value;
+        const void *pointer;
+        StringValue<char> string;
+        StringValue<signed char> sstring;
+        StringValue<unsigned char> ustring;
+        StringValue<wchar_t> wstring;
+        CustomValue custom;
+    };
 
-  enum Type {
-    NONE, NAMED_ARG,
-    // Integer types should go first,
-    INT, UINT, LONG_LONG, ULONG_LONG, BOOL, CHAR, LAST_INTEGER_TYPE = CHAR,
-    // followed by floating-point types.
-    DOUBLE, LONG_DOUBLE, LAST_NUMERIC_TYPE = LONG_DOUBLE,
-    CSTRING, STRING, WSTRING, POINTER, CUSTOM
-  };
+    enum Type
+    {
+        NONE, NAMED_ARG,
+        // Integer types should go first,
+        INT, UINT, LONG_LONG, ULONG_LONG, BOOL, CHAR, LAST_INTEGER_TYPE = CHAR,
+        // followed by floating-point types.
+        DOUBLE, LONG_DOUBLE, LAST_NUMERIC_TYPE = LONG_DOUBLE,
+        CSTRING, STRING, WSTRING, POINTER, CUSTOM
+    };
 };
 
 // A formatting argument. It is a trivially copyable/constructible type to
 // allow storage in internal::MemoryBuffer.
-struct Arg : Value {
-  Type type;
+struct Arg : Value
+{
+    Type type;
 };
 
 template <typename Char>
@@ -1134,15 +1312,17 @@ struct Null {};
 // A helper class template to enable or disable overloads taking wide
 // characters and strings in MakeValue.
 template <typename T, typename Char>
-struct WCharHelper {
-  typedef Null<T> Supported;
-  typedef T Unsupported;
+struct WCharHelper
+{
+    typedef Null<T> Supported;
+    typedef T Unsupported;
 };
 
 template <typename T>
-struct WCharHelper<T, wchar_t> {
-  typedef T Supported;
-  typedef Null<T> Unsupported;
+struct WCharHelper<T, wchar_t>
+{
+    typedef T Supported;
+    typedef Null<T> Unsupported;
 };
 
 typedef char Yes[1];
@@ -1156,29 +1336,35 @@ Yes &convert(fmt::ULongLong);
 No &convert(...);
 
 template<typename T, bool ENABLE_CONVERSION>
-struct ConvertToIntImpl {
-  enum { value = ENABLE_CONVERSION };
+struct ConvertToIntImpl
+{
+    enum { value = ENABLE_CONVERSION };
 };
 
 template<typename T, bool ENABLE_CONVERSION>
-struct ConvertToIntImpl2 {
-  enum { value = false };
+struct ConvertToIntImpl2
+{
+    enum { value = false };
 };
 
 template<typename T>
-struct ConvertToIntImpl2<T, true> {
-  enum {
-    // Don't convert numeric types.
-    value = ConvertToIntImpl<T, !std::numeric_limits<T>::is_specialized>::value
-  };
+struct ConvertToIntImpl2<T, true>
+{
+    enum
+    {
+        // Don't convert numeric types.
+        value = ConvertToIntImpl<T, !std::numeric_limits<T>::is_specialized>::value
+    };
 };
 
 template<typename T>
-struct ConvertToInt {
-  enum {
-    enable_conversion = sizeof(fmt::internal::convert(get<T>())) == sizeof(Yes)
-  };
-  enum { value = ConvertToIntImpl2<T, enable_conversion>::value };
+struct ConvertToInt
+{
+    enum
+    {
+        enable_conversion = sizeof(fmt::internal::convert(get<T>())) == sizeof(Yes)
+    };
+    enum { value = ConvertToIntImpl2<T, enable_conversion>::value };
 };
 
 #define FMT_DISABLE_CONVERSION_TO_INT(Type) \
@@ -1194,26 +1380,45 @@ template<bool B, class T = void>
 struct EnableIf {};
 
 template<class T>
-struct EnableIf<true, T> { typedef T type; };
+struct EnableIf<true, T>
+{
+    typedef T type;
+};
 
 template<bool B, class T, class F>
-struct Conditional { typedef T type; };
+struct Conditional
+{
+    typedef T type;
+};
 
 template<class T, class F>
-struct Conditional<false, T, F> { typedef F type; };
+struct Conditional<false, T, F>
+{
+    typedef F type;
+};
 
 // For bcc32 which doesn't understand ! in template arguments.
 template <bool>
-struct Not { enum { value = 0 }; };
+struct Not
+{
+    enum { value = 0 };
+};
 
 template <>
-struct Not<false> { enum { value = 1 }; };
+struct Not<false>
+{
+    enum { value = 1 };
+};
 
 template <typename T>
-struct FalseType { enum { value = 0 }; };
+struct FalseType
+{
+    enum { value = 0 };
+};
 
-template <typename T, T> struct LConvCheck {
-  LConvCheck(int) {}
+template <typename T, T> struct LConvCheck
+{
+    LConvCheck(int) {}
 };
 
 // Returns the thousands separator for the current locale.
@@ -1221,11 +1426,15 @@ template <typename T, T> struct LConvCheck {
 // ``lconv`` is stubbed as an empty struct.
 template <typename LConv>
 inline StringRef thousands_sep(
-    LConv *lc, LConvCheck<char *LConv::*, &LConv::thousands_sep> = 0) {
-  return lc->thousands_sep;
+    LConv *lc, LConvCheck<char *LConv::*, &LConv::thousands_sep> = 0)
+{
+    return lc->thousands_sep;
 }
 
-inline fmt::StringRef thousands_sep(...) { return ""; }
+inline fmt::StringRef thousands_sep(...)
+{
+    return "";
+}
 
 #define FMT_CONCAT(a, b) a##b
 
@@ -1249,63 +1458,68 @@ inline fmt::StringRef thousands_sep(...) { return ""; }
 #endif
 
 template <typename Formatter, typename Char, typename T>
-void format_arg(Formatter &, const Char *, const T &) {
-  FMT_STATIC_ASSERT(FalseType<T>::value,
-                    "Cannot format argument. To enable the use of ostream "
-                    "operator<< include fmt/ostream.h. Otherwise provide "
-                    "an overload of format_arg.");
+void format_arg(Formatter &, const Char *, const T &)
+{
+    FMT_STATIC_ASSERT(FalseType<T>::value,
+                      "Cannot format argument. To enable the use of ostream "
+                      "operator<< include fmt/ostream.h. Otherwise provide "
+                      "an overload of format_arg.");
 }
 
 // Makes an Arg object from any type.
 template <typename Formatter>
-class MakeValue : public Arg {
- public:
-  typedef typename Formatter::Char Char;
+class MakeValue : public Arg
+{
+public:
+    typedef typename Formatter::Char Char;
 
- private:
-  // The following two methods are private to disallow formatting of
-  // arbitrary pointers. If you want to output a pointer cast it to
-  // "void *" or "const void *". In particular, this forbids formatting
-  // of "[const] volatile char *" which is printed as bool by iostreams.
-  // Do not implement!
-  template <typename T>
-  MakeValue(const T *value);
-  template <typename T>
-  MakeValue(T *value);
+private:
+    // The following two methods are private to disallow formatting of
+    // arbitrary pointers. If you want to output a pointer cast it to
+    // "void *" or "const void *". In particular, this forbids formatting
+    // of "[const] volatile char *" which is printed as bool by iostreams.
+    // Do not implement!
+    template <typename T>
+    MakeValue(const T *value);
+    template <typename T>
+    MakeValue(T *value);
 
-  // The following methods are private to disallow formatting of wide
-  // characters and strings into narrow strings as in
-  //   fmt::format("{}", L"test");
-  // To fix this, use a wide format string: fmt::format(L"{}", L"test").
+    // The following methods are private to disallow formatting of wide
+    // characters and strings into narrow strings as in
+    //   fmt::format("{}", L"test");
+    // To fix this, use a wide format string: fmt::format(L"{}", L"test").
 #if !FMT_MSC_VER || defined(_NATIVE_WCHAR_T_DEFINED)
-  MakeValue(typename WCharHelper<wchar_t, Char>::Unsupported);
+    MakeValue(typename WCharHelper<wchar_t, Char>::Unsupported);
 #endif
-  MakeValue(typename WCharHelper<wchar_t *, Char>::Unsupported);
-  MakeValue(typename WCharHelper<const wchar_t *, Char>::Unsupported);
-  MakeValue(typename WCharHelper<const std::wstring &, Char>::Unsupported);
-  MakeValue(typename WCharHelper<WStringRef, Char>::Unsupported);
+    MakeValue(typename WCharHelper<wchar_t *, Char>::Unsupported);
+    MakeValue(typename WCharHelper<const wchar_t *, Char>::Unsupported);
+    MakeValue(typename WCharHelper<const std::wstring &, Char>::Unsupported);
+    MakeValue(typename WCharHelper<WStringRef, Char>::Unsupported);
 
-  void set_string(StringRef str) {
-    string.value = str.data();
-    string.size = str.size();
-  }
+    void set_string(StringRef str)
+    {
+        string.value = str.data();
+        string.size = str.size();
+    }
 
-  void set_string(WStringRef str) {
-    wstring.value = str.data();
-    wstring.size = str.size();
-  }
+    void set_string(WStringRef str)
+    {
+        wstring.value = str.data();
+        wstring.size = str.size();
+    }
 
-  // Formats an argument of a custom type, such as a user-defined class.
-  template <typename T>
-  static void format_custom_arg(
-      void *formatter, const void *arg, void *format_str_ptr) {
-    format_arg(*static_cast<Formatter*>(formatter),
-               *static_cast<const Char**>(format_str_ptr),
-               *static_cast<const T*>(arg));
-  }
+    // Formats an argument of a custom type, such as a user-defined class.
+    template <typename T>
+    static void format_custom_arg(
+        void *formatter, const void *arg, void *format_str_ptr)
+    {
+        format_arg(*static_cast<Formatter*>(formatter),
+                   *static_cast<const Char**>(format_str_ptr),
+                   *static_cast<const T*>(arg));
+    }
 
- public:
-  MakeValue() {}
+public:
+    MakeValue() {}
 
 #define FMT_MAKE_VALUE_(Type, field, TYPE, rhs) \
   MakeValue(Type value) { field = rhs; } \
@@ -1314,64 +1528,72 @@ class MakeValue : public Arg {
 #define FMT_MAKE_VALUE(Type, field, TYPE) \
   FMT_MAKE_VALUE_(Type, field, TYPE, value)
 
-  FMT_MAKE_VALUE(bool, int_value, BOOL)
-  FMT_MAKE_VALUE(short, int_value, INT)
-  FMT_MAKE_VALUE(unsigned short, uint_value, UINT)
-  FMT_MAKE_VALUE(int, int_value, INT)
-  FMT_MAKE_VALUE(unsigned, uint_value, UINT)
+    FMT_MAKE_VALUE(bool, int_value, BOOL)
+    FMT_MAKE_VALUE(short, int_value, INT)
+    FMT_MAKE_VALUE(unsigned short, uint_value, UINT)
+    FMT_MAKE_VALUE(int, int_value, INT)
+    FMT_MAKE_VALUE(unsigned, uint_value, UINT)
 
-  MakeValue(long value) {
-    // To minimize the number of types we need to deal with, long is
-    // translated either to int or to long long depending on its size.
-    if (const_check(sizeof(long) == sizeof(int)))
-      int_value = static_cast<int>(value);
-    else
-      long_long_value = value;
-  }
-  static uint64_t type(long) {
-    return sizeof(long) == sizeof(int) ? Arg::INT : Arg::LONG_LONG;
-  }
+    MakeValue(long value)
+    {
+        // To minimize the number of types we need to deal with, long is
+        // translated either to int or to long long depending on its size.
+        if (const_check(sizeof(long) == sizeof(int)))
+            int_value = static_cast<int>(value);
+        else
+            long_long_value = value;
+    }
+    static uint64_t type(long)
+    {
+        return sizeof(long) == sizeof(int) ? Arg::INT : Arg::LONG_LONG;
+    }
 
-  MakeValue(unsigned long value) {
-    if (const_check(sizeof(unsigned long) == sizeof(unsigned)))
-      uint_value = static_cast<unsigned>(value);
-    else
-      ulong_long_value = value;
-  }
-  static uint64_t type(unsigned long) {
-    return sizeof(unsigned long) == sizeof(unsigned) ?
-          Arg::UINT : Arg::ULONG_LONG;
-  }
+    MakeValue(unsigned long value)
+    {
+        if (const_check(sizeof(unsigned long) == sizeof(unsigned)))
+            uint_value = static_cast<unsigned>(value);
+        else
+            ulong_long_value = value;
+    }
+    static uint64_t type(unsigned long)
+    {
+        return sizeof(unsigned long) == sizeof(unsigned) ?
+               Arg::UINT : Arg::ULONG_LONG;
+    }
 
-  FMT_MAKE_VALUE(LongLong, long_long_value, LONG_LONG)
-  FMT_MAKE_VALUE(ULongLong, ulong_long_value, ULONG_LONG)
-  FMT_MAKE_VALUE(float, double_value, DOUBLE)
-  FMT_MAKE_VALUE(double, double_value, DOUBLE)
-  FMT_MAKE_VALUE(long double, long_double_value, LONG_DOUBLE)
-  FMT_MAKE_VALUE(signed char, int_value, INT)
-  FMT_MAKE_VALUE(unsigned char, uint_value, UINT)
-  FMT_MAKE_VALUE(char, int_value, CHAR)
+    FMT_MAKE_VALUE(LongLong, long_long_value, LONG_LONG)
+    FMT_MAKE_VALUE(ULongLong, ulong_long_value, ULONG_LONG)
+    FMT_MAKE_VALUE(float, double_value, DOUBLE)
+    FMT_MAKE_VALUE(double, double_value, DOUBLE)
+    FMT_MAKE_VALUE(long double, long_double_value, LONG_DOUBLE)
+    FMT_MAKE_VALUE(signed char, int_value, INT)
+    FMT_MAKE_VALUE(unsigned char, uint_value, UINT)
+    FMT_MAKE_VALUE(char, int_value, CHAR)
 
 #if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
-  MakeValue(typename WCharHelper<wchar_t, Char>::Supported value) {
-    int_value = value;
-  }
-  static uint64_t type(wchar_t) { return Arg::CHAR; }
+    MakeValue(typename WCharHelper<wchar_t, Char>::Supported value)
+    {
+        int_value = value;
+    }
+    static uint64_t type(wchar_t)
+    {
+        return Arg::CHAR;
+    }
 #endif
 
 #define FMT_MAKE_STR_VALUE(Type, TYPE) \
   MakeValue(Type value) { set_string(value); } \
   static uint64_t type(Type) { return Arg::TYPE; }
 
-  FMT_MAKE_VALUE(char *, string.value, CSTRING)
-  FMT_MAKE_VALUE(const char *, string.value, CSTRING)
-  FMT_MAKE_VALUE(signed char *, sstring.value, CSTRING)
-  FMT_MAKE_VALUE(const signed char *, sstring.value, CSTRING)
-  FMT_MAKE_VALUE(unsigned char *, ustring.value, CSTRING)
-  FMT_MAKE_VALUE(const unsigned char *, ustring.value, CSTRING)
-  FMT_MAKE_STR_VALUE(const std::string &, STRING)
-  FMT_MAKE_STR_VALUE(StringRef, STRING)
-  FMT_MAKE_VALUE_(CStringRef, string.value, CSTRING, value.c_str())
+    FMT_MAKE_VALUE(char *, string.value, CSTRING)
+    FMT_MAKE_VALUE(const char *, string.value, CSTRING)
+    FMT_MAKE_VALUE(signed char *, sstring.value, CSTRING)
+    FMT_MAKE_VALUE(const signed char *, sstring.value, CSTRING)
+    FMT_MAKE_VALUE(unsigned char *, ustring.value, CSTRING)
+    FMT_MAKE_VALUE(const unsigned char *, ustring.value, CSTRING)
+    FMT_MAKE_STR_VALUE(const std::string &, STRING)
+    FMT_MAKE_STR_VALUE(StringRef, STRING)
+    FMT_MAKE_VALUE_(CStringRef, string.value, CSTRING, value.c_str())
 
 #define FMT_MAKE_WSTR_VALUE(Type, TYPE) \
   MakeValue(typename WCharHelper<Type, Char>::Supported value) { \
@@ -1379,75 +1601,95 @@ class MakeValue : public Arg {
   } \
   static uint64_t type(Type) { return Arg::TYPE; }
 
-  FMT_MAKE_WSTR_VALUE(wchar_t *, WSTRING)
-  FMT_MAKE_WSTR_VALUE(const wchar_t *, WSTRING)
-  FMT_MAKE_WSTR_VALUE(const std::wstring &, WSTRING)
-  FMT_MAKE_WSTR_VALUE(WStringRef, WSTRING)
+    FMT_MAKE_WSTR_VALUE(wchar_t *, WSTRING)
+    FMT_MAKE_WSTR_VALUE(const wchar_t *, WSTRING)
+    FMT_MAKE_WSTR_VALUE(const std::wstring &, WSTRING)
+    FMT_MAKE_WSTR_VALUE(WStringRef, WSTRING)
 
-  FMT_MAKE_VALUE(void *, pointer, POINTER)
-  FMT_MAKE_VALUE(const void *, pointer, POINTER)
+    FMT_MAKE_VALUE(void *, pointer, POINTER)
+    FMT_MAKE_VALUE(const void *, pointer, POINTER)
 
-  template <typename T>
-  MakeValue(const T &value,
-            typename EnableIf<Not<
-              ConvertToInt<T>::value>::value, int>::type = 0) {
-    custom.value = &value;
-    custom.format = &format_custom_arg<T>;
-  }
+    template <typename T>
+    MakeValue(const T &value,
+              typename EnableIf<Not<
+              ConvertToInt<T>::value>::value, int>::type = 0)
+    {
+        custom.value = &value;
+        custom.format = &format_custom_arg<T>;
+    }
 
-  template <typename T>
-  static typename EnableIf<Not<ConvertToInt<T>::value>::value, uint64_t>::type
-      type(const T &) {
-    return Arg::CUSTOM;
-  }
+    template <typename T>
+    static typename EnableIf<Not<ConvertToInt<T>::value>::value, uint64_t>::type
+    type(const T &)
+    {
+        return Arg::CUSTOM;
+    }
 
-  // Additional template param `Char_` is needed here because make_type always
-  // uses char.
-  template <typename Char_>
-  MakeValue(const NamedArg<Char_> &value) { pointer = &value; }
-  template <typename Char_, typename T>
-  MakeValue(const NamedArgWithType<Char_, T> &value) { pointer = &value; }
+    // Additional template param `Char_` is needed here because make_type always
+    // uses char.
+    template <typename Char_>
+    MakeValue(const NamedArg<Char_> &value)
+    {
+        pointer = &value;
+    }
+    template <typename Char_, typename T>
+    MakeValue(const NamedArgWithType<Char_, T> &value)
+    {
+        pointer = &value;
+    }
 
-  template <typename Char_>
-  static uint64_t type(const NamedArg<Char_> &) { return Arg::NAMED_ARG; }
-  template <typename Char_, typename T>
-  static uint64_t type(const NamedArgWithType<Char_, T> &) { return Arg::NAMED_ARG; }
+    template <typename Char_>
+    static uint64_t type(const NamedArg<Char_> &)
+    {
+        return Arg::NAMED_ARG;
+    }
+    template <typename Char_, typename T>
+    static uint64_t type(const NamedArgWithType<Char_, T> &)
+    {
+        return Arg::NAMED_ARG;
+    }
 };
 
 template <typename Formatter>
-class MakeArg : public Arg {
+class MakeArg : public Arg
+{
 public:
-  MakeArg() {
-    type = Arg::NONE;
-  }
+    MakeArg()
+    {
+        type = Arg::NONE;
+    }
 
-  template <typename T>
-  MakeArg(const T &value)
-  : Arg(MakeValue<Formatter>(value)) {
-    type = static_cast<Arg::Type>(MakeValue<Formatter>::type(value));
-  }
+    template <typename T>
+    MakeArg(const T &value)
+        : Arg(MakeValue<Formatter>(value))
+    {
+        type = static_cast<Arg::Type>(MakeValue<Formatter>::type(value));
+    }
 };
 
 template <typename Char>
-struct NamedArg : Arg {
-  BasicStringRef<Char> name;
+struct NamedArg : Arg
+{
+    BasicStringRef<Char> name;
 
-  template <typename T>
-  NamedArg(BasicStringRef<Char> argname, const T &value)
-  : Arg(MakeArg< BasicFormatter<Char> >(value)), name(argname) {}
+    template <typename T>
+    NamedArg(BasicStringRef<Char> argname, const T &value)
+        : Arg(MakeArg< BasicFormatter<Char> >(value)), name(argname) {}
 };
 
 template <typename Char, typename T>
-struct NamedArgWithType : NamedArg<Char> {
-  NamedArgWithType(BasicStringRef<Char> argname, const T &value)
-  : NamedArg<Char>(argname, value) {}
+struct NamedArgWithType : NamedArg<Char>
+{
+    NamedArgWithType(BasicStringRef<Char> argname, const T &value)
+        : NamedArg<Char>(argname, value) {}
 };
 
-class RuntimeError : public std::runtime_error {
- protected:
-  RuntimeError() : std::runtime_error("") {}
-  RuntimeError(const RuntimeError &rerr) : std::runtime_error(rerr) {}
-  FMT_API ~RuntimeError() FMT_DTOR_NOEXCEPT;
+class RuntimeError : public std::runtime_error
+{
+protected:
+    RuntimeError() : std::runtime_error("") {}
+    RuntimeError(const RuntimeError &rerr) : std::runtime_error(rerr) {}
+    FMT_API ~RuntimeError() FMT_DTOR_NOEXCEPT;
 };
 
 template <typename Char>
@@ -1455,73 +1697,84 @@ class ArgMap;
 }  // namespace internal
 
 /** An argument list. */
-class ArgList {
- private:
-  // To reduce compiled code size per formatting function call, types of first
-  // MAX_PACKED_ARGS arguments are passed in the types_ field.
-  uint64_t types_;
-  union {
-    // If the number of arguments is less than MAX_PACKED_ARGS, the argument
-    // values are stored in values_, otherwise they are stored in args_.
-    // This is done to reduce compiled code size as storing larger objects
-    // may require more code (at least on x86-64) even if the same amount of
-    // data is actually copied to stack. It saves ~10% on the bloat test.
-    const internal::Value *values_;
-    const internal::Arg *args_;
-  };
+class ArgList
+{
+private:
+    // To reduce compiled code size per formatting function call, types of first
+    // MAX_PACKED_ARGS arguments are passed in the types_ field.
+    uint64_t types_;
+    union
+    {
+        // If the number of arguments is less than MAX_PACKED_ARGS, the argument
+        // values are stored in values_, otherwise they are stored in args_.
+        // This is done to reduce compiled code size as storing larger objects
+        // may require more code (at least on x86-64) even if the same amount of
+        // data is actually copied to stack. It saves ~10% on the bloat test.
+        const internal::Value *values_;
+        const internal::Arg *args_;
+    };
 
-  internal::Arg::Type type(unsigned index) const {
-    return type(types_, index);
-  }
-
-  template <typename Char>
-  friend class internal::ArgMap;
-
- public:
-  // Maximum number of arguments with packed types.
-  enum { MAX_PACKED_ARGS = 16 };
-
-  ArgList() : types_(0) {}
-
-  ArgList(ULongLong types, const internal::Value *values)
-  : types_(types), values_(values) {}
-  ArgList(ULongLong types, const internal::Arg *args)
-  : types_(types), args_(args) {}
-
-  uint64_t types() const { return types_; }
-
-  /** Returns the argument at specified index. */
-  internal::Arg operator[](unsigned index) const {
-    using internal::Arg;
-    Arg arg;
-    bool use_values = type(MAX_PACKED_ARGS - 1) == Arg::NONE;
-    if (index < MAX_PACKED_ARGS) {
-      Arg::Type arg_type = type(index);
-      internal::Value &val = arg;
-      if (arg_type != Arg::NONE)
-        val = use_values ? values_[index] : args_[index];
-      arg.type = arg_type;
-      return arg;
+    internal::Arg::Type type(unsigned index) const
+    {
+        return type(types_, index);
     }
-    if (use_values) {
-      // The index is greater than the number of arguments that can be stored
-      // in values, so return a "none" argument.
-      arg.type = Arg::NONE;
-      return arg;
-    }
-    for (unsigned i = MAX_PACKED_ARGS; i <= index; ++i) {
-      if (args_[i].type == Arg::NONE)
-        return args_[i];
-    }
-    return args_[index];
-  }
 
-  static internal::Arg::Type type(uint64_t types, unsigned index) {
-    unsigned shift = index * 4;
-    uint64_t mask = 0xf;
-    return static_cast<internal::Arg::Type>(
-          (types & (mask << shift)) >> shift);
-  }
+    template <typename Char>
+    friend class internal::ArgMap;
+
+public:
+    // Maximum number of arguments with packed types.
+    enum { MAX_PACKED_ARGS = 16 };
+
+    ArgList() : types_(0) {}
+
+    ArgList(ULongLong types, const internal::Value *values)
+        : types_(types), values_(values) {}
+    ArgList(ULongLong types, const internal::Arg *args)
+        : types_(types), args_(args) {}
+
+    uint64_t types() const
+    {
+        return types_;
+    }
+
+    /** Returns the argument at specified index. */
+    internal::Arg operator[](unsigned index) const
+    {
+        using internal::Arg;
+        Arg arg;
+        bool use_values = type(MAX_PACKED_ARGS - 1) == Arg::NONE;
+        if (index < MAX_PACKED_ARGS)
+        {
+            Arg::Type arg_type = type(index);
+            internal::Value &val = arg;
+            if (arg_type != Arg::NONE)
+                val = use_values ? values_[index] : args_[index];
+            arg.type = arg_type;
+            return arg;
+        }
+        if (use_values)
+        {
+            // The index is greater than the number of arguments that can be stored
+            // in values, so return a "none" argument.
+            arg.type = Arg::NONE;
+            return arg;
+        }
+        for (unsigned i = MAX_PACKED_ARGS; i <= index; ++i)
+        {
+            if (args_[i].type == Arg::NONE)
+                return args_[i];
+        }
+        return args_[index];
+    }
+
+    static internal::Arg::Type type(uint64_t types, unsigned index)
+    {
+        unsigned shift = index * 4;
+        uint64_t mask = 0xf;
+        return static_cast<internal::Arg::Type>(
+                   (types & (mask << shift)) >> shift);
+    }
 };
 
 #define FMT_DISPATCH(call) static_cast<Impl*>(this)->call
@@ -1551,148 +1804,169 @@ class ArgList {
   \endrst
  */
 template <typename Impl, typename Result>
-class ArgVisitor {
- private:
-  typedef internal::Arg Arg;
+class ArgVisitor
+{
+private:
+    typedef internal::Arg Arg;
 
- public:
-  void report_unhandled_arg() {}
+public:
+    void report_unhandled_arg() {}
 
-  Result visit_unhandled_arg() {
-    FMT_DISPATCH(report_unhandled_arg());
-    return Result();
-  }
-
-  /** Visits an ``int`` argument. **/
-  Result visit_int(int value) {
-    return FMT_DISPATCH(visit_any_int(value));
-  }
-
-  /** Visits a ``long long`` argument. **/
-  Result visit_long_long(LongLong value) {
-    return FMT_DISPATCH(visit_any_int(value));
-  }
-
-  /** Visits an ``unsigned`` argument. **/
-  Result visit_uint(unsigned value) {
-    return FMT_DISPATCH(visit_any_int(value));
-  }
-
-  /** Visits an ``unsigned long long`` argument. **/
-  Result visit_ulong_long(ULongLong value) {
-    return FMT_DISPATCH(visit_any_int(value));
-  }
-
-  /** Visits a ``bool`` argument. **/
-  Result visit_bool(bool value) {
-    return FMT_DISPATCH(visit_any_int(value));
-  }
-
-  /** Visits a ``char`` or ``wchar_t`` argument. **/
-  Result visit_char(int value) {
-    return FMT_DISPATCH(visit_any_int(value));
-  }
-
-  /** Visits an argument of any integral type. **/
-  template <typename T>
-  Result visit_any_int(T) {
-    return FMT_DISPATCH(visit_unhandled_arg());
-  }
-
-  /** Visits a ``double`` argument. **/
-  Result visit_double(double value) {
-    return FMT_DISPATCH(visit_any_double(value));
-  }
-
-  /** Visits a ``long double`` argument. **/
-  Result visit_long_double(long double value) {
-    return FMT_DISPATCH(visit_any_double(value));
-  }
-
-  /** Visits a ``double`` or ``long double`` argument. **/
-  template <typename T>
-  Result visit_any_double(T) {
-    return FMT_DISPATCH(visit_unhandled_arg());
-  }
-
-  /** Visits a null-terminated C string (``const char *``) argument. **/
-  Result visit_cstring(const char *) {
-    return FMT_DISPATCH(visit_unhandled_arg());
-  }
-
-  /** Visits a string argument. **/
-  Result visit_string(Arg::StringValue<char>) {
-    return FMT_DISPATCH(visit_unhandled_arg());
-  }
-
-  /** Visits a wide string argument. **/
-  Result visit_wstring(Arg::StringValue<wchar_t>) {
-    return FMT_DISPATCH(visit_unhandled_arg());
-  }
-
-  /** Visits a pointer argument. **/
-  Result visit_pointer(const void *) {
-    return FMT_DISPATCH(visit_unhandled_arg());
-  }
-
-  /** Visits an argument of a custom (user-defined) type. **/
-  Result visit_custom(Arg::CustomValue) {
-    return FMT_DISPATCH(visit_unhandled_arg());
-  }
-
-  /**
-    \rst
-    Visits an argument dispatching to the appropriate visit method based on
-    the argument type. For example, if the argument type is ``double`` then
-    the `~fmt::ArgVisitor::visit_double()` method of the *Impl* class will be
-    called.
-    \endrst
-   */
-  Result visit(const Arg &arg) {
-    switch (arg.type) {
-    case Arg::NONE:
-    case Arg::NAMED_ARG:
-      FMT_ASSERT(false, "invalid argument type");
-      break;
-    case Arg::INT:
-      return FMT_DISPATCH(visit_int(arg.int_value));
-    case Arg::UINT:
-      return FMT_DISPATCH(visit_uint(arg.uint_value));
-    case Arg::LONG_LONG:
-      return FMT_DISPATCH(visit_long_long(arg.long_long_value));
-    case Arg::ULONG_LONG:
-      return FMT_DISPATCH(visit_ulong_long(arg.ulong_long_value));
-    case Arg::BOOL:
-      return FMT_DISPATCH(visit_bool(arg.int_value != 0));
-    case Arg::CHAR:
-      return FMT_DISPATCH(visit_char(arg.int_value));
-    case Arg::DOUBLE:
-      return FMT_DISPATCH(visit_double(arg.double_value));
-    case Arg::LONG_DOUBLE:
-      return FMT_DISPATCH(visit_long_double(arg.long_double_value));
-    case Arg::CSTRING:
-      return FMT_DISPATCH(visit_cstring(arg.string.value));
-    case Arg::STRING:
-      return FMT_DISPATCH(visit_string(arg.string));
-    case Arg::WSTRING:
-      return FMT_DISPATCH(visit_wstring(arg.wstring));
-    case Arg::POINTER:
-      return FMT_DISPATCH(visit_pointer(arg.pointer));
-    case Arg::CUSTOM:
-      return FMT_DISPATCH(visit_custom(arg.custom));
+    Result visit_unhandled_arg()
+    {
+        FMT_DISPATCH(report_unhandled_arg());
+        return Result();
+    }
+
+    /** Visits an ``int`` argument. **/
+    Result visit_int(int value)
+    {
+        return FMT_DISPATCH(visit_any_int(value));
+    }
+
+    /** Visits a ``long long`` argument. **/
+    Result visit_long_long(LongLong value)
+    {
+        return FMT_DISPATCH(visit_any_int(value));
+    }
+
+    /** Visits an ``unsigned`` argument. **/
+    Result visit_uint(unsigned value)
+    {
+        return FMT_DISPATCH(visit_any_int(value));
+    }
+
+    /** Visits an ``unsigned long long`` argument. **/
+    Result visit_ulong_long(ULongLong value)
+    {
+        return FMT_DISPATCH(visit_any_int(value));
+    }
+
+    /** Visits a ``bool`` argument. **/
+    Result visit_bool(bool value)
+    {
+        return FMT_DISPATCH(visit_any_int(value));
+    }
+
+    /** Visits a ``char`` or ``wchar_t`` argument. **/
+    Result visit_char(int value)
+    {
+        return FMT_DISPATCH(visit_any_int(value));
+    }
+
+    /** Visits an argument of any integral type. **/
+    template <typename T>
+    Result visit_any_int(T)
+    {
+        return FMT_DISPATCH(visit_unhandled_arg());
+    }
+
+    /** Visits a ``double`` argument. **/
+    Result visit_double(double value)
+    {
+        return FMT_DISPATCH(visit_any_double(value));
+    }
+
+    /** Visits a ``long double`` argument. **/
+    Result visit_long_double(long double value)
+    {
+        return FMT_DISPATCH(visit_any_double(value));
+    }
+
+    /** Visits a ``double`` or ``long double`` argument. **/
+    template <typename T>
+    Result visit_any_double(T)
+    {
+        return FMT_DISPATCH(visit_unhandled_arg());
+    }
+
+    /** Visits a null-terminated C string (``const char *``) argument. **/
+    Result visit_cstring(const char *)
+    {
+        return FMT_DISPATCH(visit_unhandled_arg());
+    }
+
+    /** Visits a string argument. **/
+    Result visit_string(Arg::StringValue<char>)
+    {
+        return FMT_DISPATCH(visit_unhandled_arg());
+    }
+
+    /** Visits a wide string argument. **/
+    Result visit_wstring(Arg::StringValue<wchar_t>)
+    {
+        return FMT_DISPATCH(visit_unhandled_arg());
+    }
+
+    /** Visits a pointer argument. **/
+    Result visit_pointer(const void *)
+    {
+        return FMT_DISPATCH(visit_unhandled_arg());
+    }
+
+    /** Visits an argument of a custom (user-defined) type. **/
+    Result visit_custom(Arg::CustomValue)
+    {
+        return FMT_DISPATCH(visit_unhandled_arg());
+    }
+
+    /**
+      \rst
+      Visits an argument dispatching to the appropriate visit method based on
+      the argument type. For example, if the argument type is ``double`` then
+      the `~fmt::ArgVisitor::visit_double()` method of the *Impl* class will be
+      called.
+      \endrst
+     */
+    Result visit(const Arg &arg)
+    {
+        switch (arg.type)
+        {
+        case Arg::NONE:
+        case Arg::NAMED_ARG:
+            FMT_ASSERT(false, "invalid argument type");
+            break;
+        case Arg::INT:
+            return FMT_DISPATCH(visit_int(arg.int_value));
+        case Arg::UINT:
+            return FMT_DISPATCH(visit_uint(arg.uint_value));
+        case Arg::LONG_LONG:
+            return FMT_DISPATCH(visit_long_long(arg.long_long_value));
+        case Arg::ULONG_LONG:
+            return FMT_DISPATCH(visit_ulong_long(arg.ulong_long_value));
+        case Arg::BOOL:
+            return FMT_DISPATCH(visit_bool(arg.int_value != 0));
+        case Arg::CHAR:
+            return FMT_DISPATCH(visit_char(arg.int_value));
+        case Arg::DOUBLE:
+            return FMT_DISPATCH(visit_double(arg.double_value));
+        case Arg::LONG_DOUBLE:
+            return FMT_DISPATCH(visit_long_double(arg.long_double_value));
+        case Arg::CSTRING:
+            return FMT_DISPATCH(visit_cstring(arg.string.value));
+        case Arg::STRING:
+            return FMT_DISPATCH(visit_string(arg.string));
+        case Arg::WSTRING:
+            return FMT_DISPATCH(visit_wstring(arg.wstring));
+        case Arg::POINTER:
+            return FMT_DISPATCH(visit_pointer(arg.pointer));
+        case Arg::CUSTOM:
+            return FMT_DISPATCH(visit_custom(arg.custom));
+        }
+        return Result();
     }
-    return Result();
-  }
 };
 
-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,
-  CHAR_FLAG = 0x10  // Argument has char type - used in error reporting.
+enum
+{
+    SIGN_FLAG = 1, PLUS_FLAG = 2, MINUS_FLAG = 4, HASH_FLAG = 8,
+    CHAR_FLAG = 0x10  // Argument has char type - used in error reporting.
 };
 
 // An empty format specifier.
@@ -1700,94 +1974,162 @@ struct EmptySpec {};
 
 // A type specifier.
 template <char TYPE>
-struct TypeSpec : EmptySpec {
-  Alignment align() const { return ALIGN_DEFAULT; }
-  unsigned width() const { return 0; }
-  int precision() const { return -1; }
-  bool flag(unsigned) const { return false; }
-  char type() const { return TYPE; }
-  char type_prefix() const { return TYPE; }
-  char fill() const { return ' '; }
+struct TypeSpec : EmptySpec
+{
+    Alignment align() const
+    {
+        return ALIGN_DEFAULT;
+    }
+    unsigned width() const
+    {
+        return 0;
+    }
+    int precision() const
+    {
+        return -1;
+    }
+    bool flag(unsigned) const
+    {
+        return false;
+    }
+    char type() const
+    {
+        return TYPE;
+    }
+    char type_prefix() const
+    {
+        return TYPE;
+    }
+    char fill() const
+    {
+        return ' ';
+    }
 };
 
 // A width specifier.
-struct WidthSpec {
-  unsigned width_;
-  // Fill is always wchar_t and cast to char if necessary to avoid having
-  // two specialization of WidthSpec and its subclasses.
-  wchar_t fill_;
+struct WidthSpec
+{
+    unsigned width_;
+    // Fill is always wchar_t and cast to char if necessary to avoid having
+    // two specialization of WidthSpec and its subclasses.
+    wchar_t fill_;
 
-  WidthSpec(unsigned width, wchar_t fill) : width_(width), fill_(fill) {}
+    WidthSpec(unsigned width, wchar_t fill) : width_(width), fill_(fill) {}
 
-  unsigned width() const { return width_; }
-  wchar_t fill() const { return fill_; }
+    unsigned width() const
+    {
+        return width_;
+    }
+    wchar_t fill() const
+    {
+        return fill_;
+    }
 };
 
 // An alignment specifier.
-struct AlignSpec : WidthSpec {
-  Alignment align_;
+struct AlignSpec : WidthSpec
+{
+    Alignment align_;
 
-  AlignSpec(unsigned width, wchar_t fill, Alignment align = ALIGN_DEFAULT)
-  : WidthSpec(width, fill), align_(align) {}
+    AlignSpec(unsigned width, wchar_t fill, Alignment align = ALIGN_DEFAULT)
+        : WidthSpec(width, fill), align_(align) {}
 
-  Alignment align() const { return align_; }
+    Alignment align() const
+    {
+        return align_;
+    }
 
-  int precision() const { return -1; }
+    int precision() const
+    {
+        return -1;
+    }
 };
 
 // An alignment and type specifier.
 template <char TYPE>
-struct AlignTypeSpec : AlignSpec {
-  AlignTypeSpec(unsigned width, wchar_t fill) : AlignSpec(width, fill) {}
+struct AlignTypeSpec : AlignSpec
+{
+    AlignTypeSpec(unsigned width, wchar_t fill) : AlignSpec(width, fill) {}
 
-  bool flag(unsigned) const { return false; }
-  char type() const { return TYPE; }
-  char type_prefix() const { return TYPE; }
+    bool flag(unsigned) const
+    {
+        return false;
+    }
+    char type() const
+    {
+        return TYPE;
+    }
+    char type_prefix() const
+    {
+        return TYPE;
+    }
 };
 
 // A full format specifier.
-struct FormatSpec : AlignSpec {
-  unsigned flags_;
-  int precision_;
-  char type_;
+struct FormatSpec : AlignSpec
+{
+    unsigned flags_;
+    int precision_;
+    char type_;
 
-  FormatSpec(
-    unsigned width = 0, char type = 0, wchar_t fill = ' ')
-  : AlignSpec(width, fill), flags_(0), precision_(-1), type_(type) {}
+    FormatSpec(
+        unsigned width = 0, char type = 0, wchar_t fill = ' ')
+        : AlignSpec(width, fill), flags_(0), precision_(-1), type_(type) {}
 
-  bool flag(unsigned f) const { return (flags_ & f) != 0; }
-  int precision() const { return precision_; }
-  char type() const { return type_; }
-  char type_prefix() const { return type_; }
+    bool flag(unsigned f) const
+    {
+        return (flags_ & f) != 0;
+    }
+    int precision() const
+    {
+        return precision_;
+    }
+    char type() const
+    {
+        return type_;
+    }
+    char type_prefix() const
+    {
+        return type_;
+    }
 };
 
 // An integer format specifier.
 template <typename T, typename SpecT = TypeSpec<0>, typename Char = char>
-class IntFormatSpec : public SpecT {
- private:
-  T value_;
+class IntFormatSpec : public SpecT
+{
+private:
+    T value_;
 
- public:
-  IntFormatSpec(T val, const SpecT &spec = SpecT())
-  : SpecT(spec), value_(val) {}
+public:
+    IntFormatSpec(T val, const SpecT &spec = SpecT())
+        : SpecT(spec), value_(val) {}
 
-  T value() const { return value_; }
+    T value() const
+    {
+        return value_;
+    }
 };
 
 // A string format specifier.
 template <typename Char>
-class StrFormatSpec : public AlignSpec {
- private:
-  const Char *str_;
+class StrFormatSpec : public AlignSpec
+{
+private:
+    const Char *str_;
 
- public:
-  template <typename FillChar>
-  StrFormatSpec(const Char *str, unsigned width, FillChar fill)
-  : AlignSpec(width, fill), str_(str) {
-    internal::CharTraits<Char>::convert(FillChar());
-  }
+public:
+    template <typename FillChar>
+    StrFormatSpec(const Char *str, unsigned width, FillChar fill)
+        : AlignSpec(width, fill), str_(str)
+    {
+        internal::CharTraits<Char>::convert(FillChar());
+    }
 
-  const Char *str() const { return str_; }
+    const Char *str() const
+    {
+        return str_;
+    }
 };
 
 /**
@@ -1900,190 +2242,238 @@ FMT_DEFINE_INT_FORMATTERS(ULongLong)
  */
 template <typename Char>
 inline StrFormatSpec<Char> pad(
-    const Char *str, unsigned width, Char fill = ' ') {
-  return StrFormatSpec<Char>(str, width, fill);
+    const Char *str, unsigned width, Char fill = ' ')
+{
+    return StrFormatSpec<Char>(str, width, fill);
 }
 
 inline StrFormatSpec<wchar_t> pad(
-    const wchar_t *str, unsigned width, char fill = ' ') {
-  return StrFormatSpec<wchar_t>(str, width, fill);
+    const wchar_t *str, unsigned width, char fill = ' ')
+{
+    return StrFormatSpec<wchar_t>(str, width, fill);
 }
 
-namespace internal {
+namespace internal
+{
 
 template <typename Char>
-class ArgMap {
- private:
-  typedef std::vector<
+class ArgMap
+{
+private:
+    typedef std::vector<
     std::pair<fmt::BasicStringRef<Char>, internal::Arg> > MapType;
-  typedef typename MapType::value_type Pair;
+    typedef typename MapType::value_type Pair;
 
-  MapType map_;
+    MapType map_;
 
- public:
-  FMT_API void init(const ArgList &args);
+public:
+    FMT_API void init(const ArgList &args);
 
-  const internal::Arg *find(const fmt::BasicStringRef<Char> &name) const {
-    // The list is unsorted, so just return the first matching name.
-    for (typename MapType::const_iterator it = map_.begin(), end = map_.end();
-         it != end; ++it) {
-      if (it->first == name)
-        return &it->second;
+    const internal::Arg *find(const fmt::BasicStringRef<Char> &name) const
+    {
+        // The list is unsorted, so just return the first matching name.
+        for (typename MapType::const_iterator it = map_.begin(), end = map_.end();
+                it != end; ++it)
+        {
+            if (it->first == name)
+                return &it->second;
+        }
+        return FMT_NULL;
     }
-    return FMT_NULL;
-  }
 };
 
 template <typename Impl, typename Char, typename Spec = fmt::FormatSpec>
-class ArgFormatterBase : public ArgVisitor<Impl, void> {
- private:
-  BasicWriter<Char> &writer_;
-  Spec &spec_;
+class ArgFormatterBase : public ArgVisitor<Impl, void>
+{
+private:
+    BasicWriter<Char> &writer_;
+    Spec &spec_;
 
-  FMT_DISALLOW_COPY_AND_ASSIGN(ArgFormatterBase);
+    FMT_DISALLOW_COPY_AND_ASSIGN(ArgFormatterBase);
 
-  void write_pointer(const void *p) {
-    spec_.flags_ = HASH_FLAG;
-    spec_.type_ = 'x';
-    writer_.write_int(reinterpret_cast<uintptr_t>(p), spec_);
-  }
-
-  // workaround MSVC two-phase lookup issue
-  typedef internal::Arg Arg;
-
- protected:
-  BasicWriter<Char> &writer() { return writer_; }
-  Spec &spec() { return spec_; }
-
-  void write(bool value) {
-    const char *str_value = value ? "true" : "false";
-    Arg::StringValue<char> str = { str_value, std::strlen(str_value) };
-    writer_.write_str(str, spec_);
-  }
-
-  void write(const char *value) {
-    Arg::StringValue<char> str = {value, value ? std::strlen(value) : 0};
-    writer_.write_str(str, spec_);
-  }
-
- public:
-  typedef Spec SpecType;
-
-  ArgFormatterBase(BasicWriter<Char> &w, Spec &s)
-  : writer_(w), spec_(s) {}
-
-  template <typename T>
-  void visit_any_int(T value) { writer_.write_int(value, spec_); }
-
-  template <typename T>
-  void visit_any_double(T value) { writer_.write_double(value, spec_); }
-
-  void visit_bool(bool value) {
-    if (spec_.type_) {
-      visit_any_int(value);
-      return;
+    void write_pointer(const void *p)
+    {
+        spec_.flags_ = HASH_FLAG;
+        spec_.type_ = 'x';
+        writer_.write_int(reinterpret_cast<uintptr_t>(p), spec_);
     }
-    write(value);
-  }
 
-  void visit_char(int value) {
-    if (spec_.type_ && spec_.type_ != 'c') {
-      spec_.flags_ |= CHAR_FLAG;
-      writer_.write_int(value, spec_);
-      return;
+    // workaround MSVC two-phase lookup issue
+    typedef internal::Arg Arg;
+
+protected:
+    BasicWriter<Char> &writer()
+    {
+        return writer_;
     }
-    if (spec_.align_ == ALIGN_NUMERIC || spec_.flags_ != 0)
-      FMT_THROW(FormatError("invalid format specifier for char"));
-    typedef typename BasicWriter<Char>::CharPtr CharPtr;
-    Char fill = internal::CharTraits<Char>::cast(spec_.fill());
-    CharPtr out = CharPtr();
-    const unsigned CHAR_SIZE = 1;
-    if (spec_.width_ > CHAR_SIZE) {
-      out = writer_.grow_buffer(spec_.width_);
-      if (spec_.align_ == ALIGN_RIGHT) {
-        std::uninitialized_fill_n(out, spec_.width_ - CHAR_SIZE, fill);
-        out += spec_.width_ - CHAR_SIZE;
-      } else if (spec_.align_ == ALIGN_CENTER) {
-        out = writer_.fill_padding(out, spec_.width_,
-                                   internal::const_check(CHAR_SIZE), fill);
-      } else {
-        std::uninitialized_fill_n(out + CHAR_SIZE,
-                                  spec_.width_ - CHAR_SIZE, fill);
-      }
-    } else {
-      out = writer_.grow_buffer(CHAR_SIZE);
+    Spec &spec()
+    {
+        return spec_;
     }
-    *out = internal::CharTraits<Char>::cast(value);
-  }
 
-  void visit_cstring(const char *value) {
-    if (spec_.type_ == 'p')
-      return write_pointer(value);
-    write(value);
-  }
+    void write(bool value)
+    {
+        const char *str_value = value ? "true" : "false";
+        Arg::StringValue<char> str = { str_value, std::strlen(str_value) };
+        writer_.write_str(str, spec_);
+    }
 
-  // Qualification with "internal" here and below is a workaround for nvcc.
-  void visit_string(internal::Arg::StringValue<char> value) {
-    writer_.write_str(value, spec_);
-  }
+    void write(const char *value)
+    {
+        Arg::StringValue<char> str = {value, value ? std::strlen(value) : 0};
+        writer_.write_str(str, spec_);
+    }
 
-  using ArgVisitor<Impl, void>::visit_wstring;
+public:
+    typedef Spec SpecType;
 
-  void visit_wstring(internal::Arg::StringValue<Char> value) {
-    writer_.write_str(value, spec_);
-  }
+    ArgFormatterBase(BasicWriter<Char> &w, Spec &s)
+        : writer_(w), spec_(s) {}
 
-  void visit_pointer(const void *value) {
-    if (spec_.type_ && spec_.type_ != 'p')
-      report_unknown_type(spec_.type_, "pointer");
-    write_pointer(value);
-  }
+    template <typename T>
+    void visit_any_int(T value)
+    {
+        writer_.write_int(value, spec_);
+    }
+
+    template <typename T>
+    void visit_any_double(T value)
+    {
+        writer_.write_double(value, spec_);
+    }
+
+    void visit_bool(bool value)
+    {
+        if (spec_.type_)
+        {
+            visit_any_int(value);
+            return;
+        }
+        write(value);
+    }
+
+    void visit_char(int value)
+    {
+        if (spec_.type_ && spec_.type_ != 'c')
+        {
+            spec_.flags_ |= CHAR_FLAG;
+            writer_.write_int(value, spec_);
+            return;
+        }
+        if (spec_.align_ == ALIGN_NUMERIC || spec_.flags_ != 0)
+            FMT_THROW(FormatError("invalid format specifier for char"));
+        typedef typename BasicWriter<Char>::CharPtr CharPtr;
+        Char fill = internal::CharTraits<Char>::cast(spec_.fill());
+        CharPtr out = CharPtr();
+        const unsigned CHAR_SIZE = 1;
+        if (spec_.width_ > CHAR_SIZE)
+        {
+            out = writer_.grow_buffer(spec_.width_);
+            if (spec_.align_ == ALIGN_RIGHT)
+            {
+                std::uninitialized_fill_n(out, spec_.width_ - CHAR_SIZE, fill);
+                out += spec_.width_ - CHAR_SIZE;
+            }
+            else if (spec_.align_ == ALIGN_CENTER)
+            {
+                out = writer_.fill_padding(out, spec_.width_,
+                                           internal::const_check(CHAR_SIZE), fill);
+            }
+            else
+            {
+                std::uninitialized_fill_n(out + CHAR_SIZE,
+                                          spec_.width_ - CHAR_SIZE, fill);
+            }
+        }
+        else
+        {
+            out = writer_.grow_buffer(CHAR_SIZE);
+        }
+        *out = internal::CharTraits<Char>::cast(value);
+    }
+
+    void visit_cstring(const char *value)
+    {
+        if (spec_.type_ == 'p')
+            return write_pointer(value);
+        write(value);
+    }
+
+    // Qualification with "internal" here and below is a workaround for nvcc.
+    void visit_string(internal::Arg::StringValue<char> value)
+    {
+        writer_.write_str(value, spec_);
+    }
+
+    using ArgVisitor<Impl, void>::visit_wstring;
+
+    void visit_wstring(internal::Arg::StringValue<Char> value)
+    {
+        writer_.write_str(value, spec_);
+    }
+
+    void visit_pointer(const void *value)
+    {
+        if (spec_.type_ && spec_.type_ != 'p')
+            report_unknown_type(spec_.type_, "pointer");
+        write_pointer(value);
+    }
 };
 
-class FormatterBase {
- private:
-  ArgList args_;
-  int next_arg_index_;
+class FormatterBase
+{
+private:
+    ArgList args_;
+    int next_arg_index_;
 
-  // Returns the argument with specified index.
-  FMT_API Arg do_get_arg(unsigned arg_index, const char *&error);
+    // Returns the argument with specified index.
+    FMT_API Arg do_get_arg(unsigned arg_index, const char *&error);
 
- protected:
-  const ArgList &args() const { return args_; }
-
-  explicit FormatterBase(const ArgList &args) {
-    args_ = args;
-    next_arg_index_ = 0;
-  }
-
-  // Returns the next argument.
-  Arg next_arg(const char *&error) {
-    if (next_arg_index_ >= 0)
-      return do_get_arg(internal::to_unsigned(next_arg_index_++), error);
-    error = "cannot switch from manual to automatic argument indexing";
-    return Arg();
-  }
-
-  // Checks if manual indexing is used and returns the argument with
-  // specified index.
-  Arg get_arg(unsigned arg_index, const char *&error) {
-    return check_no_auto_index(error) ? do_get_arg(arg_index, error) : Arg();
-  }
-
-  bool check_no_auto_index(const char *&error) {
-    if (next_arg_index_ > 0) {
-      error = "cannot switch from automatic to manual argument indexing";
-      return false;
+protected:
+    const ArgList &args() const
+    {
+        return args_;
     }
-    next_arg_index_ = -1;
-    return true;
-  }
 
-  template <typename Char>
-  void write(BasicWriter<Char> &w, const Char *start, const Char *end) {
-    if (start != end)
-      w << BasicStringRef<Char>(start, internal::to_unsigned(end - start));
-  }
+    explicit FormatterBase(const ArgList &args)
+    {
+        args_ = args;
+        next_arg_index_ = 0;
+    }
+
+    // Returns the next argument.
+    Arg next_arg(const char *&error)
+    {
+        if (next_arg_index_ >= 0)
+            return do_get_arg(internal::to_unsigned(next_arg_index_++), error);
+        error = "cannot switch from manual to automatic argument indexing";
+        return Arg();
+    }
+
+    // Checks if manual indexing is used and returns the argument with
+    // specified index.
+    Arg get_arg(unsigned arg_index, const char *&error)
+    {
+        return check_no_auto_index(error) ? do_get_arg(arg_index, error) : Arg();
+    }
+
+    bool check_no_auto_index(const char *&error)
+    {
+        if (next_arg_index_ > 0)
+        {
+            error = "cannot switch from automatic to manual argument indexing";
+            return false;
+        }
+        next_arg_index_ = -1;
+        return true;
+    }
+
+    template <typename Char>
+    void write(BasicWriter<Char> &w, const Char *start, const Char *end)
+    {
+        if (start != end)
+            w << BasicStringRef<Char>(start, internal::to_unsigned(end - start));
+    }
 };
 }  // namespace internal
 
@@ -2105,87 +2495,94 @@ class FormatterBase {
   \endrst
  */
 template <typename Impl, typename Char, typename Spec = fmt::FormatSpec>
-class BasicArgFormatter : public internal::ArgFormatterBase<Impl, Char, Spec> {
- private:
-  BasicFormatter<Char, Impl> &formatter_;
-  const Char *format_;
+class BasicArgFormatter : public internal::ArgFormatterBase<Impl, Char, Spec>
+{
+private:
+    BasicFormatter<Char, Impl> &formatter_;
+    const Char *format_;
 
- public:
-  /**
-    \rst
-    Constructs an argument formatter object.
-    *formatter* is a reference to the main formatter object, *spec* contains
-    format specifier information for standard argument types, and *fmt* points
-    to the part of the format string being parsed for custom argument types.
-    \endrst
-   */
-  BasicArgFormatter(BasicFormatter<Char, Impl> &formatter,
-                    Spec &spec, const Char *fmt)
-  : internal::ArgFormatterBase<Impl, Char, Spec>(formatter.writer(), spec),
-    formatter_(formatter), format_(fmt) {}
+public:
+    /**
+      \rst
+      Constructs an argument formatter object.
+      *formatter* is a reference to the main formatter object, *spec* contains
+      format specifier information for standard argument types, and *fmt* points
+      to the part of the format string being parsed for custom argument types.
+      \endrst
+     */
+    BasicArgFormatter(BasicFormatter<Char, Impl> &formatter,
+                      Spec &spec, const Char *fmt)
+        : internal::ArgFormatterBase<Impl, Char, Spec>(formatter.writer(), spec),
+          formatter_(formatter), format_(fmt) {}
 
-  /** Formats an argument of a custom (user-defined) type. */
-  void visit_custom(internal::Arg::CustomValue c) {
-    c.format(&formatter_, c.value, &format_);
-  }
+    /** Formats an argument of a custom (user-defined) type. */
+    void visit_custom(internal::Arg::CustomValue c)
+    {
+        c.format(&formatter_, c.value, &format_);
+    }
 };
 
 /** The default argument formatter. */
 template <typename Char>
 class ArgFormatter :
-    public BasicArgFormatter<ArgFormatter<Char>, Char, FormatSpec> {
- public:
-  /** Constructs an argument formatter object. */
-  ArgFormatter(BasicFormatter<Char> &formatter,
-               FormatSpec &spec, const Char *fmt)
-  : BasicArgFormatter<ArgFormatter<Char>,
-                      Char, FormatSpec>(formatter, spec, fmt) {}
+    public BasicArgFormatter<ArgFormatter<Char>, Char, FormatSpec>
+{
+public:
+    /** Constructs an argument formatter object. */
+    ArgFormatter(BasicFormatter<Char> &formatter,
+                 FormatSpec &spec, const Char *fmt)
+        : BasicArgFormatter<ArgFormatter<Char>,
+          Char, FormatSpec>(formatter, spec, fmt) {}
 };
 
 /** This template formats data and writes the output to a writer. */
 template <typename CharType, typename ArgFormatter>
-class BasicFormatter : private internal::FormatterBase {
- public:
-  /** The character type for the output. */
-  typedef CharType Char;
+class BasicFormatter : private internal::FormatterBase
+{
+public:
+    /** The character type for the output. */
+    typedef CharType Char;
 
- private:
-  BasicWriter<Char> &writer_;
-  internal::ArgMap<Char> map_;
+private:
+    BasicWriter<Char> &writer_;
+    internal::ArgMap<Char> map_;
 
-  FMT_DISALLOW_COPY_AND_ASSIGN(BasicFormatter);
+    FMT_DISALLOW_COPY_AND_ASSIGN(BasicFormatter);
 
-  using internal::FormatterBase::get_arg;
+    using internal::FormatterBase::get_arg;
 
-  // Checks if manual indexing is used and returns the argument with
-  // specified name.
-  internal::Arg get_arg(BasicStringRef<Char> arg_name, const char *&error);
+    // Checks if manual indexing is used and returns the argument with
+    // specified name.
+    internal::Arg get_arg(BasicStringRef<Char> arg_name, const char *&error);
 
-  // Parses argument index and returns corresponding argument.
-  internal::Arg parse_arg_index(const Char *&s);
+    // Parses argument index and returns corresponding argument.
+    internal::Arg parse_arg_index(const Char *&s);
 
-  // Parses argument name and returns corresponding argument.
-  internal::Arg parse_arg_name(const Char *&s);
+    // Parses argument name and returns corresponding argument.
+    internal::Arg parse_arg_name(const Char *&s);
 
- public:
-  /**
-   \rst
-   Constructs a ``BasicFormatter`` object. References to the arguments and
-   the writer are stored in the formatter object so make sure they have
-   appropriate lifetimes.
-   \endrst
-   */
-  BasicFormatter(const ArgList &args, BasicWriter<Char> &w)
-    : internal::FormatterBase(args), writer_(w) {}
+public:
+    /**
+     \rst
+     Constructs a ``BasicFormatter`` object. References to the arguments and
+     the writer are stored in the formatter object so make sure they have
+     appropriate lifetimes.
+     \endrst
+     */
+    BasicFormatter(const ArgList &args, BasicWriter<Char> &w)
+        : internal::FormatterBase(args), writer_(w) {}
 
-  /** Returns a reference to the writer associated with this formatter. */
-  BasicWriter<Char> &writer() { return writer_; }
+    /** Returns a reference to the writer associated with this formatter. */
+    BasicWriter<Char> &writer()
+    {
+        return writer_;
+    }
 
-  /** Formats stored arguments and writes the output to the writer. */
-  void format(BasicCStringRef<Char> format_str);
+    /** Formats stored arguments and writes the output to the writer. */
+    void format(BasicCStringRef<Char> format_str);
 
-  // Formats a single argument and advances format_str, a format string pointer.
-  const Char *format(const Char *&format_str, const internal::Arg &arg);
+    // Formats a single argument and advances format_str, a format string pointer.
+    const Char *format(const Char *&format_str, const internal::Arg &arg);
 };
 
 // Generates a comma-separated list with results of applying f to
@@ -2207,23 +2604,30 @@ class BasicFormatter : private internal::FormatterBase {
 # define FMT_GEN14(f) FMT_GEN13(f), f(13)
 # define FMT_GEN15(f) FMT_GEN14(f), f(14)
 
-namespace internal {
-inline uint64_t make_type() { return 0; }
+namespace internal
+{
+inline uint64_t make_type()
+{
+    return 0;
+}
 
 template <typename T>
-inline uint64_t make_type(const T &arg) {
-  return MakeValue< BasicFormatter<char> >::type(arg);
+inline uint64_t make_type(const T &arg)
+{
+    return MakeValue< BasicFormatter<char> >::type(arg);
 }
 
 template <std::size_t N, bool/*IsPacked*/= (N < ArgList::MAX_PACKED_ARGS)>
-struct ArgArray;
+          struct ArgArray;
 
 template <std::size_t N>
-struct ArgArray<N, true/*IsPacked*/> {
-  typedef Value Type[N > 0 ? N : 1];
+struct ArgArray<N, true/*IsPacked*/>
+{
+    typedef Value Type[N > 0 ? N : 1];
 
-  template <typename Formatter, typename T>
-  static Value make(const T &value) {
+template <typename Formatter, typename T>
+static Value make(const T &value)
+{
 #ifdef __clang__
     Value result = MakeValue<Formatter>(value);
     // Workaround a bug in Apple LLVM version 4.2 (clang-425.0.28) of clang:
@@ -2233,41 +2637,48 @@ struct ArgArray<N, true/*IsPacked*/> {
 #else
     return MakeValue<Formatter>(value);
 #endif
-  }
-};
+}
+         };
 
 template <std::size_t N>
-struct ArgArray<N, false/*IsPacked*/> {
-  typedef Arg Type[N + 1]; // +1 for the list end Arg::NONE
+struct ArgArray<N, false/*IsPacked*/>
+{
+    typedef Arg Type[N + 1]; // +1 for the list end Arg::NONE
 
-  template <typename Formatter, typename T>
-  static Arg make(const T &value) { return MakeArg<Formatter>(value); }
+    template <typename Formatter, typename T>
+    static Arg make(const T &value)
+    {
+        return MakeArg<Formatter>(value);
+    }
 };
 
 #if FMT_USE_VARIADIC_TEMPLATES
 template <typename Arg, typename... Args>
-inline uint64_t make_type(const Arg &first, const Args & ... tail) {
-  return make_type(first) | (make_type(tail...) << 4);
+inline uint64_t make_type(const Arg &first, const Args & ... tail)
+{
+    return make_type(first) | (make_type(tail...) << 4);
 }
 
 #else
 
-struct ArgType {
-  uint64_t type;
+struct ArgType
+{
+    uint64_t type;
 
-  ArgType() : type(0) {}
+    ArgType() : type(0) {}
 
-  template <typename T>
-  ArgType(const T &arg) : type(make_type(arg)) {}
+    template <typename T>
+    ArgType(const T &arg) : type(make_type(arg)) {}
 };
 
 # define FMT_ARG_TYPE_DEFAULT(n) ArgType t##n = ArgType()
 
-inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) {
-  return t0.type | (t1.type << 4) | (t2.type << 8) | (t3.type << 12) |
-      (t4.type << 16) | (t5.type << 20) | (t6.type << 24) | (t7.type << 28) |
-      (t8.type << 32) | (t9.type << 36) | (t10.type << 40) | (t11.type << 44) |
-      (t12.type << 48) | (t13.type << 52) | (t14.type << 56);
+inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT))
+{
+    return t0.type | (t1.type << 4) | (t2.type << 8) | (t3.type << 12) |
+           (t4.type << 16) | (t5.type << 20) | (t6.type << 24) | (t7.type << 28) |
+           (t8.type << 32) | (t9.type << 36) | (t10.type << 40) | (t11.type << 44) |
+           (t12.type << 48) | (t13.type << 52) | (t14.type << 56);
 }
 #endif
 }  // namespace internal
@@ -2374,45 +2785,50 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) {
  An error returned by an operating system or a language runtime,
  for example a file opening error.
 */
-class SystemError : public internal::RuntimeError {
- private:
-  FMT_API void init(int err_code, CStringRef format_str, ArgList args);
+class SystemError : public internal::RuntimeError
+{
+private:
+    FMT_API void init(int err_code, CStringRef format_str, ArgList args);
 
- protected:
-  int error_code_;
+protected:
+    int error_code_;
 
-  typedef char Char;  // For FMT_VARIADIC_CTOR.
+    typedef char Char;  // For FMT_VARIADIC_CTOR.
 
-  SystemError() {}
+    SystemError() {}
 
- public:
-  /**
-   \rst
-   Constructs a :class:`fmt::SystemError` 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::SystemError` 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 SystemError with the description
-     //   cannot open file 'madeup': No such file or directory
-     // or similar (system message may vary).
-     const char *filename = "madeup";
-     std::FILE *file = std::fopen(filename, "r");
-     if (!file)
-       throw fmt::SystemError(errno, "cannot open file '{}'", filename);
-   \endrst
-  */
-  SystemError(int error_code, CStringRef message) {
-    init(error_code, message, ArgList());
-  }
-  FMT_DEFAULTED_COPY_CTOR(SystemError)
-  FMT_VARIADIC_CTOR(SystemError, init, int, CStringRef)
+       // This throws a SystemError with the description
+       //   cannot open file 'madeup': No such file or directory
+       // or similar (system message may vary).
+       const char *filename = "madeup";
+       std::FILE *file = std::fopen(filename, "r");
+       if (!file)
+         throw fmt::SystemError(errno, "cannot open file '{}'", filename);
+     \endrst
+    */
+    SystemError(int error_code, CStringRef message)
+    {
+        init(error_code, message, ArgList());
+    }
+    FMT_DEFAULTED_COPY_CTOR(SystemError)
+    FMT_VARIADIC_CTOR(SystemError, init, int, CStringRef)
 
-  FMT_API ~SystemError() FMT_DTOR_NOEXCEPT;
+    FMT_API ~SystemError() FMT_DTOR_NOEXCEPT;
 
-  int error_code() const { return error_code_; }
+    int error_code() const
+    {
+        return error_code_;
+    }
 };
 
 /**
@@ -2453,649 +2869,771 @@ FMT_API void format_system_error(fmt::Writer &out, int error_code,
   \endrst
  */
 template <typename Char>
-class BasicWriter {
- private:
-  // Output buffer.
-  Buffer<Char> &buffer_;
+class BasicWriter
+{
+private:
+    // Output buffer.
+    Buffer<Char> &buffer_;
 
-  FMT_DISALLOW_COPY_AND_ASSIGN(BasicWriter);
+    FMT_DISALLOW_COPY_AND_ASSIGN(BasicWriter);
 
-  typedef typename internal::CharTraits<Char>::CharPtr CharPtr;
+    typedef typename internal::CharTraits<Char>::CharPtr CharPtr;
 
 #if FMT_SECURE_SCL
-  // Returns pointer value.
-  static Char *get(CharPtr p) { return p.base(); }
+    // Returns pointer value.
+    static Char *get(CharPtr p)
+    {
+        return p.base();
+    }
 #else
-  static Char *get(Char *p) { return p; }
+    static Char *get(Char *p)
+    {
+        return p;
+    }
 #endif
 
-  // Fills the padding around the content and returns the pointer to the
-  // content area.
-  static CharPtr fill_padding(CharPtr buffer,
-      unsigned total_size, std::size_t content_size, wchar_t fill);
+    // Fills the padding around the content and returns the pointer to the
+    // content area.
+    static CharPtr fill_padding(CharPtr buffer,
+                                unsigned total_size, std::size_t content_size, wchar_t fill);
 
-  // Grows the buffer by n characters and returns a pointer to the newly
-  // allocated area.
-  CharPtr grow_buffer(std::size_t n) {
-    std::size_t size = buffer_.size();
-    buffer_.resize(size + n);
-    return internal::make_ptr(&buffer_[size], n);
-  }
-
-  // Writes an unsigned decimal integer.
-  template <typename UInt>
-  Char *write_unsigned_decimal(UInt value, unsigned prefix_size = 0) {
-    unsigned num_digits = internal::count_digits(value);
-    Char *ptr = get(grow_buffer(prefix_size + num_digits));
-    internal::format_decimal(ptr + prefix_size, value, num_digits);
-    return ptr;
-  }
-
-  // Writes a decimal integer.
-  template <typename Int>
-  void write_decimal(Int value) {
-    typedef typename internal::IntTraits<Int>::MainType MainType;
-    MainType abs_value = static_cast<MainType>(value);
-    if (internal::is_negative(value)) {
-      abs_value = 0 - abs_value;
-      *write_unsigned_decimal(abs_value, 1) = '-';
-    } else {
-      write_unsigned_decimal(abs_value, 0);
+    // Grows the buffer by n characters and returns a pointer to the newly
+    // allocated area.
+    CharPtr grow_buffer(std::size_t n)
+    {
+        std::size_t size = buffer_.size();
+        buffer_.resize(size + n);
+        return internal::make_ptr(&buffer_[size], n);
     }
-  }
 
-  // Prepare a buffer for integer formatting.
-  CharPtr prepare_int_buffer(unsigned num_digits,
-      const EmptySpec &, const char *prefix, unsigned prefix_size) {
-    unsigned size = prefix_size + num_digits;
-    CharPtr p = grow_buffer(size);
-    std::uninitialized_copy(prefix, prefix + prefix_size, p);
-    return p + size - 1;
-  }
+    // Writes an unsigned decimal integer.
+    template <typename UInt>
+    Char *write_unsigned_decimal(UInt value, unsigned prefix_size = 0)
+    {
+        unsigned num_digits = internal::count_digits(value);
+        Char *ptr = get(grow_buffer(prefix_size + num_digits));
+        internal::format_decimal(ptr + prefix_size, value, num_digits);
+        return ptr;
+    }
 
-  template <typename Spec>
-  CharPtr prepare_int_buffer(unsigned num_digits,
-    const Spec &spec, const char *prefix, unsigned prefix_size);
+    // Writes a decimal integer.
+    template <typename Int>
+    void write_decimal(Int value)
+    {
+        typedef typename internal::IntTraits<Int>::MainType MainType;
+        MainType abs_value = static_cast<MainType>(value);
+        if (internal::is_negative(value))
+        {
+            abs_value = 0 - abs_value;
+            *write_unsigned_decimal(abs_value, 1) = '-';
+        }
+        else
+        {
+            write_unsigned_decimal(abs_value, 0);
+        }
+    }
 
-  // Formats an integer.
-  template <typename T, typename Spec>
-  void write_int(T value, Spec spec);
+    // Prepare a buffer for integer formatting.
+    CharPtr prepare_int_buffer(unsigned num_digits,
+                               const EmptySpec &, const char *prefix, unsigned prefix_size)
+    {
+        unsigned size = prefix_size + num_digits;
+        CharPtr p = grow_buffer(size);
+        std::uninitialized_copy(prefix, prefix + prefix_size, p);
+        return p + size - 1;
+    }
 
-  // Formats a floating-point number (double or long double).
-  template <typename T, typename Spec>
-  void write_double(T value, const Spec &spec);
+    template <typename Spec>
+    CharPtr prepare_int_buffer(unsigned num_digits,
+                               const Spec &spec, const char *prefix, unsigned prefix_size);
 
-  // Writes a formatted string.
-  template <typename StrChar>
-  CharPtr write_str(const StrChar *s, std::size_t size, const AlignSpec &spec);
+    // Formats an integer.
+    template <typename T, typename Spec>
+    void write_int(T value, Spec spec);
 
-  template <typename StrChar, typename Spec>
-  void write_str(const internal::Arg::StringValue<StrChar> &str,
-                 const Spec &spec);
+    // Formats a floating-point number (double or long double).
+    template <typename T, typename Spec>
+    void write_double(T value, const Spec &spec);
 
-  // This following methods are private to disallow writing wide characters
-  // and strings to a char stream. If you want to print a wide string as a
-  // pointer as std::ostream does, cast it to const void*.
-  // Do not implement!
-  void operator<<(typename internal::WCharHelper<wchar_t, Char>::Unsupported);
-  void operator<<(
-      typename internal::WCharHelper<const wchar_t *, Char>::Unsupported);
+    // Writes a formatted string.
+    template <typename StrChar>
+    CharPtr write_str(const StrChar *s, std::size_t size, const AlignSpec &spec);
 
-  // Appends floating-point length specifier to the format string.
-  // The second argument is only used for overload resolution.
-  void append_float_length(Char *&format_ptr, long double) {
-    *format_ptr++ = 'L';
-  }
+    template <typename StrChar, typename Spec>
+    void write_str(const internal::Arg::StringValue<StrChar> &str,
+                   const Spec &spec);
 
-  template<typename T>
-  void append_float_length(Char *&, T) {}
+    // This following methods are private to disallow writing wide characters
+    // and strings to a char stream. If you want to print a wide string as a
+    // pointer as std::ostream does, cast it to const void*.
+    // Do not implement!
+    void operator<<(typename internal::WCharHelper<wchar_t, Char>::Unsupported);
+    void operator<<(
+        typename internal::WCharHelper<const wchar_t *, Char>::Unsupported);
 
-  template <typename Impl, typename Char_, typename Spec_>
-  friend class internal::ArgFormatterBase;
+    // Appends floating-point length specifier to the format string.
+    // The second argument is only used for overload resolution.
+    void append_float_length(Char *&format_ptr, long double)
+    {
+        *format_ptr++ = 'L';
+    }
 
-  template <typename Impl, typename Char_, typename Spec_>
-  friend class BasicPrintfArgFormatter;
+    template<typename T>
+    void append_float_length(Char *&, T) {}
 
- protected:
-  /**
-    Constructs a ``BasicWriter`` object.
-   */
-  explicit BasicWriter(Buffer<Char> &b) : buffer_(b) {}
+    template <typename Impl, typename Char_, typename Spec_>
+    friend class internal::ArgFormatterBase;
 
- public:
-  /**
-    \rst
-    Destroys a ``BasicWriter`` object.
-    \endrst
-   */
-  virtual ~BasicWriter() {}
+    template <typename Impl, typename Char_, typename Spec_>
+    friend class BasicPrintfArgFormatter;
 
-  /**
-    Returns the total number of characters written.
-   */
-  std::size_t size() const { return buffer_.size(); }
+protected:
+    /**
+      Constructs a ``BasicWriter`` object.
+     */
+    explicit BasicWriter(Buffer<Char> &b) : buffer_(b) {}
 
-  /**
-    Returns a pointer to the output buffer content. No terminating null
-    character is appended.
-   */
-  const Char *data() const FMT_NOEXCEPT { return &buffer_[0]; }
+public:
+    /**
+      \rst
+      Destroys a ``BasicWriter`` object.
+      \endrst
+     */
+    virtual ~BasicWriter() {}
 
-  /**
-    Returns a pointer to the output buffer content with terminating null
-    character appended.
-   */
-  const Char *c_str() const {
-    std::size_t size = buffer_.size();
-    buffer_.reserve(size + 1);
-    buffer_[size] = '\0';
-    return &buffer_[0];
-  }
+    /**
+      Returns the total number of characters written.
+     */
+    std::size_t size() const
+    {
+        return buffer_.size();
+    }
 
-  /**
-    \rst
-    Returns the content of the output buffer as an `std::string`.
-    \endrst
-   */
-  std::basic_string<Char> str() const {
-    return std::basic_string<Char>(&buffer_[0], buffer_.size());
-  }
+    /**
+      Returns a pointer to the output buffer content. No terminating null
+      character is appended.
+     */
+    const Char *data() const FMT_NOEXCEPT
+    {
+        return &buffer_[0];
+    }
 
-  /**
-    \rst
-    Writes formatted data.
+    /**
+      Returns a pointer to the output buffer content with terminating null
+      character appended.
+     */
+    const Char *c_str() const
+    {
+        std::size_t size = buffer_.size();
+        buffer_.reserve(size + 1);
+        buffer_[size] = '\0';
+        return &buffer_[0];
+    }
 
-    *args* is an argument list representing arbitrary arguments.
+    /**
+      \rst
+      Returns the content of the output buffer as an `std::string`.
+      \endrst
+     */
+    std::basic_string<Char> str() const
+    {
+        return std::basic_string<Char>(&buffer_[0], buffer_.size());
+    }
 
-    **Example**::
+    /**
+      \rst
+      Writes formatted data.
 
-       MemoryWriter out;
-       out.write("Current point:\n");
-       out.write("({:+f}, {:+f})", -3.14, 3.14);
+      *args* is an argument list representing arbitrary arguments.
 
-    This will write the following output to the ``out`` object:
+      **Example**::
 
-    .. code-block:: none
+         MemoryWriter out;
+         out.write("Current point:\n");
+         out.write("({:+f}, {:+f})", -3.14, 3.14);
 
-       Current point:
-       (-3.140000, +3.140000)
+      This will write the following output to the ``out`` object:
 
-    The output can be accessed using :func:`data()`, :func:`c_str` or
-    :func:`str` methods.
+      .. code-block:: none
 
-    See also :ref:`syntax`.
-    \endrst
-   */
-  void write(BasicCStringRef<Char> format, ArgList args) {
-    BasicFormatter<Char>(args, *this).format(format);
-  }
-  FMT_VARIADIC_VOID(write, BasicCStringRef<Char>)
+         Current point:
+         (-3.140000, +3.140000)
 
-  BasicWriter &operator<<(int value) {
-    write_decimal(value);
-    return *this;
-  }
-  BasicWriter &operator<<(unsigned value) {
-    return *this << IntFormatSpec<unsigned>(value);
-  }
-  BasicWriter &operator<<(long value) {
-    write_decimal(value);
-    return *this;
-  }
-  BasicWriter &operator<<(unsigned long value) {
-    return *this << IntFormatSpec<unsigned long>(value);
-  }
-  BasicWriter &operator<<(LongLong value) {
-    write_decimal(value);
-    return *this;
-  }
+      The output can be accessed using :func:`data()`, :func:`c_str` or
+      :func:`str` methods.
 
-  /**
-    \rst
-    Formats *value* and writes it to the stream.
-    \endrst
-   */
-  BasicWriter &operator<<(ULongLong value) {
-    return *this << IntFormatSpec<ULongLong>(value);
-  }
+      See also :ref:`syntax`.
+      \endrst
+     */
+    void write(BasicCStringRef<Char> format, ArgList args)
+    {
+        BasicFormatter<Char>(args, *this).format(format);
+    }
+    FMT_VARIADIC_VOID(write, BasicCStringRef<Char>)
 
-  BasicWriter &operator<<(double value) {
-    write_double(value, FormatSpec());
-    return *this;
-  }
+    BasicWriter &operator<<(int value)
+    {
+        write_decimal(value);
+        return *this;
+    }
+    BasicWriter &operator<<(unsigned value)
+    {
+        return *this << IntFormatSpec<unsigned>(value);
+    }
+    BasicWriter &operator<<(long value)
+    {
+        write_decimal(value);
+        return *this;
+    }
+    BasicWriter &operator<<(unsigned long value)
+    {
+        return *this << IntFormatSpec<unsigned long>(value);
+    }
+    BasicWriter &operator<<(LongLong value)
+    {
+        write_decimal(value);
+        return *this;
+    }
 
-  /**
-    \rst
-    Formats *value* using the general format for floating-point numbers
-    (``'g'``) and writes it to the stream.
-    \endrst
-   */
-  BasicWriter &operator<<(long double value) {
-    write_double(value, FormatSpec());
-    return *this;
-  }
+    /**
+      \rst
+      Formats *value* and writes it to the stream.
+      \endrst
+     */
+    BasicWriter &operator<<(ULongLong value)
+    {
+        return *this << IntFormatSpec<ULongLong>(value);
+    }
 
-  /**
-    Writes a character to the stream.
-   */
-  BasicWriter &operator<<(char value) {
-    buffer_.push_back(value);
-    return *this;
-  }
+    BasicWriter &operator<<(double value)
+    {
+        write_double(value, FormatSpec());
+        return *this;
+    }
 
-  BasicWriter &operator<<(
-      typename internal::WCharHelper<wchar_t, Char>::Supported value) {
-    buffer_.push_back(value);
-    return *this;
-  }
+    /**
+      \rst
+      Formats *value* using the general format for floating-point numbers
+      (``'g'``) and writes it to the stream.
+      \endrst
+     */
+    BasicWriter &operator<<(long double value)
+    {
+        write_double(value, FormatSpec());
+        return *this;
+    }
 
-  /**
-    \rst
-    Writes *value* to the stream.
-    \endrst
-   */
-  BasicWriter &operator<<(fmt::BasicStringRef<Char> value) {
-    const Char *str = value.data();
-    buffer_.append(str, str + value.size());
-    return *this;
-  }
+    /**
+      Writes a character to the stream.
+     */
+    BasicWriter &operator<<(char value)
+    {
+        buffer_.push_back(value);
+        return *this;
+    }
 
-  BasicWriter &operator<<(
-      typename internal::WCharHelper<StringRef, Char>::Supported value) {
-    const char *str = value.data();
-    buffer_.append(str, str + value.size());
-    return *this;
-  }
+    BasicWriter &operator<<(
+        typename internal::WCharHelper<wchar_t, Char>::Supported value)
+    {
+        buffer_.push_back(value);
+        return *this;
+    }
 
-  template <typename T, typename Spec, typename FillChar>
-  BasicWriter &operator<<(IntFormatSpec<T, Spec, FillChar> spec) {
-    internal::CharTraits<Char>::convert(FillChar());
-    write_int(spec.value(), spec);
-    return *this;
-  }
+    /**
+      \rst
+      Writes *value* to the stream.
+      \endrst
+     */
+    BasicWriter &operator<<(fmt::BasicStringRef<Char> value)
+    {
+        const Char *str = value.data();
+        buffer_.append(str, str + value.size());
+        return *this;
+    }
 
-  template <typename StrChar>
-  BasicWriter &operator<<(const StrFormatSpec<StrChar> &spec) {
-    const StrChar *s = spec.str();
-    write_str(s, std::char_traits<Char>::length(s), spec);
-    return *this;
-  }
+    BasicWriter &operator<<(
+        typename internal::WCharHelper<StringRef, Char>::Supported value)
+    {
+        const char *str = value.data();
+        buffer_.append(str, str + value.size());
+        return *this;
+    }
 
-  void clear() FMT_NOEXCEPT { buffer_.clear(); }
+    template <typename T, typename Spec, typename FillChar>
+    BasicWriter &operator<<(IntFormatSpec<T, Spec, FillChar> spec)
+    {
+        internal::CharTraits<Char>::convert(FillChar());
+        write_int(spec.value(), spec);
+        return *this;
+    }
 
-  Buffer<Char> &buffer() FMT_NOEXCEPT { return buffer_; }
+    template <typename StrChar>
+    BasicWriter &operator<<(const StrFormatSpec<StrChar> &spec)
+    {
+        const StrChar *s = spec.str();
+        write_str(s, std::char_traits<Char>::length(s), spec);
+        return *this;
+    }
+
+    void clear() FMT_NOEXCEPT { buffer_.clear(); }
+
+    Buffer<Char> &buffer() FMT_NOEXCEPT { return buffer_; }
 };
 
 template <typename Char>
 template <typename StrChar>
 typename BasicWriter<Char>::CharPtr BasicWriter<Char>::write_str(
-      const StrChar *s, std::size_t size, const AlignSpec &spec) {
-  CharPtr out = CharPtr();
-  if (spec.width() > size) {
-    out = grow_buffer(spec.width());
-    Char fill = internal::CharTraits<Char>::cast(spec.fill());
-    if (spec.align() == ALIGN_RIGHT) {
-      std::uninitialized_fill_n(out, spec.width() - size, fill);
-      out += spec.width() - size;
-    } else if (spec.align() == ALIGN_CENTER) {
-      out = fill_padding(out, spec.width(), size, fill);
-    } else {
-      std::uninitialized_fill_n(out + size, spec.width() - size, fill);
+    const StrChar *s, std::size_t size, const AlignSpec &spec)
+{
+    CharPtr out = CharPtr();
+    if (spec.width() > size)
+    {
+        out = grow_buffer(spec.width());
+        Char fill = internal::CharTraits<Char>::cast(spec.fill());
+        if (spec.align() == ALIGN_RIGHT)
+        {
+            std::uninitialized_fill_n(out, spec.width() - size, fill);
+            out += spec.width() - size;
+        }
+        else if (spec.align() == ALIGN_CENTER)
+        {
+            out = fill_padding(out, spec.width(), size, fill);
+        }
+        else
+        {
+            std::uninitialized_fill_n(out + size, spec.width() - size, fill);
+        }
     }
-  } else {
-    out = grow_buffer(size);
-  }
-  std::uninitialized_copy(s, s + size, out);
-  return out;
+    else
+    {
+        out = grow_buffer(size);
+    }
+    std::uninitialized_copy(s, s + size, out);
+    return out;
 }
 
 template <typename Char>
 template <typename StrChar, typename Spec>
 void BasicWriter<Char>::write_str(
-    const internal::Arg::StringValue<StrChar> &s, const Spec &spec) {
-  // Check if StrChar is convertible to Char.
-  internal::CharTraits<Char>::convert(StrChar());
-  if (spec.type_ && spec.type_ != 's')
-    internal::report_unknown_type(spec.type_, "string");
-  const StrChar *str_value = s.value;
-  std::size_t str_size = s.size;
-  if (str_size == 0) {
-    if (!str_value) {
-      FMT_THROW(FormatError("string pointer is null"));
+    const internal::Arg::StringValue<StrChar> &s, const Spec &spec)
+{
+    // Check if StrChar is convertible to Char.
+    internal::CharTraits<Char>::convert(StrChar());
+    if (spec.type_ && spec.type_ != 's')
+        internal::report_unknown_type(spec.type_, "string");
+    const StrChar *str_value = s.value;
+    std::size_t str_size = s.size;
+    if (str_size == 0)
+    {
+        if (!str_value)
+        {
+            FMT_THROW(FormatError("string pointer is null"));
+        }
     }
-  }
-  std::size_t precision = static_cast<std::size_t>(spec.precision_);
-  if (spec.precision_ >= 0 && precision < str_size)
-    str_size = precision;
-  write_str(str_value, str_size, spec);
+    std::size_t precision = static_cast<std::size_t>(spec.precision_);
+    if (spec.precision_ >= 0 && precision < str_size)
+        str_size = precision;
+    write_str(str_value, str_size, spec);
 }
 
 template <typename Char>
 typename BasicWriter<Char>::CharPtr
-  BasicWriter<Char>::fill_padding(
+BasicWriter<Char>::fill_padding(
     CharPtr buffer, unsigned total_size,
-    std::size_t content_size, wchar_t fill) {
-  std::size_t padding = total_size - content_size;
-  std::size_t left_padding = padding / 2;
-  Char fill_char = internal::CharTraits<Char>::cast(fill);
-  std::uninitialized_fill_n(buffer, left_padding, fill_char);
-  buffer += left_padding;
-  CharPtr content = buffer;
-  std::uninitialized_fill_n(buffer + content_size,
-                            padding - left_padding, fill_char);
-  return content;
+    std::size_t content_size, wchar_t fill)
+{
+    std::size_t padding = total_size - content_size;
+    std::size_t left_padding = padding / 2;
+    Char fill_char = internal::CharTraits<Char>::cast(fill);
+    std::uninitialized_fill_n(buffer, left_padding, fill_char);
+    buffer += left_padding;
+    CharPtr content = buffer;
+    std::uninitialized_fill_n(buffer + content_size,
+                              padding - left_padding, fill_char);
+    return content;
 }
 
 template <typename Char>
 template <typename Spec>
 typename BasicWriter<Char>::CharPtr
-  BasicWriter<Char>::prepare_int_buffer(
+BasicWriter<Char>::prepare_int_buffer(
     unsigned num_digits, const Spec &spec,
-    const char *prefix, unsigned prefix_size) {
-  unsigned width = spec.width();
-  Alignment align = spec.align();
-  Char fill = internal::CharTraits<Char>::cast(spec.fill());
-  if (spec.precision() > static_cast<int>(num_digits)) {
-    // Octal prefix '0' is counted as a digit, so ignore it if precision
-    // is specified.
-    if (prefix_size > 0 && prefix[prefix_size - 1] == '0')
-      --prefix_size;
-    unsigned number_size =
-        prefix_size + internal::to_unsigned(spec.precision());
-    AlignSpec subspec(number_size, '0', ALIGN_NUMERIC);
-    if (number_size >= width)
-      return prepare_int_buffer(num_digits, subspec, prefix, prefix_size);
-    buffer_.reserve(width);
-    unsigned fill_size = width - number_size;
-    if (align != ALIGN_LEFT) {
-      CharPtr p = grow_buffer(fill_size);
-      std::uninitialized_fill(p, p + fill_size, fill);
+    const char *prefix, unsigned prefix_size)
+{
+    unsigned width = spec.width();
+    Alignment align = spec.align();
+    Char fill = internal::CharTraits<Char>::cast(spec.fill());
+    if (spec.precision() > static_cast<int>(num_digits))
+    {
+        // Octal prefix '0' is counted as a digit, so ignore it if precision
+        // is specified.
+        if (prefix_size > 0 && prefix[prefix_size - 1] == '0')
+            --prefix_size;
+        unsigned number_size =
+            prefix_size + internal::to_unsigned(spec.precision());
+        AlignSpec subspec(number_size, '0', ALIGN_NUMERIC);
+        if (number_size >= width)
+            return prepare_int_buffer(num_digits, subspec, prefix, prefix_size);
+        buffer_.reserve(width);
+        unsigned fill_size = width - number_size;
+        if (align != ALIGN_LEFT)
+        {
+            CharPtr p = grow_buffer(fill_size);
+            std::uninitialized_fill(p, p + fill_size, fill);
+        }
+        CharPtr result = prepare_int_buffer(
+                             num_digits, subspec, prefix, prefix_size);
+        if (align == ALIGN_LEFT)
+        {
+            CharPtr p = grow_buffer(fill_size);
+            std::uninitialized_fill(p, p + fill_size, fill);
+        }
+        return result;
     }
-    CharPtr result = prepare_int_buffer(
-        num_digits, subspec, prefix, prefix_size);
-    if (align == ALIGN_LEFT) {
-      CharPtr p = grow_buffer(fill_size);
-      std::uninitialized_fill(p, p + fill_size, fill);
+    unsigned size = prefix_size + num_digits;
+    if (width <= size)
+    {
+        CharPtr p = grow_buffer(size);
+        std::uninitialized_copy(prefix, prefix + prefix_size, p);
+        return p + size - 1;
     }
-    return result;
-  }
-  unsigned size = prefix_size + num_digits;
-  if (width <= size) {
-    CharPtr p = grow_buffer(size);
-    std::uninitialized_copy(prefix, prefix + prefix_size, p);
-    return p + size - 1;
-  }
-  CharPtr p = grow_buffer(width);
-  CharPtr end = p + width;
-  if (align == ALIGN_LEFT) {
-    std::uninitialized_copy(prefix, prefix + prefix_size, p);
-    p += size;
-    std::uninitialized_fill(p, end, fill);
-  } else if (align == ALIGN_CENTER) {
-    p = fill_padding(p, width, size, fill);
-    std::uninitialized_copy(prefix, prefix + prefix_size, p);
-    p += size;
-  } else {
-    if (align == ALIGN_NUMERIC) {
-      if (prefix_size != 0) {
-        p = std::uninitialized_copy(prefix, prefix + prefix_size, p);
-        size -= prefix_size;
-      }
-    } else {
-      std::uninitialized_copy(prefix, prefix + prefix_size, end - size);
+    CharPtr p = grow_buffer(width);
+    CharPtr end = p + width;
+    if (align == ALIGN_LEFT)
+    {
+        std::uninitialized_copy(prefix, prefix + prefix_size, p);
+        p += size;
+        std::uninitialized_fill(p, end, fill);
     }
-    std::uninitialized_fill(p, end - size, fill);
-    p = end;
-  }
-  return p - 1;
+    else if (align == ALIGN_CENTER)
+    {
+        p = fill_padding(p, width, size, fill);
+        std::uninitialized_copy(prefix, prefix + prefix_size, p);
+        p += size;
+    }
+    else
+    {
+        if (align == ALIGN_NUMERIC)
+        {
+            if (prefix_size != 0)
+            {
+                p = std::uninitialized_copy(prefix, prefix + prefix_size, p);
+                size -= prefix_size;
+            }
+        }
+        else
+        {
+            std::uninitialized_copy(prefix, prefix + prefix_size, end - size);
+        }
+        std::uninitialized_fill(p, end - size, fill);
+        p = end;
+    }
+    return p - 1;
 }
 
 template <typename Char>
 template <typename T, typename Spec>
-void BasicWriter<Char>::write_int(T value, Spec spec) {
-  unsigned prefix_size = 0;
-  typedef typename internal::IntTraits<T>::MainType UnsignedType;
-  UnsignedType abs_value = static_cast<UnsignedType>(value);
-  char prefix[4] = "";
-  if (internal::is_negative(value)) {
-    prefix[0] = '-';
-    ++prefix_size;
-    abs_value = 0 - abs_value;
-  } else if (spec.flag(SIGN_FLAG)) {
-    prefix[0] = spec.flag(PLUS_FLAG) ? '+' : ' ';
-    ++prefix_size;
-  }
-  switch (spec.type()) {
-  case 0: case 'd': {
-    unsigned num_digits = internal::count_digits(abs_value);
-    CharPtr p = prepare_int_buffer(num_digits, spec, prefix, prefix_size) + 1;
-    internal::format_decimal(get(p), abs_value, 0);
-    break;
-  }
-  case 'x': case 'X': {
-    UnsignedType n = abs_value;
-    if (spec.flag(HASH_FLAG)) {
-      prefix[prefix_size++] = '0';
-      prefix[prefix_size++] = spec.type_prefix();
+void BasicWriter<Char>::write_int(T value, Spec spec)
+{
+    unsigned prefix_size = 0;
+    typedef typename internal::IntTraits<T>::MainType UnsignedType;
+    UnsignedType abs_value = static_cast<UnsignedType>(value);
+    char prefix[4] = "";
+    if (internal::is_negative(value))
+    {
+        prefix[0] = '-';
+        ++prefix_size;
+        abs_value = 0 - abs_value;
     }
-    unsigned num_digits = 0;
-    do {
-      ++num_digits;
-    } while ((n >>= 4) != 0);
-    Char *p = get(prepare_int_buffer(
-      num_digits, spec, prefix, prefix_size));
-    n = abs_value;
-    const char *digits = spec.type() == 'x' ?
-        "0123456789abcdef" : "0123456789ABCDEF";
-    do {
-      *p-- = digits[n & 0xf];
-    } while ((n >>= 4) != 0);
-    break;
-  }
-  case 'b': case 'B': {
-    UnsignedType n = abs_value;
-    if (spec.flag(HASH_FLAG)) {
-      prefix[prefix_size++] = '0';
-      prefix[prefix_size++] = spec.type_prefix();
+    else if (spec.flag(SIGN_FLAG))
+    {
+        prefix[0] = spec.flag(PLUS_FLAG) ? '+' : ' ';
+        ++prefix_size;
     }
-    unsigned num_digits = 0;
-    do {
-      ++num_digits;
-    } while ((n >>= 1) != 0);
-    Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size));
-    n = abs_value;
-    do {
-      *p-- = static_cast<Char>('0' + (n & 1));
-    } while ((n >>= 1) != 0);
-    break;
-  }
-  case 'o': {
-    UnsignedType n = abs_value;
-    if (spec.flag(HASH_FLAG))
-      prefix[prefix_size++] = '0';
-    unsigned num_digits = 0;
-    do {
-      ++num_digits;
-    } while ((n >>= 3) != 0);
-    Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size));
-    n = abs_value;
-    do {
-      *p-- = static_cast<Char>('0' + (n & 7));
-    } while ((n >>= 3) != 0);
-    break;
-  }
-  case 'n': {
-    unsigned num_digits = internal::count_digits(abs_value);
-    fmt::StringRef sep = "";
+    switch (spec.type())
+    {
+    case 0:
+    case 'd':
+    {
+        unsigned num_digits = internal::count_digits(abs_value);
+        CharPtr p = prepare_int_buffer(num_digits, spec, prefix, prefix_size) + 1;
+        internal::format_decimal(get(p), abs_value, 0);
+        break;
+    }
+    case 'x':
+    case 'X':
+    {
+        UnsignedType n = abs_value;
+        if (spec.flag(HASH_FLAG))
+        {
+            prefix[prefix_size++] = '0';
+            prefix[prefix_size++] = spec.type_prefix();
+        }
+        unsigned num_digits = 0;
+        do
+        {
+            ++num_digits;
+        }
+        while ((n >>= 4) != 0);
+        Char *p = get(prepare_int_buffer(
+                          num_digits, spec, prefix, prefix_size));
+        n = abs_value;
+        const char *digits = spec.type() == 'x' ?
+                             "0123456789abcdef" : "0123456789ABCDEF";
+        do
+        {
+            *p-- = digits[n & 0xf];
+        }
+        while ((n >>= 4) != 0);
+        break;
+    }
+    case 'b':
+    case 'B':
+    {
+        UnsignedType n = abs_value;
+        if (spec.flag(HASH_FLAG))
+        {
+            prefix[prefix_size++] = '0';
+            prefix[prefix_size++] = spec.type_prefix();
+        }
+        unsigned num_digits = 0;
+        do
+        {
+            ++num_digits;
+        }
+        while ((n >>= 1) != 0);
+        Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size));
+        n = abs_value;
+        do
+        {
+            *p-- = static_cast<Char>('0' + (n & 1));
+        }
+        while ((n >>= 1) != 0);
+        break;
+    }
+    case 'o':
+    {
+        UnsignedType n = abs_value;
+        if (spec.flag(HASH_FLAG))
+            prefix[prefix_size++] = '0';
+        unsigned num_digits = 0;
+        do
+        {
+            ++num_digits;
+        }
+        while ((n >>= 3) != 0);
+        Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size));
+        n = abs_value;
+        do
+        {
+            *p-- = static_cast<Char>('0' + (n & 7));
+        }
+        while ((n >>= 3) != 0);
+        break;
+    }
+    case 'n':
+    {
+        unsigned num_digits = internal::count_digits(abs_value);
+        fmt::StringRef sep = "";
 #if !(defined(ANDROID) || defined(__ANDROID__))
-    sep = internal::thousands_sep(std::localeconv());
+        sep = internal::thousands_sep(std::localeconv());
 #endif
-    unsigned size = static_cast<unsigned>(
-          num_digits + sep.size() * ((num_digits - 1) / 3));
-    CharPtr p = prepare_int_buffer(size, spec, prefix, prefix_size) + 1;
-    internal::format_decimal(get(p), abs_value, 0, internal::ThousandsSep(sep));
-    break;
-  }
-  default:
-    internal::report_unknown_type(
-      spec.type(), spec.flag(CHAR_FLAG) ? "char" : "integer");
-    break;
-  }
+        unsigned size = static_cast<unsigned>(
+                            num_digits + sep.size() * ((num_digits - 1) / 3));
+        CharPtr p = prepare_int_buffer(size, spec, prefix, prefix_size) + 1;
+        internal::format_decimal(get(p), abs_value, 0, internal::ThousandsSep(sep));
+        break;
+    }
+    default:
+        internal::report_unknown_type(
+            spec.type(), spec.flag(CHAR_FLAG) ? "char" : "integer");
+        break;
+    }
 }
 
 template <typename Char>
 template <typename T, typename Spec>
-void BasicWriter<Char>::write_double(T value, const Spec &spec) {
-  // Check type.
-  char type = spec.type();
-  bool upper = false;
-  switch (type) {
-  case 0:
-    type = 'g';
-    break;
-  case 'e': case 'f': case 'g': case 'a':
-    break;
-  case 'F':
+void BasicWriter<Char>::write_double(T value, const Spec &spec)
+{
+    // Check type.
+    char type = spec.type();
+    bool upper = false;
+    switch (type)
+    {
+    case 0:
+        type = 'g';
+        break;
+    case 'e':
+    case 'f':
+    case 'g':
+    case 'a':
+        break;
+    case 'F':
 #if FMT_MSC_VER
-    // MSVC's printf doesn't support 'F'.
-    type = 'f';
+        // MSVC's printf doesn't support 'F'.
+        type = 'f';
 #endif
     // Fall through.
-  case 'E': case 'G': case 'A':
-    upper = true;
-    break;
-  default:
-    internal::report_unknown_type(type, "double");
-    break;
-  }
-
-  char sign = 0;
-  // Use isnegative instead of value < 0 because the latter is always
-  // false for NaN.
-  if (internal::FPUtil::isnegative(static_cast<double>(value))) {
-    sign = '-';
-    value = -value;
-  } else if (spec.flag(SIGN_FLAG)) {
-    sign = spec.flag(PLUS_FLAG) ? '+' : ' ';
-  }
-
-  if (internal::FPUtil::isnotanumber(value)) {
-    // Format NaN ourselves because sprintf's output is not consistent
-    // across platforms.
-    std::size_t nan_size = 4;
-    const char *nan = upper ? " NAN" : " nan";
-    if (!sign) {
-      --nan_size;
-      ++nan;
+    case 'E':
+    case 'G':
+    case 'A':
+        upper = true;
+        break;
+    default:
+        internal::report_unknown_type(type, "double");
+        break;
     }
-    CharPtr out = write_str(nan, nan_size, spec);
-    if (sign)
-      *out = sign;
-    return;
-  }
 
-  if (internal::FPUtil::isinfinity(value)) {
-    // Format infinity ourselves because sprintf's output is not consistent
-    // across platforms.
-    std::size_t inf_size = 4;
-    const char *inf = upper ? " INF" : " inf";
-    if (!sign) {
-      --inf_size;
-      ++inf;
+    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;
     }
-    CharPtr out = write_str(inf, inf_size, spec);
+    else if (spec.flag(SIGN_FLAG))
+    {
+        sign = spec.flag(PLUS_FLAG) ? '+' : ' ';
+    }
+
+    if (internal::FPUtil::isnotanumber(value))
+    {
+        // Format NaN ourselves because sprintf's output is not consistent
+        // across platforms.
+        std::size_t nan_size = 4;
+        const char *nan = upper ? " NAN" : " nan";
+        if (!sign)
+        {
+            --nan_size;
+            ++nan;
+        }
+        CharPtr out = write_str(nan, nan_size, spec);
+        if (sign)
+            *out = sign;
+        return;
+    }
+
+    if (internal::FPUtil::isinfinity(value))
+    {
+        // Format infinity ourselves because sprintf's output is not consistent
+        // across platforms.
+        std::size_t inf_size = 4;
+        const char *inf = upper ? " INF" : " inf";
+        if (!sign)
+        {
+            --inf_size;
+            ++inf;
+        }
+        CharPtr out = write_str(inf, inf_size, spec);
+        if (sign)
+            *out = sign;
+        return;
+    }
+
+    std::size_t offset = buffer_.size();
+    unsigned width = spec.width();
     if (sign)
-      *out = sign;
-    return;
-  }
+    {
+        buffer_.reserve(buffer_.size() + (width > 1u ? width : 1u));
+        if (width > 0)
+            --width;
+        ++offset;
+    }
 
-  std::size_t offset = buffer_.size();
-  unsigned width = spec.width();
-  if (sign) {
-    buffer_.reserve(buffer_.size() + (width > 1u ? width : 1u));
-    if (width > 0)
-      --width;
-    ++offset;
-  }
+    // Build format string.
+    enum { MAX_FORMAT_SIZE = 10}; // longest format: %#-*.*Lg
+    Char format[MAX_FORMAT_SIZE];
+    Char *format_ptr = format;
+    *format_ptr++ = '%';
+    unsigned width_for_sprintf = width;
+    if (spec.flag(HASH_FLAG))
+        *format_ptr++ = '#';
+    if (spec.align() == ALIGN_CENTER)
+    {
+        width_for_sprintf = 0;
+    }
+    else
+    {
+        if (spec.align() == ALIGN_LEFT)
+            *format_ptr++ = '-';
+        if (width != 0)
+            *format_ptr++ = '*';
+    }
+    if (spec.precision() >= 0)
+    {
+        *format_ptr++ = '.';
+        *format_ptr++ = '*';
+    }
 
-  // Build format string.
-  enum { MAX_FORMAT_SIZE = 10}; // longest format: %#-*.*Lg
-  Char format[MAX_FORMAT_SIZE];
-  Char *format_ptr = format;
-  *format_ptr++ = '%';
-  unsigned width_for_sprintf = width;
-  if (spec.flag(HASH_FLAG))
-    *format_ptr++ = '#';
-  if (spec.align() == ALIGN_CENTER) {
-    width_for_sprintf = 0;
-  } else {
-    if (spec.align() == ALIGN_LEFT)
-      *format_ptr++ = '-';
-    if (width != 0)
-      *format_ptr++ = '*';
-  }
-  if (spec.precision() >= 0) {
-    *format_ptr++ = '.';
-    *format_ptr++ = '*';
-  }
+    append_float_length(format_ptr, value);
+    *format_ptr++ = type;
+    *format_ptr = '\0';
 
-  append_float_length(format_ptr, value);
-  *format_ptr++ = type;
-  *format_ptr = '\0';
-
-  // Format using snprintf.
-  Char fill = internal::CharTraits<Char>::cast(spec.fill());
-  unsigned n = 0;
-  Char *start = FMT_NULL;
-  for (;;) {
-    std::size_t buffer_size = buffer_.capacity() - offset;
+    // Format using snprintf.
+    Char fill = internal::CharTraits<Char>::cast(spec.fill());
+    unsigned n = 0;
+    Char *start = FMT_NULL;
+    for (;;)
+    {
+        std::size_t buffer_size = buffer_.capacity() - offset;
 #if FMT_MSC_VER
-    // MSVC's vsnprintf_s doesn't work with zero size, so reserve
-    // space for at least one extra character to make the size non-zero.
-    // Note that the buffer's capacity will increase by more than 1.
-    if (buffer_size == 0) {
-      buffer_.reserve(offset + 1);
-      buffer_size = buffer_.capacity() - offset;
-    }
+        // MSVC's vsnprintf_s doesn't work with zero size, so reserve
+        // space for at least one extra character to make the size non-zero.
+        // Note that the buffer's capacity will increase by more than 1.
+        if (buffer_size == 0)
+        {
+            buffer_.reserve(offset + 1);
+            buffer_size = buffer_.capacity() - offset;
+        }
 #endif
-    start = &buffer_[offset];
-    int result = internal::CharTraits<Char>::format_float(
-        start, buffer_size, format, width_for_sprintf, spec.precision(), value);
-    if (result >= 0) {
-      n = internal::to_unsigned(result);
-      if (offset + n < buffer_.capacity())
-        break;  // The buffer is large enough - continue with formatting.
-      buffer_.reserve(offset + n + 1);
-    } else {
-      // If result is negative we ask to increase the capacity by at least 1,
-      // but as std::vector, the buffer grows exponentially.
-      buffer_.reserve(buffer_.capacity() + 1);
+        start = &buffer_[offset];
+        int result = internal::CharTraits<Char>::format_float(
+                         start, buffer_size, format, width_for_sprintf, spec.precision(), value);
+        if (result >= 0)
+        {
+            n = internal::to_unsigned(result);
+            if (offset + n < buffer_.capacity())
+                break;  // The buffer is large enough - continue with formatting.
+            buffer_.reserve(offset + n + 1);
+        }
+        else
+        {
+            // If result is negative we ask to increase the capacity by at least 1,
+            // but as std::vector, the buffer grows exponentially.
+            buffer_.reserve(buffer_.capacity() + 1);
+        }
     }
-  }
-  if (sign) {
-    if ((spec.align() != ALIGN_RIGHT && spec.align() != ALIGN_DEFAULT) ||
-        *start != ' ') {
-      *(start - 1) = sign;
-      sign = 0;
-    } else {
-      *(start - 1) = fill;
-    }
-    ++n;
-  }
-  if (spec.align() == ALIGN_CENTER && spec.width() > n) {
-    width = spec.width();
-    CharPtr p = grow_buffer(width);
-    std::memmove(get(p) + (width - n) / 2, get(p), n * sizeof(Char));
-    fill_padding(p, spec.width(), n, fill);
-    return;
-  }
-  if (spec.fill() != ' ' || sign) {
-    while (*start == ' ')
-      *start++ = fill;
     if (sign)
-      *(start - 1) = sign;
-  }
-  grow_buffer(n);
+    {
+        if ((spec.align() != ALIGN_RIGHT && spec.align() != ALIGN_DEFAULT) ||
+                *start != ' ')
+        {
+            *(start - 1) = sign;
+            sign = 0;
+        }
+        else
+        {
+            *(start - 1) = fill;
+        }
+        ++n;
+    }
+    if (spec.align() == ALIGN_CENTER && spec.width() > n)
+    {
+        width = spec.width();
+        CharPtr p = grow_buffer(width);
+        std::memmove(get(p) + (width - n) / 2, get(p), n * sizeof(Char));
+        fill_padding(p, spec.width(), n, fill);
+        return;
+    }
+    if (spec.fill() != ' ' || sign)
+    {
+        while (*start == ' ')
+            *start++ = fill;
+        if (sign)
+            *(start - 1) = sign;
+    }
+    grow_buffer(n);
 }
 
 /**
@@ -3133,34 +3671,37 @@ void BasicWriter<Char>::write_double(T value, const Spec &spec) {
   \endrst
  */
 template <typename Char, typename Allocator = std::allocator<Char> >
-class BasicMemoryWriter : public BasicWriter<Char> {
- private:
-  internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE, Allocator> buffer_;
+class BasicMemoryWriter : public BasicWriter<Char>
+{
+private:
+    internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE, Allocator> buffer_;
 
- public:
-  explicit BasicMemoryWriter(const Allocator& alloc = Allocator())
-    : BasicWriter<Char>(buffer_), buffer_(alloc) {}
+public:
+    explicit BasicMemoryWriter(const Allocator& alloc = Allocator())
+        : BasicWriter<Char>(buffer_), buffer_(alloc) {}
 
 #if FMT_USE_RVALUE_REFERENCES
-  /**
-    \rst
-    Constructs a :class:`fmt::BasicMemoryWriter` object moving the content
-    of the other object to it.
-    \endrst
-   */
-  BasicMemoryWriter(BasicMemoryWriter &&other)
-    : BasicWriter<Char>(buffer_), buffer_(std::move(other.buffer_)) {
-  }
+    /**
+      \rst
+      Constructs a :class:`fmt::BasicMemoryWriter` object moving the content
+      of the other object to it.
+      \endrst
+     */
+    BasicMemoryWriter(BasicMemoryWriter &&other)
+        : BasicWriter<Char>(buffer_), buffer_(std::move(other.buffer_))
+    {
+    }
 
-  /**
-    \rst
-    Moves the content of the other ``BasicMemoryWriter`` object to this one.
-    \endrst
-   */
-  BasicMemoryWriter &operator=(BasicMemoryWriter &&other) {
-    buffer_ = std::move(other.buffer_);
-    return *this;
-  }
+    /**
+      \rst
+      Moves the content of the other ``BasicMemoryWriter`` object to this one.
+      \endrst
+     */
+    BasicMemoryWriter &operator=(BasicMemoryWriter &&other)
+    {
+        buffer_ = std::move(other.buffer_);
+        return *this;
+    }
 #endif
 };
 
@@ -3188,29 +3729,30 @@ typedef BasicMemoryWriter<wchar_t> WMemoryWriter;
   \endrst
  */
 template <typename Char>
-class BasicArrayWriter : public BasicWriter<Char> {
- private:
-  internal::FixedBuffer<Char> buffer_;
+class BasicArrayWriter : public BasicWriter<Char>
+{
+private:
+    internal::FixedBuffer<Char> buffer_;
 
- public:
-  /**
-   \rst
-   Constructs a :class:`fmt::BasicArrayWriter` object for *array* of the
-   given size.
-   \endrst
-   */
-  BasicArrayWriter(Char *array, std::size_t size)
-    : BasicWriter<Char>(buffer_), buffer_(array, size) {}
+public:
+    /**
+     \rst
+     Constructs a :class:`fmt::BasicArrayWriter` object for *array* of the
+     given size.
+     \endrst
+     */
+    BasicArrayWriter(Char *array, std::size_t size)
+        : BasicWriter<Char>(buffer_), buffer_(array, size) {}
 
-  /**
-   \rst
-   Constructs a :class:`fmt::BasicArrayWriter` object for *array* of the
-   size known at compile time.
-   \endrst
-   */
-  template <std::size_t SIZE>
-  explicit BasicArrayWriter(Char (&array)[SIZE])
-    : BasicWriter<Char>(buffer_), buffer_(array, SIZE) {}
+    /**
+     \rst
+     Constructs a :class:`fmt::BasicArrayWriter` object for *array* of the
+     size known at compile time.
+     \endrst
+     */
+    template <std::size_t SIZE>
+    explicit BasicArrayWriter(Char (&array)[SIZE])
+        : BasicWriter<Char>(buffer_), buffer_(array, SIZE) {}
 };
 
 typedef BasicArrayWriter<char> ArrayWriter;
@@ -3224,43 +3766,45 @@ FMT_API void report_system_error(int error_code,
 #if FMT_USE_WINDOWS_H
 
 /** A Windows error. */
-class WindowsError : public SystemError {
- private:
-  FMT_API void init(int error_code, CStringRef format_str, ArgList args);
+class WindowsError : public SystemError
+{
+private:
+    FMT_API void init(int error_code, CStringRef format_str, ArgList args);
 
- public:
-  /**
-   \rst
-   Constructs a :class:`fmt::WindowsError` object with the description
-   of the form
+public:
+    /**
+     \rst
+     Constructs a :class:`fmt::WindowsError` 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 WindowsError with the description
-     //   cannot open file 'madeup': The system cannot find the file specified.
-     // or similar (system message may vary).
-     const char *filename = "madeup";
-     LPOFSTRUCT of = LPOFSTRUCT();
-     HFILE file = OpenFile(filename, &of, OF_READ);
-     if (file == HFILE_ERROR) {
-       throw fmt::WindowsError(GetLastError(),
-                               "cannot open file '{}'", filename);
-     }
-   \endrst
-  */
-  WindowsError(int error_code, CStringRef message) {
-    init(error_code, message, ArgList());
-  }
-  FMT_VARIADIC_CTOR(WindowsError, init, int, CStringRef)
+       // This throws a WindowsError with the description
+       //   cannot open file 'madeup': The system cannot find the file specified.
+       // or similar (system message may vary).
+       const char *filename = "madeup";
+       LPOFSTRUCT of = LPOFSTRUCT();
+       HFILE file = OpenFile(filename, &of, OF_READ);
+       if (file == HFILE_ERROR) {
+         throw fmt::WindowsError(GetLastError(),
+                                 "cannot open file '{}'", filename);
+       }
+     \endrst
+    */
+    WindowsError(int error_code, CStringRef message)
+    {
+        init(error_code, message, ArgList());
+    }
+    FMT_VARIADIC_CTOR(WindowsError, init, int, CStringRef)
 };
 
 // Reports a Windows error without throwing an exception.
@@ -3289,16 +3833,18 @@ FMT_API void print_colored(Color c, CStringRef format, ArgList args);
     std::string message = format("The answer is {}", 42);
   \endrst
 */
-inline std::string format(CStringRef format_str, ArgList args) {
-  MemoryWriter w;
-  w.write(format_str, args);
-  return w.str();
+inline std::string format(CStringRef format_str, ArgList args)
+{
+    MemoryWriter w;
+    w.write(format_str, args);
+    return w.str();
 }
 
-inline std::wstring format(WCStringRef format_str, ArgList args) {
-  WMemoryWriter w;
-  w.write(format_str, args);
-  return w.str();
+inline std::wstring format(WCStringRef format_str, ArgList args)
+{
+    WMemoryWriter w;
+    w.write(format_str, args);
+    return w.str();
 }
 
 /**
@@ -3326,106 +3872,132 @@ FMT_API void print(CStringRef format_str, ArgList args);
 /**
   Fast integer formatter.
  */
-class FormatInt {
- private:
-  // Buffer should be large enough to hold all digits (digits10 + 1),
-  // a sign and a null character.
-  enum {BUFFER_SIZE = std::numeric_limits<ULongLong>::digits10 + 3};
-  mutable char buffer_[BUFFER_SIZE];
-  char *str_;
+class FormatInt
+{
+private:
+    // Buffer should be large enough to hold all digits (digits10 + 1),
+    // a sign and a null character.
+    enum {BUFFER_SIZE = std::numeric_limits<ULongLong>::digits10 + 3};
+    mutable char buffer_[BUFFER_SIZE];
+    char *str_;
 
-  // Formats value in reverse and returns the number of digits.
-  char *format_decimal(ULongLong value) {
-    char *buffer_end = buffer_ + BUFFER_SIZE - 1;
-    while (value >= 100) {
-      // Integer division is slow so do it for a group of two digits instead
-      // of for every digit. The idea comes from the talk by Alexandrescu
-      // "Three Optimization Tips for C++". See speed-test for a comparison.
-      unsigned index = static_cast<unsigned>((value % 100) * 2);
-      value /= 100;
-      *--buffer_end = internal::Data::DIGITS[index + 1];
-      *--buffer_end = internal::Data::DIGITS[index];
+    // Formats value in reverse and returns the number of digits.
+    char *format_decimal(ULongLong value)
+    {
+        char *buffer_end = buffer_ + BUFFER_SIZE - 1;
+        while (value >= 100)
+        {
+            // Integer division is slow so do it for a group of two digits instead
+            // of for every digit. The idea comes from the talk by Alexandrescu
+            // "Three Optimization Tips for C++". See speed-test for a comparison.
+            unsigned index = static_cast<unsigned>((value % 100) * 2);
+            value /= 100;
+            *--buffer_end = internal::Data::DIGITS[index + 1];
+            *--buffer_end = internal::Data::DIGITS[index];
+        }
+        if (value < 10)
+        {
+            *--buffer_end = static_cast<char>('0' + value);
+            return buffer_end;
+        }
+        unsigned index = static_cast<unsigned>(value * 2);
+        *--buffer_end = internal::Data::DIGITS[index + 1];
+        *--buffer_end = internal::Data::DIGITS[index];
+        return buffer_end;
     }
-    if (value < 10) {
-      *--buffer_end = static_cast<char>('0' + value);
-      return buffer_end;
+
+    void FormatSigned(LongLong value)
+    {
+        ULongLong abs_value = static_cast<ULongLong>(value);
+        bool negative = value < 0;
+        if (negative)
+            abs_value = 0 - abs_value;
+        str_ = format_decimal(abs_value);
+        if (negative)
+            *--str_ = '-';
     }
-    unsigned index = static_cast<unsigned>(value * 2);
-    *--buffer_end = internal::Data::DIGITS[index + 1];
-    *--buffer_end = internal::Data::DIGITS[index];
-    return buffer_end;
-  }
 
-  void FormatSigned(LongLong value) {
-    ULongLong abs_value = static_cast<ULongLong>(value);
-    bool negative = value < 0;
-    if (negative)
-      abs_value = 0 - abs_value;
-    str_ = format_decimal(abs_value);
-    if (negative)
-      *--str_ = '-';
-  }
+public:
+    explicit FormatInt(int value)
+    {
+        FormatSigned(value);
+    }
+    explicit FormatInt(long value)
+    {
+        FormatSigned(value);
+    }
+    explicit FormatInt(LongLong value)
+    {
+        FormatSigned(value);
+    }
+    explicit FormatInt(unsigned value) : str_(format_decimal(value)) {}
+    explicit FormatInt(unsigned long value) : str_(format_decimal(value)) {}
+    explicit FormatInt(ULongLong value) : str_(format_decimal(value)) {}
 
- public:
-  explicit FormatInt(int value) { FormatSigned(value); }
-  explicit FormatInt(long value) { FormatSigned(value); }
-  explicit FormatInt(LongLong value) { FormatSigned(value); }
-  explicit FormatInt(unsigned value) : str_(format_decimal(value)) {}
-  explicit FormatInt(unsigned long value) : str_(format_decimal(value)) {}
-  explicit FormatInt(ULongLong value) : str_(format_decimal(value)) {}
+    /** Returns the number of characters written to the output buffer. */
+    std::size_t size() const
+    {
+        return internal::to_unsigned(buffer_ - str_ + BUFFER_SIZE - 1);
+    }
 
-  /** Returns 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::IntTraits<T>::MainType MainType;
-  MainType abs_value = static_cast<MainType>(value);
-  if (internal::is_negative(value)) {
-    *buffer++ = '-';
-    abs_value = 0 - abs_value;
-  }
-  if (abs_value < 100) {
-    if (abs_value < 10) {
-      *buffer++ = static_cast<char>('0' + abs_value);
-      return;
+inline void format_decimal(char *&buffer, T value)
+{
+    typedef typename internal::IntTraits<T>::MainType MainType;
+    MainType abs_value = static_cast<MainType>(value);
+    if (internal::is_negative(value))
+    {
+        *buffer++ = '-';
+        abs_value = 0 - abs_value;
     }
-    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;
 }
 
 /**
@@ -3439,13 +4011,15 @@ inline void format_decimal(char *&buffer, T value) {
   \endrst
  */
 template <typename T>
-inline internal::NamedArgWithType<char, T> arg(StringRef name, const T &arg) {
-  return internal::NamedArgWithType<char, T>(name, arg);
+inline internal::NamedArgWithType<char, T> arg(StringRef name, const T &arg)
+{
+    return internal::NamedArgWithType<char, T>(name, arg);
 }
 
 template <typename T>
-inline internal::NamedArgWithType<wchar_t, T> arg(WStringRef name, const T &arg) {
-  return internal::NamedArgWithType<wchar_t, T>(name, arg);
+inline internal::NamedArgWithType<wchar_t, T> arg(WStringRef name, const T &arg)
+{
+    return internal::NamedArgWithType<wchar_t, T>(name, arg);
 }
 
 // The following two functions are deleted intentionally to disable
@@ -3582,382 +4156,443 @@ void arg(WStringRef, const internal::NamedArg<Char>&) FMT_DELETED_OR_UNDEFINED;
 
 #define FMT_CAPTURE_W(...) FMT_FOR_EACH(FMT_CAPTURE_ARG_W_, __VA_ARGS__)
 
-namespace fmt {
+namespace fmt
+{
 FMT_VARIADIC(std::string, format, CStringRef)
 FMT_VARIADIC_W(std::wstring, format, WCStringRef)
 FMT_VARIADIC(void, print, CStringRef)
 FMT_VARIADIC(void, print, std::FILE *, CStringRef)
 FMT_VARIADIC(void, print_colored, Color, CStringRef)
 
-namespace internal {
+namespace internal
+{
 template <typename Char>
-inline bool is_name_start(Char c) {
-  return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c;
+inline bool is_name_start(Char c)
+{
+    return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c;
 }
 
 // Parses an unsigned integer advancing s to the end of the parsed input.
 // This function assumes that the first character of s is a digit.
 template <typename Char>
-unsigned parse_nonnegative_int(const Char *&s) {
-  assert('0' <= *s && *s <= '9');
-  unsigned value = 0;
-  do {
-    unsigned new_value = value * 10 + (*s++ - '0');
-    // Check if value wrapped around.
-    if (new_value < value) {
-      value = (std::numeric_limits<unsigned>::max)();
-      break;
+unsigned parse_nonnegative_int(const Char *&s)
+{
+    assert('0' <= *s && *s <= '9');
+    unsigned value = 0;
+    do
+    {
+        unsigned new_value = value * 10 + (*s++ - '0');
+        // Check if value wrapped around.
+        if (new_value < value)
+        {
+            value = (std::numeric_limits<unsigned>::max)();
+            break;
+        }
+        value = new_value;
     }
-    value = new_value;
-  } while ('0' <= *s && *s <= '9');
-  // Convert to unsigned to prevent a warning.
-  unsigned max_int = (std::numeric_limits<int>::max)();
-  if (value > max_int)
-    FMT_THROW(FormatError("number is too big"));
-  return value;
+    while ('0' <= *s && *s <= '9');
+    // Convert to unsigned to prevent a warning.
+    unsigned max_int = (std::numeric_limits<int>::max)();
+    if (value > max_int)
+        FMT_THROW(FormatError("number is too big"));
+    return value;
 }
 
-inline void require_numeric_argument(const Arg &arg, char spec) {
-  if (arg.type > Arg::LAST_NUMERIC_TYPE) {
-    std::string message =
-        fmt::format("format specifier '{}' requires numeric argument", spec);
-    FMT_THROW(fmt::FormatError(message));
-  }
+inline void require_numeric_argument(const Arg &arg, char spec)
+{
+    if (arg.type > Arg::LAST_NUMERIC_TYPE)
+    {
+        std::string message =
+            fmt::format("format specifier '{}' requires numeric argument", spec);
+        FMT_THROW(fmt::FormatError(message));
+    }
 }
 
 template <typename Char>
-void check_sign(const Char *&s, const Arg &arg) {
-  char sign = static_cast<char>(*s);
-  require_numeric_argument(arg, sign);
-  if (arg.type == Arg::UINT || arg.type == Arg::ULONG_LONG) {
-    FMT_THROW(FormatError(fmt::format(
-      "format specifier '{}' requires signed argument", sign)));
-  }
-  ++s;
+void check_sign(const Char *&s, const Arg &arg)
+{
+    char sign = static_cast<char>(*s);
+    require_numeric_argument(arg, sign);
+    if (arg.type == Arg::UINT || arg.type == Arg::ULONG_LONG)
+    {
+        FMT_THROW(FormatError(fmt::format(
+                                  "format specifier '{}' requires signed argument", sign)));
+    }
+    ++s;
 }
 }  // namespace internal
 
 template <typename Char, typename AF>
 inline internal::Arg BasicFormatter<Char, AF>::get_arg(
-    BasicStringRef<Char> arg_name, const char *&error) {
-  if (check_no_auto_index(error)) {
-    map_.init(args());
-    const internal::Arg *arg = map_.find(arg_name);
-    if (arg)
-      return *arg;
-    error = "argument not found";
-  }
-  return internal::Arg();
+    BasicStringRef<Char> arg_name, const char *&error)
+{
+    if (check_no_auto_index(error))
+    {
+        map_.init(args());
+        const internal::Arg *arg = map_.find(arg_name);
+        if (arg)
+            return *arg;
+        error = "argument not found";
+    }
+    return internal::Arg();
 }
 
 template <typename Char, typename AF>
-inline internal::Arg BasicFormatter<Char, AF>::parse_arg_index(const Char *&s) {
-  const char *error = FMT_NULL;
-  internal::Arg arg = *s < '0' || *s > '9' ?
-        next_arg(error) : get_arg(internal::parse_nonnegative_int(s), error);
-  if (error) {
-    FMT_THROW(FormatError(
-                *s != '}' && *s != ':' ? "invalid format string" : error));
-  }
-  return arg;
+inline internal::Arg BasicFormatter<Char, AF>::parse_arg_index(const Char *&s)
+{
+    const char *error = FMT_NULL;
+    internal::Arg arg = *s < '0' || *s > '9' ?
+                        next_arg(error) : get_arg(internal::parse_nonnegative_int(s), error);
+    if (error)
+    {
+        FMT_THROW(FormatError(
+                      *s != '}' && *s != ':' ? "invalid format string" : error));
+    }
+    return arg;
 }
 
 template <typename Char, typename AF>
-inline internal::Arg BasicFormatter<Char, AF>::parse_arg_name(const Char *&s) {
-  assert(internal::is_name_start(*s));
-  const Char *start = s;
-  Char c;
-  do {
-    c = *++s;
-  } while (internal::is_name_start(c) || ('0' <= c && c <= '9'));
-  const char *error = FMT_NULL;
-  internal::Arg arg = get_arg(BasicStringRef<Char>(start, s - start), error);
-  if (error)
-    FMT_THROW(FormatError(error));
-  return arg;
+inline internal::Arg BasicFormatter<Char, AF>::parse_arg_name(const Char *&s)
+{
+    assert(internal::is_name_start(*s));
+    const Char *start = s;
+    Char c;
+    do
+    {
+        c = *++s;
+    }
+    while (internal::is_name_start(c) || ('0' <= c && c <= '9'));
+    const char *error = FMT_NULL;
+    internal::Arg arg = get_arg(BasicStringRef<Char>(start, s - start), error);
+    if (error)
+        FMT_THROW(FormatError(error));
+    return arg;
 }
 
 template <typename Char, typename ArgFormatter>
 const Char *BasicFormatter<Char, ArgFormatter>::format(
-    const Char *&format_str, const internal::Arg &arg) {
-  using internal::Arg;
-  const Char *s = format_str;
-  typename ArgFormatter::SpecType spec;
-  if (*s == ':') {
-    if (arg.type == Arg::CUSTOM) {
-      arg.custom.format(this, arg.custom.value, &s);
-      return s;
-    }
-    ++s;
-    // Parse fill and alignment.
-    if (Char c = *s) {
-      const Char *p = s + 1;
-      spec.align_ = ALIGN_DEFAULT;
-      do {
-        switch (*p) {
-          case '<':
-            spec.align_ = ALIGN_LEFT;
-            break;
-          case '>':
-            spec.align_ = ALIGN_RIGHT;
-            break;
-          case '=':
-            spec.align_ = ALIGN_NUMERIC;
-            break;
-          case '^':
-            spec.align_ = ALIGN_CENTER;
-            break;
+    const Char *&format_str, const internal::Arg &arg)
+{
+    using internal::Arg;
+    const Char *s = format_str;
+    typename ArgFormatter::SpecType spec;
+    if (*s == ':')
+    {
+        if (arg.type == Arg::CUSTOM)
+        {
+            arg.custom.format(this, arg.custom.value, &s);
+            return s;
         }
-        if (spec.align_ != ALIGN_DEFAULT) {
-          if (p != s) {
-            if (c == '}') break;
-            if (c == '{')
-              FMT_THROW(FormatError("invalid fill character '{'"));
-            s += 2;
-            spec.fill_ = c;
-          } else ++s;
-          if (spec.align_ == ALIGN_NUMERIC)
-            require_numeric_argument(arg, '=');
-          break;
-        }
-      } while (--p >= s);
-    }
-
-    // Parse sign.
-    switch (*s) {
-      case '+':
-        check_sign(s, arg);
-        spec.flags_ |= SIGN_FLAG | PLUS_FLAG;
-        break;
-      case '-':
-        check_sign(s, arg);
-        spec.flags_ |= MINUS_FLAG;
-        break;
-      case ' ':
-        check_sign(s, arg);
-        spec.flags_ |= SIGN_FLAG;
-        break;
-    }
-
-    if (*s == '#') {
-      require_numeric_argument(arg, '#');
-      spec.flags_ |= HASH_FLAG;
-      ++s;
-    }
-
-    // Parse zero flag.
-    if (*s == '0') {
-      require_numeric_argument(arg, '0');
-      spec.align_ = ALIGN_NUMERIC;
-      spec.fill_ = '0';
-      ++s;
-    }
-
-    // Parse width.
-    if ('0' <= *s && *s <= '9') {
-      spec.width_ = internal::parse_nonnegative_int(s);
-    } else if (*s == '{') {
-      ++s;
-      Arg width_arg = internal::is_name_start(*s) ?
-            parse_arg_name(s) : parse_arg_index(s);
-      if (*s++ != '}')
-        FMT_THROW(FormatError("invalid format string"));
-      ULongLong value = 0;
-      switch (width_arg.type) {
-      case Arg::INT:
-        if (width_arg.int_value < 0)
-          FMT_THROW(FormatError("negative width"));
-        value = width_arg.int_value;
-        break;
-      case Arg::UINT:
-        value = width_arg.uint_value;
-        break;
-      case Arg::LONG_LONG:
-        if (width_arg.long_long_value < 0)
-          FMT_THROW(FormatError("negative width"));
-        value = width_arg.long_long_value;
-        break;
-      case Arg::ULONG_LONG:
-        value = width_arg.ulong_long_value;
-        break;
-      default:
-        FMT_THROW(FormatError("width is not integer"));
-      }
-      if (value > (std::numeric_limits<int>::max)())
-        FMT_THROW(FormatError("number is too big"));
-      spec.width_ = static_cast<int>(value);
-    }
-
-    // Parse precision.
-    if (*s == '.') {
-      ++s;
-      spec.precision_ = 0;
-      if ('0' <= *s && *s <= '9') {
-        spec.precision_ = internal::parse_nonnegative_int(s);
-      } else if (*s == '{') {
         ++s;
-        Arg precision_arg = internal::is_name_start(*s) ?
-              parse_arg_name(s) : parse_arg_index(s);
-        if (*s++ != '}')
-          FMT_THROW(FormatError("invalid format string"));
-        ULongLong value = 0;
-        switch (precision_arg.type) {
-          case Arg::INT:
-            if (precision_arg.int_value < 0)
-              FMT_THROW(FormatError("negative precision"));
-            value = precision_arg.int_value;
-            break;
-          case Arg::UINT:
-            value = precision_arg.uint_value;
-            break;
-          case Arg::LONG_LONG:
-            if (precision_arg.long_long_value < 0)
-              FMT_THROW(FormatError("negative precision"));
-            value = precision_arg.long_long_value;
-            break;
-          case Arg::ULONG_LONG:
-            value = precision_arg.ulong_long_value;
-            break;
-          default:
-            FMT_THROW(FormatError("precision is not integer"));
+        // Parse fill and alignment.
+        if (Char c = *s)
+        {
+            const Char *p = s + 1;
+            spec.align_ = ALIGN_DEFAULT;
+            do
+            {
+                switch (*p)
+                {
+                case '<':
+                    spec.align_ = ALIGN_LEFT;
+                    break;
+                case '>':
+                    spec.align_ = ALIGN_RIGHT;
+                    break;
+                case '=':
+                    spec.align_ = ALIGN_NUMERIC;
+                    break;
+                case '^':
+                    spec.align_ = ALIGN_CENTER;
+                    break;
+                }
+                if (spec.align_ != ALIGN_DEFAULT)
+                {
+                    if (p != s)
+                    {
+                        if (c == '}') break;
+                        if (c == '{')
+                            FMT_THROW(FormatError("invalid fill character '{'"));
+                        s += 2;
+                        spec.fill_ = c;
+                    }
+                    else ++s;
+                    if (spec.align_ == ALIGN_NUMERIC)
+                        require_numeric_argument(arg, '=');
+                    break;
+                }
+            }
+            while (--p >= s);
         }
-        if (value > (std::numeric_limits<int>::max)())
-          FMT_THROW(FormatError("number is too big"));
-        spec.precision_ = static_cast<int>(value);
-      } else {
-        FMT_THROW(FormatError("missing precision specifier"));
-      }
-      if (arg.type <= Arg::LAST_INTEGER_TYPE || arg.type == Arg::POINTER) {
-        FMT_THROW(FormatError(
-            fmt::format("precision not allowed in {} format specifier",
-            arg.type == Arg::POINTER ? "pointer" : "integer")));
-      }
+
+        // Parse sign.
+        switch (*s)
+        {
+        case '+':
+            check_sign(s, arg);
+            spec.flags_ |= SIGN_FLAG | PLUS_FLAG;
+            break;
+        case '-':
+            check_sign(s, arg);
+            spec.flags_ |= MINUS_FLAG;
+            break;
+        case ' ':
+            check_sign(s, arg);
+            spec.flags_ |= SIGN_FLAG;
+            break;
+        }
+
+        if (*s == '#')
+        {
+            require_numeric_argument(arg, '#');
+            spec.flags_ |= HASH_FLAG;
+            ++s;
+        }
+
+        // Parse zero flag.
+        if (*s == '0')
+        {
+            require_numeric_argument(arg, '0');
+            spec.align_ = ALIGN_NUMERIC;
+            spec.fill_ = '0';
+            ++s;
+        }
+
+        // Parse width.
+        if ('0' <= *s && *s <= '9')
+        {
+            spec.width_ = internal::parse_nonnegative_int(s);
+        }
+        else if (*s == '{')
+        {
+            ++s;
+            Arg width_arg = internal::is_name_start(*s) ?
+                            parse_arg_name(s) : parse_arg_index(s);
+            if (*s++ != '}')
+                FMT_THROW(FormatError("invalid format string"));
+            ULongLong value = 0;
+            switch (width_arg.type)
+            {
+            case Arg::INT:
+                if (width_arg.int_value < 0)
+                    FMT_THROW(FormatError("negative width"));
+                value = width_arg.int_value;
+                break;
+            case Arg::UINT:
+                value = width_arg.uint_value;
+                break;
+            case Arg::LONG_LONG:
+                if (width_arg.long_long_value < 0)
+                    FMT_THROW(FormatError("negative width"));
+                value = width_arg.long_long_value;
+                break;
+            case Arg::ULONG_LONG:
+                value = width_arg.ulong_long_value;
+                break;
+            default:
+                FMT_THROW(FormatError("width is not integer"));
+            }
+            if (value > (std::numeric_limits<int>::max)())
+                FMT_THROW(FormatError("number is too big"));
+            spec.width_ = static_cast<int>(value);
+        }
+
+        // Parse precision.
+        if (*s == '.')
+        {
+            ++s;
+            spec.precision_ = 0;
+            if ('0' <= *s && *s <= '9')
+            {
+                spec.precision_ = internal::parse_nonnegative_int(s);
+            }
+            else if (*s == '{')
+            {
+                ++s;
+                Arg precision_arg = internal::is_name_start(*s) ?
+                                    parse_arg_name(s) : parse_arg_index(s);
+                if (*s++ != '}')
+                    FMT_THROW(FormatError("invalid format string"));
+                ULongLong value = 0;
+                switch (precision_arg.type)
+                {
+                case Arg::INT:
+                    if (precision_arg.int_value < 0)
+                        FMT_THROW(FormatError("negative precision"));
+                    value = precision_arg.int_value;
+                    break;
+                case Arg::UINT:
+                    value = precision_arg.uint_value;
+                    break;
+                case Arg::LONG_LONG:
+                    if (precision_arg.long_long_value < 0)
+                        FMT_THROW(FormatError("negative precision"));
+                    value = precision_arg.long_long_value;
+                    break;
+                case Arg::ULONG_LONG:
+                    value = precision_arg.ulong_long_value;
+                    break;
+                default:
+                    FMT_THROW(FormatError("precision is not integer"));
+                }
+                if (value > (std::numeric_limits<int>::max)())
+                    FMT_THROW(FormatError("number is too big"));
+                spec.precision_ = static_cast<int>(value);
+            }
+            else
+            {
+                FMT_THROW(FormatError("missing precision specifier"));
+            }
+            if (arg.type <= Arg::LAST_INTEGER_TYPE || arg.type == Arg::POINTER)
+            {
+                FMT_THROW(FormatError(
+                              fmt::format("precision not allowed in {} format specifier",
+                                          arg.type == Arg::POINTER ? "pointer" : "integer")));
+            }
+        }
+
+        // Parse type.
+        if (*s != '}' && *s)
+            spec.type_ = static_cast<char>(*s++);
     }
 
-    // Parse type.
-    if (*s != '}' && *s)
-      spec.type_ = static_cast<char>(*s++);
-  }
+    if (*s++ != '}')
+        FMT_THROW(FormatError("missing '}' in format string"));
 
-  if (*s++ != '}')
-    FMT_THROW(FormatError("missing '}' in format string"));
-
-  // Format argument.
-  ArgFormatter(*this, spec, s - 1).visit(arg);
-  return s;
+    // Format argument.
+    ArgFormatter(*this, spec, s - 1).visit(arg);
+    return s;
 }
 
 template <typename Char, typename AF>
-void BasicFormatter<Char, AF>::format(BasicCStringRef<Char> format_str) {
-  const Char *s = format_str.c_str();
-  const Char *start = s;
-  while (*s) {
-    Char c = *s++;
-    if (c != '{' && c != '}') continue;
-    if (*s == c) {
-      write(writer_, start, s);
-      start = ++s;
-      continue;
+void BasicFormatter<Char, AF>::format(BasicCStringRef<Char> format_str)
+{
+    const Char *s = format_str.c_str();
+    const Char *start = s;
+    while (*s)
+    {
+        Char c = *s++;
+        if (c != '{' && c != '}') continue;
+        if (*s == c)
+        {
+            write(writer_, start, s);
+            start = ++s;
+            continue;
+        }
+        if (c == '}')
+            FMT_THROW(FormatError("unmatched '}' in format string"));
+        write(writer_, start, s - 1);
+        internal::Arg arg = internal::is_name_start(*s) ?
+                            parse_arg_name(s) : parse_arg_index(s);
+        start = s = format(s, arg);
     }
-    if (c == '}')
-      FMT_THROW(FormatError("unmatched '}' in format string"));
-    write(writer_, start, s - 1);
-    internal::Arg arg = internal::is_name_start(*s) ?
-          parse_arg_name(s) : parse_arg_index(s);
-    start = s = format(s, arg);
-  }
-  write(writer_, start, s);
+    write(writer_, start, s);
 }
 
 template <typename Char, typename It>
-struct ArgJoin {
-  It first;
-  It last;
-  BasicCStringRef<Char> sep;
+struct ArgJoin
+{
+    It first;
+    It last;
+    BasicCStringRef<Char> sep;
 
-  ArgJoin(It first, It last, const BasicCStringRef<Char>& sep) :
-    first(first),
-    last(last),
-    sep(sep) {}
+    ArgJoin(It first, It last, const BasicCStringRef<Char>& sep) :
+        first(first),
+        last(last),
+        sep(sep) {}
 };
 
 template <typename It>
-ArgJoin<char, It> join(It first, It last, const BasicCStringRef<char>& sep) {
-  return ArgJoin<char, It>(first, last, sep);
+ArgJoin<char, It> join(It first, It last, const BasicCStringRef<char>& sep)
+{
+    return ArgJoin<char, It>(first, last, sep);
 }
 
 template <typename It>
-ArgJoin<wchar_t, It> join(It first, It last, const BasicCStringRef<wchar_t>& sep) {
-  return ArgJoin<wchar_t, It>(first, last, sep);
+ArgJoin<wchar_t, It> join(It first, It last, const BasicCStringRef<wchar_t>& sep)
+{
+    return ArgJoin<wchar_t, It>(first, last, sep);
 }
 
 #if FMT_HAS_GXX_CXX11
 template <typename Range>
 auto join(const Range& range, const BasicCStringRef<char>& sep)
-    -> ArgJoin<char, decltype(std::begin(range))> {
-  return join(std::begin(range), std::end(range), sep);
+-> ArgJoin<char, decltype(std::begin(range))>
+{
+    return join(std::begin(range), std::end(range), sep);
 }
 
 template <typename Range>
 auto join(const Range& range, const BasicCStringRef<wchar_t>& sep)
-    -> ArgJoin<wchar_t, decltype(std::begin(range))> {
-  return join(std::begin(range), std::end(range), sep);
+-> ArgJoin<wchar_t, decltype(std::begin(range))>
+{
+    return join(std::begin(range), std::end(range), sep);
 }
 #endif
 
 template <typename ArgFormatter, typename Char, typename It>
 void format_arg(fmt::BasicFormatter<Char, ArgFormatter> &f,
-    const Char *&format_str, const ArgJoin<Char, It>& e) {
-  const Char* end = format_str;
-  if (*end == ':')
-    ++end;
-  while (*end && *end != '}')
-    ++end;
-  if (*end != '}')
-    FMT_THROW(FormatError("missing '}' in format string"));
+                const Char *&format_str, const ArgJoin<Char, It>& e)
+{
+    const Char* end = format_str;
+    if (*end == ':')
+        ++end;
+    while (*end && *end != '}')
+        ++end;
+    if (*end != '}')
+        FMT_THROW(FormatError("missing '}' in format string"));
 
-  It it = e.first;
-  if (it != e.last) {
-    const Char* save = format_str;
-    f.format(format_str, internal::MakeArg<fmt::BasicFormatter<Char, ArgFormatter> >(*it++));
-    while (it != e.last) {
-      f.writer().write(e.sep);
-      format_str = save;
-      f.format(format_str, internal::MakeArg<fmt::BasicFormatter<Char, ArgFormatter> >(*it++));
+    It it = e.first;
+    if (it != e.last)
+    {
+        const Char* save = format_str;
+        f.format(format_str, internal::MakeArg<fmt::BasicFormatter<Char, ArgFormatter> >(*it++));
+        while (it != e.last)
+        {
+            f.writer().write(e.sep);
+            format_str = save;
+            f.format(format_str, internal::MakeArg<fmt::BasicFormatter<Char, ArgFormatter> >(*it++));
+        }
     }
-  }
-  format_str = end + 1;
+    format_str = end + 1;
 }
 }  // namespace fmt
 
 #if FMT_USE_USER_DEFINED_LITERALS
-namespace fmt {
-namespace internal {
+namespace fmt
+{
+namespace internal
+{
 
 template <typename Char>
-struct UdlFormat {
-  const Char *str;
+struct UdlFormat
+{
+    const Char *str;
 
-  template <typename... Args>
-  auto operator()(Args && ... args) const
-                  -> decltype(format(str, std::forward<Args>(args)...)) {
-    return format(str, std::forward<Args>(args)...);
-  }
+    template <typename... Args>
+    auto operator()(Args && ... args) const
+    -> decltype(format(str, std::forward<Args>(args)...))
+    {
+        return format(str, std::forward<Args>(args)...);
+    }
 };
 
 template <typename Char>
-struct UdlArg {
-  const Char *str;
+struct UdlArg
+{
+    const Char *str;
 
-  template <typename T>
-  NamedArgWithType<Char, T> operator=(T &&value) const {
-    return {str, std::forward<T>(value)};
-  }
+    template <typename T>
+    NamedArgWithType<Char, T> operator=(T &&value) const
+    {
+        return {str, std::forward<T>(value)};
+    }
 };
 
 } // namespace internal
 
-inline namespace literals {
+inline namespace literals
+{
 
 /**
   \rst
@@ -3970,9 +4605,15 @@ inline namespace literals {
   \endrst
  */
 inline internal::UdlFormat<char>
-operator"" _format(const char *s, std::size_t) { return {s}; }
+operator"" _format(const char *s, std::size_t)
+{
+    return {s};
+}
 inline internal::UdlFormat<wchar_t>
-operator"" _format(const wchar_t *s, std::size_t) { return {s}; }
+operator"" _format(const wchar_t *s, std::size_t)
+{
+    return {s};
+}
 
 /**
   \rst
@@ -3985,9 +4626,15 @@ operator"" _format(const wchar_t *s, std::size_t) { return {s}; }
   \endrst
  */
 inline internal::UdlArg<char>
-operator"" _a(const char *s, std::size_t) { return {s}; }
+operator"" _a(const char *s, std::size_t)
+{
+    return {s};
+}
 inline internal::UdlArg<wchar_t>
-operator"" _a(const wchar_t *s, std::size_t) { return {s}; }
+operator"" _a(const wchar_t *s, std::size_t)
+{
+    return {s};
+}
 
 } // inline namespace literals
 } // namespace fmt
diff --git a/include/spdlog/fmt/bundled/ostream.h b/include/spdlog/fmt/bundled/ostream.h
index 84a02d17..cfb8e035 100644
--- a/include/spdlog/fmt/bundled/ostream.h
+++ b/include/spdlog/fmt/bundled/ostream.h
@@ -13,57 +13,65 @@
 #include "format.h"
 #include <ostream>
 
-namespace fmt {
+namespace fmt
+{
 
-namespace internal {
+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;
+class FormatBuf : public std::basic_streambuf<Char>
+{
+private:
+    typedef typename std::basic_streambuf<Char>::int_type int_type;
+    typedef typename std::basic_streambuf<Char>::traits_type traits_type;
 
-  Buffer<Char> &buffer_;
+    Buffer<Char> &buffer_;
 
- public:
-  FormatBuf(Buffer<Char> &buffer) : buffer_(buffer) {}
+public:
+    FormatBuf(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;
+    }
 };
 
 Yes &convert(std::ostream &);
 
-struct DummyStream : std::ostream {
-  DummyStream();  // Suppress a bogus warning in MSVC.
-  // Hide all operator<< overloads from std::ostream.
-  void operator<<(Null<>);
+struct DummyStream : std::ostream
+{
+    DummyStream();  // Suppress a bogus warning in MSVC.
+    // Hide all operator<< overloads from std::ostream.
+    void operator<<(Null<>);
 };
 
 No &operator<<(std::ostream &, int);
 
 template<typename T>
-struct ConvertToIntImpl<T, true> {
-  // Convert to int only if T doesn't have an overloaded operator<<.
-  enum {
-    value = sizeof(convert(get<DummyStream>() << get<T>())) == sizeof(No)
-  };
+struct ConvertToIntImpl<T, true>
+{
+    // Convert to int only if T doesn't have an overloaded operator<<.
+    enum
+    {
+        value = sizeof(convert(get<DummyStream>() << get<T>())) == sizeof(No)
+    };
 };
 
 // Write the content of w to os.
@@ -73,16 +81,17 @@ FMT_API void write(std::ostream &os, Writer &w);
 // Formats a value.
 template <typename Char, typename ArgFormatter_, typename T>
 void format_arg(BasicFormatter<Char, ArgFormatter_> &f,
-                const Char *&format_str, const T &value) {
-  internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE> buffer;
+                const Char *&format_str, const T &value)
+{
+    internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE> buffer;
 
-  internal::FormatBuf<Char> format_buf(buffer);
-  std::basic_ostream<Char> output(&format_buf);
-  output << value;
+    internal::FormatBuf<Char> format_buf(buffer);
+    std::basic_ostream<Char> output(&format_buf);
+    output << value;
 
-  BasicStringRef<Char> str(&buffer[0], buffer.size());
-  typedef internal::MakeArg< BasicFormatter<Char> > MakeArg;
-  format_str = f.format(format_str, MakeArg(str));
+    BasicStringRef<Char> str(&buffer[0], buffer.size());
+    typedef internal::MakeArg< BasicFormatter<Char> > MakeArg;
+    format_str = f.format(format_str, MakeArg(str));
 }
 
 /**
diff --git a/include/spdlog/fmt/bundled/posix.h b/include/spdlog/fmt/bundled/posix.h
index 88512de5..69327250 100644
--- a/include/spdlog/fmt/bundled/posix.h
+++ b/include/spdlog/fmt/bundled/posix.h
@@ -64,112 +64,134 @@
 
 #define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1)
 
-namespace fmt {
+namespace fmt
+{
 
 // An error code.
-class ErrorCode {
- private:
-  int value_;
+class ErrorCode
+{
+private:
+    int value_;
 
- public:
-  explicit ErrorCode(int value = 0) FMT_NOEXCEPT : value_(value) {}
+public:
+explicit ErrorCode(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 BufferedFile {
- private:
-  FILE *file_;
+class BufferedFile
+{
+private:
+    FILE *file_;
 
-  friend class File;
+    friend class File;
 
-  explicit BufferedFile(FILE *f) : file_(f) {}
-
- public:
-  // Constructs a BufferedFile object which doesn't represent any file.
-  BufferedFile() FMT_NOEXCEPT : file_(FMT_NULL) {}
-
-  // Destroys the object closing the file it represents if any.
-  FMT_API ~BufferedFile() FMT_NOEXCEPT;
-
-#if !FMT_USE_RVALUE_REFERENCES
-  // Emulate a move constructor and a move assignment operator if rvalue
-  // references are not supported.
-
- private:
-  // A proxy object to emulate a move constructor.
-  // It is private to make it impossible call operator Proxy directly.
-  struct Proxy {
-    FILE *file;
-  };
+    explicit BufferedFile(FILE *f) : file_(f) {}
 
 public:
-  // A "move constructor" for moving from a temporary.
-  BufferedFile(Proxy p) FMT_NOEXCEPT : file_(p.file) {}
+    // Constructs a BufferedFile object which doesn't represent any file.
+BufferedFile() FMT_NOEXCEPT :
+    file_(FMT_NULL) {}
 
-  // A "move constructor" for moving from an lvalue.
-  BufferedFile(BufferedFile &f) FMT_NOEXCEPT : file_(f.file_) {
-    f.file_ = FMT_NULL;
-  }
+    // Destroys the object closing the file it represents if any.
+    FMT_API ~BufferedFile() FMT_NOEXCEPT;
 
-  // A "move assignment operator" for moving from a temporary.
-  BufferedFile &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.
-  BufferedFile &operator=(BufferedFile &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:
-  //   BufferedFile file = BufferedFile(...);
-  operator Proxy() FMT_NOEXCEPT {
-    Proxy p = {file_};
-    file_ = FMT_NULL;
-    return p;
-  }
+public:
+    // A "move constructor" for moving from a temporary.
+BufferedFile(Proxy p) FMT_NOEXCEPT :
+    file_(p.file) {}
+
+    // A "move constructor" for moving from an lvalue.
+BufferedFile(BufferedFile &f) FMT_NOEXCEPT :
+    file_(f.file_)
+    {
+        f.file_ = FMT_NULL;
+    }
+
+    // A "move assignment operator" for moving from a temporary.
+    BufferedFile &operator=(Proxy p)
+    {
+        close();
+        file_ = p.file;
+        return *this;
+    }
+
+    // A "move assignment operator" for moving from an lvalue.
+    BufferedFile &operator=(BufferedFile &other)
+    {
+        close();
+        file_ = other.file_;
+        other.file_ = FMT_NULL;
+        return *this;
+    }
+
+    // Returns a proxy object for moving from a temporary:
+    //   BufferedFile file = BufferedFile(...);
+    operator Proxy() FMT_NOEXCEPT
+    {
+        Proxy p = {file_};
+        file_ = FMT_NULL;
+        return p;
+    }
 
 #else
- private:
-  FMT_DISALLOW_COPY_AND_ASSIGN(BufferedFile);
+private:
+    FMT_DISALLOW_COPY_AND_ASSIGN(BufferedFile);
 
- public:
-  BufferedFile(BufferedFile &&other) FMT_NOEXCEPT : file_(other.file_) {
-    other.file_ = FMT_NULL;
-  }
+public:
+BufferedFile(BufferedFile &&other) FMT_NOEXCEPT :
+    file_(other.file_)
+    {
+        other.file_ = FMT_NULL;
+    }
 
-  BufferedFile& operator=(BufferedFile &&other) {
-    close();
-    file_ = other.file_;
-    other.file_ = FMT_NULL;
-    return *this;
-  }
+    BufferedFile& operator=(BufferedFile &&other)
+    {
+        close();
+        file_ = other.file_;
+        other.file_ = FMT_NULL;
+        return *this;
+    }
 #endif
 
-  // Opens a file.
-  FMT_API BufferedFile(CStringRef filename, CStringRef mode);
+    // Opens a file.
+    FMT_API BufferedFile(CStringRef filename, CStringRef 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 print(CStringRef format_str, const ArgList &args) {
-    fmt::print(file_, format_str, args);
-  }
-  FMT_VARIADIC(void, print, CStringRef)
+    void print(CStringRef format_str, const ArgList &args)
+    {
+        fmt::print(file_, format_str, args);
+    }
+    FMT_VARIADIC(void, print, CStringRef)
 };
 
 // A file. Closed file is represented by a File object with descriptor -1.
@@ -178,125 +200,141 @@ 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(CStringRef path, int oflag);
+    // Opens a file and constructs a File object representing this file.
+    FMT_API File(CStringRef path, int oflag);
 
 #if !FMT_USE_RVALUE_REFERENCES
-  // Emulate a move constructor and a move assignment operator if rvalue
-  // references are not supported.
+    // 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 file = File(...);
-  operator Proxy() FMT_NOEXCEPT {
-    Proxy p = {fd_};
-    fd_ = -1;
-    return p;
-  }
+    // Returns a proxy object for moving from a temporary:
+    //   File file = File(...);
+    operator Proxy() FMT_NOEXCEPT
+    {
+        Proxy p = {fd_};
+        fd_ = -1;
+        return p;
+    }
 
 #else
- private:
-  FMT_DISALLOW_COPY_AND_ASSIGN(File);
+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_NOEXCEPT;
+    // Destroys the object closing the file it represents if any.
+    FMT_API ~File() FMT_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 LongLong size() const;
+    // Returns the file size. The size has signed type for consistency with
+    // stat::st_size.
+    FMT_API LongLong 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, ErrorCode &ec) FMT_NOEXCEPT;
+    // Makes fd be the copy of this file descriptor, closing fd first if
+    // necessary.
+    FMT_API void dup2(int fd, ErrorCode &ec) FMT_NOEXCEPT;
 
-  // Creates a pipe setting up read_end and write_end file objects for reading
-  // and writing respectively.
-  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 BufferedFile object associated with this file and detaches
-  // this File object from the file.
-  FMT_API BufferedFile fdopen(const char *mode);
+    // Creates a BufferedFile object associated with this file and detaches
+    // this File object from the file.
+    FMT_API BufferedFile fdopen(const char *mode);
 };
 
 // Returns the memory page size.
@@ -309,58 +347,77 @@ long getpagesize();
 
 #ifdef FMT_LOCALE
 // A "C" numeric locale.
-class Locale {
- private:
+class Locale
+{
+private:
 # ifdef _MSC_VER
-  typedef _locale_t locale_t;
+    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);
-  }
+    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(fmt::SystemError(errno, "cannot create locale"));
-  }
-  ~Locale() { freelocale(locale_); }
+    Locale() : locale_(newlocale(LC_NUMERIC_MASK, "C", FMT_NULL))
+    {
+        if (!locale_)
+            FMT_THROW(fmt::SystemError(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
 }  // namespace fmt
 
 #if !FMT_USE_RVALUE_REFERENCES
-namespace std {
+namespace std
+{
 // For compatibility with C++98.
-inline fmt::BufferedFile &move(fmt::BufferedFile &f) { return f; }
-inline fmt::File &move(fmt::File &f) { return f; }
+inline fmt::BufferedFile &move(fmt::BufferedFile &f)
+{
+    return f;
+}
+inline fmt::File &move(fmt::File &f)
+{
+    return f;
+}
 }
 #endif
 
diff --git a/include/spdlog/fmt/bundled/printf.h b/include/spdlog/fmt/bundled/printf.h
index 30cbc49b..7861b460 100644
--- a/include/spdlog/fmt/bundled/printf.h
+++ b/include/spdlog/fmt/bundled/printf.h
@@ -15,78 +15,118 @@
 
 #include "ostream.h"
 
-namespace fmt {
-namespace internal {
+namespace fmt
+{
+namespace internal
+{
 
 // Checks if a value fits in int - used to avoid warnings about comparing
 // signed and unsigned integers.
 template <bool IsSigned>
-struct IntChecker {
-  template <typename T>
-  static bool fits_in_int(T value) {
-    unsigned max = std::numeric_limits<int>::max();
-    return value <= max;
-  }
-  static bool fits_in_int(bool) { return true; }
+struct IntChecker
+{
+    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 IntChecker<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; }
+struct IntChecker<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 PrecisionHandler : public ArgVisitor<PrecisionHandler, int> {
- public:
-  void report_unhandled_arg() {
-    FMT_THROW(FormatError("precision is not integer"));
-  }
+class PrecisionHandler : public ArgVisitor<PrecisionHandler, int>
+{
+public:
+    void report_unhandled_arg()
+    {
+        FMT_THROW(FormatError("precision is not integer"));
+    }
 
-  template <typename T>
-  int visit_any_int(T value) {
-    if (!IntChecker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
-      FMT_THROW(FormatError("number is too big"));
-    return static_cast<int>(value);
-  }
+    template <typename T>
+    int visit_any_int(T value)
+    {
+        if (!IntChecker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
+            FMT_THROW(FormatError("number is too big"));
+        return static_cast<int>(value);
+    }
 };
 
 // IsZeroInt::visit(arg) returns true iff arg is a zero integer.
-class IsZeroInt : public ArgVisitor<IsZeroInt, bool> {
- public:
-  template <typename T>
-  bool visit_any_int(T value) { return value == 0; }
+class IsZeroInt : public ArgVisitor<IsZeroInt, bool>
+{
+public:
+    template <typename T>
+    bool visit_any_int(T value)
+    {
+        return value == 0;
+    }
 };
 
 // returns the default type for format specific "%s"
-class DefaultType : public ArgVisitor<DefaultType, char> {
- public:
-  char visit_char(int) { return 'c'; }
+class DefaultType : public ArgVisitor<DefaultType, char>
+{
+public:
+    char visit_char(int)
+    {
+        return 'c';
+    }
 
-  char visit_bool(bool) { return 's'; }
+    char visit_bool(bool)
+    {
+        return 's';
+    }
 
-  char visit_pointer(const void *) { return 'p'; }
+    char visit_pointer(const void *)
+    {
+        return 'p';
+    }
 
-  template <typename T>
-  char visit_any_int(T) { return 'd'; }
+    template <typename T>
+    char visit_any_int(T)
+    {
+        return 'd';
+    }
 
-  template <typename T>
-  char visit_any_double(T) { return 'g'; }
+    template <typename T>
+    char visit_any_double(T)
+    {
+        return 'g';
+    }
 
-  char visit_unhandled_arg() { return 's'; }
+    char visit_unhandled_arg()
+    {
+        return 's';
+    }
 };
 
 template <typename T, typename U>
-struct is_same {
-  enum { value = 0 };
+struct is_same
+{
+    enum { value = 0 };
 };
 
 template <typename T>
-struct is_same<T, T> {
-  enum { value = 1 };
+struct is_same<T, T>
+{
+    enum { value = 1 };
 };
 
 // An argument visitor that converts an integer argument to T for printf,
@@ -94,108 +134,128 @@ struct is_same<T, T> {
 // corresponding signed or unsigned type depending on the type specifier:
 // 'd' and 'i' - signed, other - unsigned)
 template <typename T = void>
-class ArgConverter : public ArgVisitor<ArgConverter<T>, void> {
- private:
-  internal::Arg &arg_;
-  wchar_t type_;
+class ArgConverter : public ArgVisitor<ArgConverter<T>, void>
+{
+private:
+    internal::Arg &arg_;
+    wchar_t type_;
 
-  FMT_DISALLOW_COPY_AND_ASSIGN(ArgConverter);
+    FMT_DISALLOW_COPY_AND_ASSIGN(ArgConverter);
 
- public:
-  ArgConverter(internal::Arg &arg, wchar_t type)
-    : arg_(arg), type_(type) {}
+public:
+    ArgConverter(internal::Arg &arg, wchar_t type)
+        : arg_(arg), type_(type) {}
 
-  void visit_bool(bool value) {
-    if (type_ != 's')
-      visit_any_int(value);
-  }
-
-  void visit_char(char value) {
-    if (type_ != 's')
-      visit_any_int(value);
-  }
-
-  template <typename U>
-  void visit_any_int(U value) {
-    bool is_signed = type_ == 'd' || type_ == 'i';
-    if (type_ == 's') {
-      is_signed = std::numeric_limits<U>::is_signed;
+    void visit_bool(bool value)
+    {
+        if (type_ != 's')
+            visit_any_int(value);
     }
 
-    using internal::Arg;
-    typedef typename internal::Conditional<
+    void visit_char(char value)
+    {
+        if (type_ != 's')
+            visit_any_int(value);
+    }
+
+    template <typename U>
+    void visit_any_int(U value)
+    {
+        bool is_signed = type_ == 'd' || type_ == 'i';
+        if (type_ == 's')
+        {
+            is_signed = std::numeric_limits<U>::is_signed;
+        }
+
+        using internal::Arg;
+        typedef typename internal::Conditional<
         is_same<T, void>::value, U, T>::type TargetType;
-    if (sizeof(TargetType) <= sizeof(int)) {
-      // Extra casts are used to silence warnings.
-      if (is_signed) {
-        arg_.type = Arg::INT;
-        arg_.int_value = static_cast<int>(static_cast<TargetType>(value));
-      } else {
-        arg_.type = Arg::UINT;
-        typedef typename internal::MakeUnsigned<TargetType>::Type Unsigned;
-        arg_.uint_value = static_cast<unsigned>(static_cast<Unsigned>(value));
-      }
-    } else {
-      if (is_signed) {
-        arg_.type = Arg::LONG_LONG;
-        // glibc's printf doesn't sign extend arguments of smaller types:
-        //   std::printf("%lld", -42);  // prints "4294967254"
-        // but we don't have to do the same because it's a UB.
-        arg_.long_long_value = static_cast<LongLong>(value);
-      } else {
-        arg_.type = Arg::ULONG_LONG;
-        arg_.ulong_long_value =
-            static_cast<typename internal::MakeUnsigned<U>::Type>(value);
-      }
+        if (sizeof(TargetType) <= sizeof(int))
+        {
+            // Extra casts are used to silence warnings.
+            if (is_signed)
+            {
+                arg_.type = Arg::INT;
+                arg_.int_value = static_cast<int>(static_cast<TargetType>(value));
+            }
+            else
+            {
+                arg_.type = Arg::UINT;
+                typedef typename internal::MakeUnsigned<TargetType>::Type Unsigned;
+                arg_.uint_value = static_cast<unsigned>(static_cast<Unsigned>(value));
+            }
+        }
+        else
+        {
+            if (is_signed)
+            {
+                arg_.type = Arg::LONG_LONG;
+                // glibc's printf doesn't sign extend arguments of smaller types:
+                //   std::printf("%lld", -42);  // prints "4294967254"
+                // but we don't have to do the same because it's a UB.
+                arg_.long_long_value = static_cast<LongLong>(value);
+            }
+            else
+            {
+                arg_.type = Arg::ULONG_LONG;
+                arg_.ulong_long_value =
+                    static_cast<typename internal::MakeUnsigned<U>::Type>(value);
+            }
+        }
     }
-  }
 };
 
 // Converts an integer argument to char for printf.
-class CharConverter : public ArgVisitor<CharConverter, void> {
- private:
-  internal::Arg &arg_;
+class CharConverter : public ArgVisitor<CharConverter, void>
+{
+private:
+    internal::Arg &arg_;
 
-  FMT_DISALLOW_COPY_AND_ASSIGN(CharConverter);
+    FMT_DISALLOW_COPY_AND_ASSIGN(CharConverter);
 
- public:
-  explicit CharConverter(internal::Arg &arg) : arg_(arg) {}
+public:
+    explicit CharConverter(internal::Arg &arg) : arg_(arg) {}
 
-  template <typename T>
-  void visit_any_int(T value) {
-    arg_.type = internal::Arg::CHAR;
-    arg_.int_value = static_cast<char>(value);
-  }
+    template <typename T>
+    void visit_any_int(T value)
+    {
+        arg_.type = internal::Arg::CHAR;
+        arg_.int_value = static_cast<char>(value);
+    }
 };
 
 // Checks if an argument is a valid printf width specifier and sets
 // left alignment if it is negative.
-class WidthHandler : public ArgVisitor<WidthHandler, unsigned> {
- private:
-  FormatSpec &spec_;
+class WidthHandler : public ArgVisitor<WidthHandler, unsigned>
+{
+private:
+    FormatSpec &spec_;
 
-  FMT_DISALLOW_COPY_AND_ASSIGN(WidthHandler);
+    FMT_DISALLOW_COPY_AND_ASSIGN(WidthHandler);
 
- public:
-  explicit WidthHandler(FormatSpec &spec) : spec_(spec) {}
+public:
+    explicit WidthHandler(FormatSpec &spec) : spec_(spec) {}
 
-  void report_unhandled_arg() {
-    FMT_THROW(FormatError("width is not integer"));
-  }
-
-  template <typename T>
-  unsigned visit_any_int(T value) {
-    typedef typename internal::IntTraits<T>::MainType UnsignedType;
-    UnsignedType width = static_cast<UnsignedType>(value);
-    if (internal::is_negative(value)) {
-      spec_.align_ = ALIGN_LEFT;
-      width = 0 - width;
+    void report_unhandled_arg()
+    {
+        FMT_THROW(FormatError("width is not integer"));
+    }
+
+    template <typename T>
+    unsigned visit_any_int(T value)
+    {
+        typedef typename internal::IntTraits<T>::MainType UnsignedType;
+        UnsignedType width = static_cast<UnsignedType>(value);
+        if (internal::is_negative(value))
+        {
+            spec_.align_ = ALIGN_LEFT;
+            width = 0 - width;
+        }
+        unsigned int_max = std::numeric_limits<int>::max();
+        if (width > int_max)
+            FMT_THROW(FormatError("number is too big"));
+        return static_cast<unsigned>(width);
     }
-    unsigned int_max = std::numeric_limits<int>::max();
-    if (width > int_max)
-      FMT_THROW(FormatError("number is too big"));
-    return static_cast<unsigned>(width);
-  }
 };
 }  // namespace internal
 
@@ -218,314 +278,359 @@ class WidthHandler : public ArgVisitor<WidthHandler, unsigned> {
  */
 template <typename Impl, typename Char, typename Spec>
 class BasicPrintfArgFormatter :
-    public internal::ArgFormatterBase<Impl, Char, Spec> {
- private:
-  void write_null_pointer() {
-    this->spec().type_ = 0;
-    this->write("(nil)");
-  }
-
-  typedef internal::ArgFormatterBase<Impl, Char, Spec> Base;
-
- public:
-  /**
-    \rst
-    Constructs an argument formatter object.
-    *writer* is a reference to the output writer and *spec* contains format
-    specifier information for standard argument types.
-    \endrst
-   */
-  BasicPrintfArgFormatter(BasicWriter<Char> &w, Spec &s)
-  : internal::ArgFormatterBase<Impl, Char, Spec>(w, s) {}
-
-  /** Formats an argument of type ``bool``. */
-  void visit_bool(bool value) {
-    Spec &fmt_spec = this->spec();
-    if (fmt_spec.type_ != 's')
-      return this->visit_any_int(value);
-    fmt_spec.type_ = 0;
-    this->write(value);
-  }
-
-  /** Formats a character. */
-  void visit_char(int value) {
-    const Spec &fmt_spec = this->spec();
-    BasicWriter<Char> &w = this->writer();
-    if (fmt_spec.type_ && fmt_spec.type_ != 'c')
-      w.write_int(value, fmt_spec);
-    typedef typename BasicWriter<Char>::CharPtr CharPtr;
-    CharPtr out = CharPtr();
-    if (fmt_spec.width_ > 1) {
-      Char fill = ' ';
-      out = w.grow_buffer(fmt_spec.width_);
-      if (fmt_spec.align_ != ALIGN_LEFT) {
-        std::fill_n(out, fmt_spec.width_ - 1, fill);
-        out += fmt_spec.width_ - 1;
-      } else {
-        std::fill_n(out + 1, fmt_spec.width_ - 1, fill);
-      }
-    } else {
-      out = w.grow_buffer(1);
+    public internal::ArgFormatterBase<Impl, Char, Spec>
+{
+private:
+    void write_null_pointer()
+    {
+        this->spec().type_ = 0;
+        this->write("(nil)");
     }
-    *out = static_cast<Char>(value);
-  }
 
-  /** Formats a null-terminated C string. */
-  void visit_cstring(const char *value) {
-    if (value)
-      Base::visit_cstring(value);
-    else if (this->spec().type_ == 'p')
-      write_null_pointer();
-    else
-      this->write("(null)");
-  }
+    typedef internal::ArgFormatterBase<Impl, Char, Spec> Base;
 
-  /** Formats a pointer. */
-  void visit_pointer(const void *value) {
-    if (value)
-      return Base::visit_pointer(value);
-    this->spec().type_ = 0;
-    write_null_pointer();
-  }
+public:
+    /**
+      \rst
+      Constructs an argument formatter object.
+      *writer* is a reference to the output writer and *spec* contains format
+      specifier information for standard argument types.
+      \endrst
+     */
+    BasicPrintfArgFormatter(BasicWriter<Char> &w, Spec &s)
+        : internal::ArgFormatterBase<Impl, Char, Spec>(w, s) {}
 
-  /** Formats an argument of a custom (user-defined) type. */
-  void visit_custom(internal::Arg::CustomValue c) {
-    BasicFormatter<Char> formatter(ArgList(), this->writer());
-    const Char format_str[] = {'}', 0};
-    const Char *format = format_str;
-    c.format(&formatter, c.value, &format);
-  }
+    /** Formats an argument of type ``bool``. */
+    void visit_bool(bool value)
+    {
+        Spec &fmt_spec = this->spec();
+        if (fmt_spec.type_ != 's')
+            return this->visit_any_int(value);
+        fmt_spec.type_ = 0;
+        this->write(value);
+    }
+
+    /** Formats a character. */
+    void visit_char(int value)
+    {
+        const Spec &fmt_spec = this->spec();
+        BasicWriter<Char> &w = this->writer();
+        if (fmt_spec.type_ && fmt_spec.type_ != 'c')
+            w.write_int(value, fmt_spec);
+        typedef typename BasicWriter<Char>::CharPtr CharPtr;
+        CharPtr out = CharPtr();
+        if (fmt_spec.width_ > 1)
+        {
+            Char fill = ' ';
+            out = w.grow_buffer(fmt_spec.width_);
+            if (fmt_spec.align_ != ALIGN_LEFT)
+            {
+                std::fill_n(out, fmt_spec.width_ - 1, fill);
+                out += fmt_spec.width_ - 1;
+            }
+            else
+            {
+                std::fill_n(out + 1, fmt_spec.width_ - 1, fill);
+            }
+        }
+        else
+        {
+            out = w.grow_buffer(1);
+        }
+        *out = static_cast<Char>(value);
+    }
+
+    /** Formats a null-terminated C string. */
+    void visit_cstring(const char *value)
+    {
+        if (value)
+            Base::visit_cstring(value);
+        else if (this->spec().type_ == 'p')
+            write_null_pointer();
+        else
+            this->write("(null)");
+    }
+
+    /** Formats a pointer. */
+    void visit_pointer(const void *value)
+    {
+        if (value)
+            return Base::visit_pointer(value);
+        this->spec().type_ = 0;
+        write_null_pointer();
+    }
+
+    /** Formats an argument of a custom (user-defined) type. */
+    void visit_custom(internal::Arg::CustomValue c)
+    {
+        BasicFormatter<Char> formatter(ArgList(), this->writer());
+        const Char format_str[] = {'}', 0};
+        const Char *format = format_str;
+        c.format(&formatter, c.value, &format);
+    }
 };
 
 /** The default printf argument formatter. */
 template <typename Char>
 class PrintfArgFormatter :
-    public BasicPrintfArgFormatter<PrintfArgFormatter<Char>, Char, FormatSpec> {
- public:
-  /** Constructs an argument formatter object. */
-  PrintfArgFormatter(BasicWriter<Char> &w, FormatSpec &s)
-  : BasicPrintfArgFormatter<PrintfArgFormatter<Char>, Char, FormatSpec>(w, s) {}
+    public BasicPrintfArgFormatter<PrintfArgFormatter<Char>, Char, FormatSpec>
+{
+public:
+    /** Constructs an argument formatter object. */
+    PrintfArgFormatter(BasicWriter<Char> &w, FormatSpec &s)
+        : BasicPrintfArgFormatter<PrintfArgFormatter<Char>, Char, FormatSpec>(w, s) {}
 };
 
 /** This template formats data and writes the output to a writer. */
 template <typename Char, typename ArgFormatter = PrintfArgFormatter<Char> >
-class PrintfFormatter : private internal::FormatterBase {
- private:
-  BasicWriter<Char> &writer_;
+class PrintfFormatter : private internal::FormatterBase
+{
+private:
+    BasicWriter<Char> &writer_;
 
-  void parse_flags(FormatSpec &spec, const Char *&s);
+    void parse_flags(FormatSpec &spec, const Char *&s);
 
-  // Returns the argument with specified index or, if arg_index is equal
-  // to the maximum unsigned value, the next argument.
-  internal::Arg get_arg(
-      const Char *s,
-      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.
+    internal::Arg get_arg(
+        const Char *s,
+        unsigned arg_index = (std::numeric_limits<unsigned>::max)());
 
-  // Parses argument index, flags and width and returns the argument index.
-  unsigned parse_header(const Char *&s, FormatSpec &spec);
+    // Parses argument index, flags and width and returns the argument index.
+    unsigned parse_header(const Char *&s, FormatSpec &spec);
 
- public:
-  /**
-   \rst
-   Constructs a ``PrintfFormatter`` object. References to the arguments and
-   the writer are stored in the formatter object so make sure they have
-   appropriate lifetimes.
-   \endrst
-   */
-  explicit PrintfFormatter(const ArgList &al, BasicWriter<Char> &w)
-    : FormatterBase(al), writer_(w) {}
+public:
+    /**
+     \rst
+     Constructs a ``PrintfFormatter`` object. References to the arguments and
+     the writer are stored in the formatter object so make sure they have
+     appropriate lifetimes.
+     \endrst
+     */
+    explicit PrintfFormatter(const ArgList &al, BasicWriter<Char> &w)
+        : FormatterBase(al), writer_(w) {}
 
-  /** Formats stored arguments and writes the output to the writer. */
-  void format(BasicCStringRef<Char> format_str);
+    /** Formats stored arguments and writes the output to the writer. */
+    void format(BasicCStringRef<Char> format_str);
 };
 
 template <typename Char, typename AF>
-void PrintfFormatter<Char, AF>::parse_flags(FormatSpec &spec, const Char *&s) {
-  for (;;) {
-    switch (*s++) {
-      case '-':
-        spec.align_ = ALIGN_LEFT;
-        break;
-      case '+':
-        spec.flags_ |= SIGN_FLAG | PLUS_FLAG;
-        break;
-      case '0':
-        spec.fill_ = '0';
-        break;
-      case ' ':
-        spec.flags_ |= SIGN_FLAG;
-        break;
-      case '#':
-        spec.flags_ |= HASH_FLAG;
-        break;
-      default:
-        --s;
-        return;
+void PrintfFormatter<Char, AF>::parse_flags(FormatSpec &spec, const Char *&s)
+{
+    for (;;)
+    {
+        switch (*s++)
+        {
+        case '-':
+            spec.align_ = ALIGN_LEFT;
+            break;
+        case '+':
+            spec.flags_ |= SIGN_FLAG | PLUS_FLAG;
+            break;
+        case '0':
+            spec.fill_ = '0';
+            break;
+        case ' ':
+            spec.flags_ |= SIGN_FLAG;
+            break;
+        case '#':
+            spec.flags_ |= HASH_FLAG;
+            break;
+        default:
+            --s;
+            return;
+        }
     }
-  }
 }
 
 template <typename Char, typename AF>
 internal::Arg PrintfFormatter<Char, AF>::get_arg(const Char *s,
-                                                 unsigned arg_index) {
-  (void)s;
-  const char *error = FMT_NULL;
-  internal::Arg arg = arg_index == std::numeric_limits<unsigned>::max() ?
-    next_arg(error) : FormatterBase::get_arg(arg_index - 1, error);
-  if (error)
-    FMT_THROW(FormatError(!*s ? "invalid format string" : error));
-  return arg;
+        unsigned arg_index)
+{
+    (void)s;
+    const char *error = FMT_NULL;
+    internal::Arg arg = arg_index == std::numeric_limits<unsigned>::max() ?
+                        next_arg(error) : FormatterBase::get_arg(arg_index - 1, error);
+    if (error)
+        FMT_THROW(FormatError(!*s ? "invalid format string" : error));
+    return arg;
 }
 
 template <typename Char, typename AF>
 unsigned PrintfFormatter<Char, AF>::parse_header(
-  const Char *&s, FormatSpec &spec) {
-  unsigned arg_index = std::numeric_limits<unsigned>::max();
-  Char c = *s;
-  if (c >= '0' && c <= '9') {
-    // Parse an argument index (if followed by '$') or a width possibly
-    // preceded with '0' flag(s).
-    unsigned value = internal::parse_nonnegative_int(s);
-    if (*s == '$') {  // value is an argument index
-      ++s;
-      arg_index = value;
-    } else {
-      if (c == '0')
-        spec.fill_ = '0';
-      if (value != 0) {
-        // Nonzero value means that we parsed width and don't need to
-        // parse it or flags again, so return now.
-        spec.width_ = value;
-        return arg_index;
-      }
+    const Char *&s, FormatSpec &spec)
+{
+    unsigned arg_index = std::numeric_limits<unsigned>::max();
+    Char c = *s;
+    if (c >= '0' && c <= '9')
+    {
+        // Parse an argument index (if followed by '$') or a width possibly
+        // preceded with '0' flag(s).
+        unsigned value = internal::parse_nonnegative_int(s);
+        if (*s == '$')    // value is an argument index
+        {
+            ++s;
+            arg_index = value;
+        }
+        else
+        {
+            if (c == '0')
+                spec.fill_ = '0';
+            if (value != 0)
+            {
+                // Nonzero value means that we parsed width and don't need to
+                // parse it or flags again, so return now.
+                spec.width_ = value;
+                return arg_index;
+            }
+        }
     }
-  }
-  parse_flags(spec, s);
-  // Parse width.
-  if (*s >= '0' && *s <= '9') {
-    spec.width_ = internal::parse_nonnegative_int(s);
-  } else if (*s == '*') {
-    ++s;
-    spec.width_ = internal::WidthHandler(spec).visit(get_arg(s));
-  }
-  return arg_index;
+    parse_flags(spec, s);
+    // Parse width.
+    if (*s >= '0' && *s <= '9')
+    {
+        spec.width_ = internal::parse_nonnegative_int(s);
+    }
+    else if (*s == '*')
+    {
+        ++s;
+        spec.width_ = internal::WidthHandler(spec).visit(get_arg(s));
+    }
+    return arg_index;
 }
 
 template <typename Char, typename AF>
-void PrintfFormatter<Char, AF>::format(BasicCStringRef<Char> format_str) {
-  const Char *start = format_str.c_str();
-  const Char *s = start;
-  while (*s) {
-    Char c = *s++;
-    if (c != '%') continue;
-    if (*s == c) {
-      write(writer_, start, s);
-      start = ++s;
-      continue;
+void PrintfFormatter<Char, AF>::format(BasicCStringRef<Char> format_str)
+{
+    const Char *start = format_str.c_str();
+    const Char *s = start;
+    while (*s)
+    {
+        Char c = *s++;
+        if (c != '%') continue;
+        if (*s == c)
+        {
+            write(writer_, start, s);
+            start = ++s;
+            continue;
+        }
+        write(writer_, start, s - 1);
+
+        FormatSpec spec;
+        spec.align_ = ALIGN_RIGHT;
+
+        // Parse argument index, flags and width.
+        unsigned arg_index = parse_header(s, spec);
+
+        // Parse precision.
+        if (*s == '.')
+        {
+            ++s;
+            if ('0' <= *s && *s <= '9')
+            {
+                spec.precision_ = static_cast<int>(internal::parse_nonnegative_int(s));
+            }
+            else if (*s == '*')
+            {
+                ++s;
+                spec.precision_ = internal::PrecisionHandler().visit(get_arg(s));
+            }
+            else
+            {
+                spec.precision_ = 0;
+            }
+        }
+
+        using internal::Arg;
+        Arg arg = get_arg(s, arg_index);
+        if (spec.flag(HASH_FLAG) && internal::IsZeroInt().visit(arg))
+            spec.flags_ &= ~internal::to_unsigned<int>(HASH_FLAG);
+        if (spec.fill_ == '0')
+        {
+            if (arg.type <= Arg::LAST_NUMERIC_TYPE)
+                spec.align_ = ALIGN_NUMERIC;
+            else
+                spec.fill_ = ' ';  // Ignore '0' flag for non-numeric types.
+        }
+
+        // Parse length and convert the argument to the required type.
+        using internal::ArgConverter;
+        switch (*s++)
+        {
+        case 'h':
+            if (*s == 'h')
+                ArgConverter<signed char>(arg, *++s).visit(arg);
+            else
+                ArgConverter<short>(arg, *s).visit(arg);
+            break;
+        case 'l':
+            if (*s == 'l')
+                ArgConverter<fmt::LongLong>(arg, *++s).visit(arg);
+            else
+                ArgConverter<long>(arg, *s).visit(arg);
+            break;
+        case 'j':
+            ArgConverter<intmax_t>(arg, *s).visit(arg);
+            break;
+        case 'z':
+            ArgConverter<std::size_t>(arg, *s).visit(arg);
+            break;
+        case 't':
+            ArgConverter<std::ptrdiff_t>(arg, *s).visit(arg);
+            break;
+        case 'L':
+            // printf produces garbage when 'L' is omitted for long double, no
+            // need to do the same.
+            break;
+        default:
+            --s;
+            ArgConverter<void>(arg, *s).visit(arg);
+        }
+
+        // Parse type.
+        if (!*s)
+            FMT_THROW(FormatError("invalid format string"));
+        spec.type_ = static_cast<char>(*s++);
+
+        if (spec.type_ == 's')
+        {
+            // set the format type to the default if 's' is specified
+            spec.type_ = internal::DefaultType().visit(arg);
+        }
+
+        if (arg.type <= Arg::LAST_INTEGER_TYPE)
+        {
+            // Normalize type.
+            switch (spec.type_)
+            {
+            case 'i':
+            case 'u':
+                spec.type_ = 'd';
+                break;
+            case 'c':
+                // TODO: handle wchar_t
+                internal::CharConverter(arg).visit(arg);
+                break;
+            }
+        }
+
+        start = s;
+
+        // Format argument.
+        AF(writer_, spec).visit(arg);
     }
-    write(writer_, start, s - 1);
-
-    FormatSpec spec;
-    spec.align_ = ALIGN_RIGHT;
-
-    // Parse argument index, flags and width.
-    unsigned arg_index = parse_header(s, spec);
-
-    // Parse precision.
-    if (*s == '.') {
-      ++s;
-      if ('0' <= *s && *s <= '9') {
-        spec.precision_ = static_cast<int>(internal::parse_nonnegative_int(s));
-      } else if (*s == '*') {
-        ++s;
-        spec.precision_ = internal::PrecisionHandler().visit(get_arg(s));
-      } else {
-        spec.precision_ = 0;
-      }
-    }
-
-    using internal::Arg;
-    Arg arg = get_arg(s, arg_index);
-    if (spec.flag(HASH_FLAG) && internal::IsZeroInt().visit(arg))
-      spec.flags_ &= ~internal::to_unsigned<int>(HASH_FLAG);
-    if (spec.fill_ == '0') {
-      if (arg.type <= Arg::LAST_NUMERIC_TYPE)
-        spec.align_ = ALIGN_NUMERIC;
-      else
-        spec.fill_ = ' ';  // Ignore '0' flag for non-numeric types.
-    }
-
-    // Parse length and convert the argument to the required type.
-    using internal::ArgConverter;
-    switch (*s++) {
-    case 'h':
-      if (*s == 'h')
-        ArgConverter<signed char>(arg, *++s).visit(arg);
-      else
-        ArgConverter<short>(arg, *s).visit(arg);
-      break;
-    case 'l':
-      if (*s == 'l')
-        ArgConverter<fmt::LongLong>(arg, *++s).visit(arg);
-      else
-        ArgConverter<long>(arg, *s).visit(arg);
-      break;
-    case 'j':
-      ArgConverter<intmax_t>(arg, *s).visit(arg);
-      break;
-    case 'z':
-      ArgConverter<std::size_t>(arg, *s).visit(arg);
-      break;
-    case 't':
-      ArgConverter<std::ptrdiff_t>(arg, *s).visit(arg);
-      break;
-    case 'L':
-      // printf produces garbage when 'L' is omitted for long double, no
-      // need to do the same.
-      break;
-    default:
-      --s;
-      ArgConverter<void>(arg, *s).visit(arg);
-    }
-
-    // Parse type.
-    if (!*s)
-      FMT_THROW(FormatError("invalid format string"));
-    spec.type_ = static_cast<char>(*s++);
-
-    if (spec.type_ == 's') {
-      // set the format type to the default if 's' is specified
-      spec.type_ = internal::DefaultType().visit(arg);
-    }
-
-    if (arg.type <= Arg::LAST_INTEGER_TYPE) {
-      // Normalize type.
-      switch (spec.type_) {
-      case 'i': case 'u':
-        spec.type_ = 'd';
-        break;
-      case 'c':
-        // TODO: handle wchar_t
-        internal::CharConverter(arg).visit(arg);
-        break;
-      }
-    }
-
-    start = s;
-
-    // Format argument.
-    AF(writer_, spec).visit(arg);
-  }
-  write(writer_, start, s);
+    write(writer_, start, s);
 }
 
-inline void printf(Writer &w, CStringRef format, ArgList args) {
-  PrintfFormatter<char>(args, w).format(format);
+inline void printf(Writer &w, CStringRef format, ArgList args)
+{
+    PrintfFormatter<char>(args, w).format(format);
 }
 FMT_VARIADIC(void, printf, Writer &, CStringRef)
 
-inline void printf(WWriter &w, WCStringRef format, ArgList args) {
-  PrintfFormatter<wchar_t>(args, w).format(format);
+inline void printf(WWriter &w, WCStringRef format, ArgList args)
+{
+    PrintfFormatter<wchar_t>(args, w).format(format);
 }
 FMT_VARIADIC(void, printf, WWriter &, WCStringRef)
 
@@ -538,17 +643,19 @@ FMT_VARIADIC(void, printf, WWriter &, WCStringRef)
     std::string message = fmt::sprintf("The answer is %d", 42);
   \endrst
 */
-inline std::string sprintf(CStringRef format, ArgList args) {
-  MemoryWriter w;
-  printf(w, format, args);
-  return w.str();
+inline std::string sprintf(CStringRef format, ArgList args)
+{
+    MemoryWriter w;
+    printf(w, format, args);
+    return w.str();
 }
 FMT_VARIADIC(std::string, sprintf, CStringRef)
 
-inline std::wstring sprintf(WCStringRef format, ArgList args) {
-  WMemoryWriter w;
-  printf(w, format, args);
-  return w.str();
+inline std::wstring sprintf(WCStringRef format, ArgList args)
+{
+    WMemoryWriter w;
+    printf(w, format, args);
+    return w.str();
 }
 FMT_VARIADIC_W(std::wstring, sprintf, WCStringRef)
 
@@ -573,8 +680,9 @@ FMT_VARIADIC(int, fprintf, std::FILE *, CStringRef)
     fmt::printf("Elapsed time: %.2f seconds", 1.23);
   \endrst
  */
-inline int printf(CStringRef format, ArgList args) {
-  return fprintf(stdout, format, args);
+inline int printf(CStringRef format, ArgList args)
+{
+    return fprintf(stdout, format, args);
 }
 FMT_VARIADIC(int, printf, CStringRef)
 
@@ -587,11 +695,12 @@ FMT_VARIADIC(int, printf, CStringRef)
     fprintf(cerr, "Don't %s!", "panic");
   \endrst
  */
-inline int fprintf(std::ostream &os, CStringRef format_str, ArgList args) {
-  MemoryWriter w;
-  printf(w, format_str, args);
-  internal::write(os, w);
-  return static_cast<int>(w.size());
+inline int fprintf(std::ostream &os, CStringRef format_str, ArgList args)
+{
+    MemoryWriter w;
+    printf(w, format_str, args);
+    internal::write(os, w);
+    return static_cast<int>(w.size());
 }
 FMT_VARIADIC(int, fprintf, std::ostream &, CStringRef)
 }  // namespace fmt
diff --git a/include/spdlog/fmt/bundled/time.h b/include/spdlog/fmt/bundled/time.h
index c98b0e01..206d0920 100644
--- a/include/spdlog/fmt/bundled/time.h
+++ b/include/spdlog/fmt/bundled/time.h
@@ -19,120 +19,160 @@
 # pragma warning(disable: 4996)  // "deprecated" functions
 #endif
 
-namespace fmt {
+namespace fmt
+{
 template <typename ArgFormatter>
 void format_arg(BasicFormatter<char, ArgFormatter> &f,
-                const char *&format_str, const std::tm &tm) {
-  if (*format_str == ':')
-    ++format_str;
-  const char *end = format_str;
-  while (*end && *end != '}')
-    ++end;
-  if (*end != '}')
-    FMT_THROW(FormatError("missing '}' in format string"));
-  internal::MemoryBuffer<char, internal::INLINE_BUFFER_SIZE> format;
-  format.append(format_str, end + 1);
-  format[format.size() - 1] = '\0';
-  Buffer<char> &buffer = f.writer().buffer();
-  std::size_t start = buffer.size();
-  for (;;) {
-    std::size_t size = buffer.capacity() - start;
-    std::size_t count = std::strftime(&buffer[start], size, &format[0], &tm);
-    if (count != 0) {
-      buffer.resize(start + count);
-      break;
+                const char *&format_str, const std::tm &tm)
+{
+    if (*format_str == ':')
+        ++format_str;
+    const char *end = format_str;
+    while (*end && *end != '}')
+        ++end;
+    if (*end != '}')
+        FMT_THROW(FormatError("missing '}' in format string"));
+    internal::MemoryBuffer<char, internal::INLINE_BUFFER_SIZE> format;
+    format.append(format_str, end + 1);
+    format[format.size() - 1] = '\0';
+    Buffer<char> &buffer = f.writer().buffer();
+    std::size_t start = buffer.size();
+    for (;;)
+    {
+        std::size_t size = buffer.capacity() - start;
+        std::size_t count = std::strftime(&buffer[start], size, &format[0], &tm);
+        if (count != 0)
+        {
+            buffer.resize(start + count);
+            break;
+        }
+        if (size >= format.size() * 256)
+        {
+            // If the buffer is 256 times larger than the format string, assume
+            // that `strftime` gives an empty result. There doesn't seem to be a
+            // better way to distinguish the two cases:
+            // https://github.com/fmtlib/fmt/issues/367
+            break;
+        }
+        const std::size_t MIN_GROWTH = 10;
+        buffer.reserve(buffer.capacity() + (size > MIN_GROWTH ? size : MIN_GROWTH));
     }
-    if (size >= format.size() * 256) {
-      // If the buffer is 256 times larger than the format string, assume
-      // that `strftime` gives an empty result. There doesn't seem to be a
-      // better way to distinguish the two cases:
-      // https://github.com/fmtlib/fmt/issues/367
-      break;
-    }
-    const std::size_t MIN_GROWTH = 10;
-    buffer.reserve(buffer.capacity() + (size > MIN_GROWTH ? size : MIN_GROWTH));
-  }
-  format_str = end + 1;
+    format_str = end + 1;
 }
 
-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<>();
+}
 }
 
 // Thread-safe replacement for std::localtime
-inline std::tm localtime(std::time_t time) {
-  struct LocalTime {
-    std::time_t time_;
-    std::tm tm_;
+inline std::tm localtime(std::time_t time)
+{
+    struct LocalTime
+    {
+        std::time_t time_;
+        std::tm tm_;
 
-    LocalTime(std::time_t t): time_(t) {}
+        LocalTime(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;
-    }
-  };
-  LocalTime lt(time);
-  if (lt.run())
-    return lt.tm_;
-  // Too big time values may be unsupported.
-  FMT_THROW(fmt::FormatError("time_t value out of range"));
-  return std::tm();
+        bool fallback(internal::Null<>)
+        {
+            using namespace fmt::internal;
+            std::tm *tm = std::localtime(&time_);
+            if (tm) tm_ = *tm;
+            return tm != FMT_NULL;
+        }
+    };
+    LocalTime lt(time);
+    if (lt.run())
+        return lt.tm_;
+    // Too big time values may be unsupported.
+    FMT_THROW(fmt::FormatError("time_t value out of range"));
+    return std::tm();
 }
 
 // Thread-safe replacement for std::gmtime
-inline std::tm gmtime(std::time_t time) {
-  struct GMTime {
-    std::time_t time_;
-    std::tm tm_;
+inline std::tm gmtime(std::time_t time)
+{
+    struct GMTime
+    {
+        std::time_t time_;
+        std::tm tm_;
 
-    GMTime(std::time_t t): time_(t) {}
+        GMTime(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 != FMT_NULL) tm_ = *tm;
-      return tm != FMT_NULL;
-    }
-  };
-  GMTime gt(time);
-  if (gt.run())
-    return gt.tm_;
-  // Too big time values may be unsupported.
-  FMT_THROW(fmt::FormatError("time_t value out of range"));
-  return std::tm();
+        bool fallback(internal::Null<>)
+        {
+            std::tm *tm = std::gmtime(&time_);
+            if (tm != FMT_NULL) tm_ = *tm;
+            return tm != FMT_NULL;
+        }
+    };
+    GMTime gt(time);
+    if (gt.run())
+        return gt.tm_;
+    // Too big time values may be unsupported.
+    FMT_THROW(fmt::FormatError("time_t value out of range"));
+    return std::tm();
 }
 } //namespace fmt
 
diff --git a/include/spdlog/spdlog.h b/include/spdlog/spdlog.h
index 447fe19e..534180dd 100644
--- a/include/spdlog/spdlog.h
+++ b/include/spdlog/spdlog.h
@@ -169,11 +169,11 @@ void drop_all();
 #define SPDLOG_STR_H(x) #x
 #define SPDLOG_STR_HELPER(x) SPDLOG_STR_H(x)
 #ifdef _MSC_VER
-  #define SPDLOG_TRACE(logger, ...) logger->trace("[ " __FILE__ "(" SPDLOG_STR_HELPER(__LINE__) ") ] " __VA_ARGS__)
-  #define SPDLOG_TRACE_IF(logger, flag, ...) logger->trace_if(flag, "[ " __FILE__ "(" SPDLOG_STR_HELPER(__LINE__) ") ] " __VA_ARGS__)
+#define SPDLOG_TRACE(logger, ...) logger->trace("[ " __FILE__ "(" SPDLOG_STR_HELPER(__LINE__) ") ] " __VA_ARGS__)
+#define SPDLOG_TRACE_IF(logger, flag, ...) logger->trace_if(flag, "[ " __FILE__ "(" SPDLOG_STR_HELPER(__LINE__) ") ] " __VA_ARGS__)
 #else
-  #define SPDLOG_TRACE(logger, ...) logger->trace("[ " __FILE__ ":" SPDLOG_STR_HELPER(__LINE__) " ] " __VA_ARGS__)
-  #define SPDLOG_TRACE_IF(logger, flag, ...) logger->trace_if(flag, "[ " __FILE__ ":" SPDLOG_STR_HELPER(__LINE__) " ] " __VA_ARGS__)
+#define SPDLOG_TRACE(logger, ...) logger->trace("[ " __FILE__ ":" SPDLOG_STR_HELPER(__LINE__) " ] " __VA_ARGS__)
+#define SPDLOG_TRACE_IF(logger, flag, ...) logger->trace_if(flag, "[ " __FILE__ ":" SPDLOG_STR_HELPER(__LINE__) " ] " __VA_ARGS__)
 #endif
 #else
 #define SPDLOG_TRACE(logger, ...)
diff --git a/tests/includes.h b/tests/includes.h
index 6c2a539f..637e6bc2 100644
--- a/tests/includes.h
+++ b/tests/includes.h
@@ -10,8 +10,8 @@
 #include "catch.hpp"
 #include "utils.h"
 
-#define SPDLOG_TRACE_ON
-#define SPDLOG_DEBUG_ON
+#define SPDLOG_TRACE_ON
+#define SPDLOG_DEBUG_ON
 
 #include "../include/spdlog/spdlog.h"
 #include "../include/spdlog/sinks/null_sink.h"
diff --git a/tests/test_macros.cpp b/tests/test_macros.cpp
index ba29d3d4..8ad7bd41 100644
--- a/tests/test_macros.cpp
+++ b/tests/test_macros.cpp
@@ -6,45 +6,45 @@
 
 TEST_CASE("debug and trace w/o format string", "[macros]]")
 {
-	prepare_logdir();
-	std::string filename = "logs/simple_log";
+    prepare_logdir();
+    std::string filename = "logs/simple_log";
 
-	auto logger = spdlog::create<spdlog::sinks::simple_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();
-	
-	REQUIRE(ends_with(file_contents(filename), "Test message 2\n"));
-	REQUIRE(count_lines(filename) == 2);
+    auto logger = spdlog::create<spdlog::sinks::simple_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();
+
+    REQUIRE(ends_with(file_contents(filename), "Test message 2\n"));
+    REQUIRE(count_lines(filename) == 2);
 }
 
 
 TEST_CASE("debug and trace with format strings", "[macros]]")
 {
-	prepare_logdir();
-	std::string filename = "logs/simple_log";
+    prepare_logdir();
+    std::string filename = "logs/simple_log";
 
-	auto logger = spdlog::create<spdlog::sinks::simple_file_sink_mt>("logger", filename);
-	logger->set_pattern("%v");
-	logger->set_level(spdlog::level::trace);
+    auto logger = spdlog::create<spdlog::sinks::simple_file_sink_mt>("logger", filename);
+    logger->set_pattern("%v");
+    logger->set_level(spdlog::level::trace);
 
 #if !defined(SPDLOG_FMT_PRINTF)
-	SPDLOG_TRACE(logger, "Test message {}", 1);
-	//SPDLOG_DEBUG(logger, "Test message 2");	
-	SPDLOG_DEBUG(logger, "Test message {}", 222);
+    SPDLOG_TRACE(logger, "Test message {}", 1);
+    //SPDLOG_DEBUG(logger, "Test message 2");
+    SPDLOG_DEBUG(logger, "Test message {}", 222);
 #else
-	SPDLOG_TRACE(logger, "Test message %d", 1);
-	//SPDLOG_DEBUG(logger, "Test message 2");	
-	SPDLOG_DEBUG(logger, "Test message %d", 222);
+    SPDLOG_TRACE(logger, "Test message %d", 1);
+    //SPDLOG_DEBUG(logger, "Test message 2");
+    SPDLOG_DEBUG(logger, "Test message %d", 222);
 #endif
 
-	logger->flush();
+    logger->flush();
 
-	REQUIRE(ends_with(file_contents(filename), "Test message 222\n"));
-	REQUIRE(count_lines(filename) == 2);
+    REQUIRE(ends_with(file_contents(filename), "Test message 222\n"));
+    REQUIRE(count_lines(filename) == 2);
 }
 
diff --git a/tests/utils.cpp b/tests/utils.cpp
index d454b2d6..e179147b 100644
--- a/tests/utils.cpp
+++ b/tests/utils.cpp
@@ -49,8 +49,8 @@ std::size_t get_filesize(const std::string& filename)
 
 
 // source: https://stackoverflow.com/a/2072890/192001
-bool ends_with(std::string const & value, std::string const & ending)
-{
-	if (ending.size() > value.size()) return false;
-	return std::equal(ending.rbegin(), ending.rend(), value.rbegin());
+bool ends_with(std::string const & value, std::string const & ending)
+{
+    if (ending.size() > value.size()) return false;
+    return std::equal(ending.rbegin(), ending.rend(), value.rbegin());
 }