diff --git a/CMakeLists.txt b/CMakeLists.txt
index 506b59f2c..982d24564 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -27,7 +27,7 @@ option(lib_utc_datetime "Build library with UTC date/time logging" OFF)
 
 set(ELPP_MAJOR_VERSION "9")
 set(ELPP_MINOR_VERSION "96")
-set(ELPP_PATCH_VERSION "4")
+set(ELPP_PATCH_VERSION "5")
 set(ELPP_VERSION_STRING "${ELPP_MAJOR_VERSION}.${ELPP_MINOR_VERSION}.${ELPP_PATCH_VERSION}")
 
 set(ELPP_INCLUDE_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/include" CACHE PATH "The directory the headers are installed in")
diff --git a/README.md b/README.md
index 6295144e5..2ee3912a6 100644
--- a/README.md
+++ b/README.md
@@ -4,7 +4,7 @@
 
 ![banner]
 
-> **Manual For v9.96.4**
+> **Manual For v9.96.5**
 
 [![Build Status (Master)](https://img.shields.io/travis/muflihun/easyloggingpp/master.svg)](#build-matrix)
 [![Build Status (Develop)](https://img.shields.io/travis/muflihun/easyloggingpp/develop.svg)](#build-matrix)
@@ -22,9 +22,9 @@
 ### Quick Links
 
   [![download] Latest Release](https://github.com/muflihun/easyloggingpp/releases/latest)
-  
+
   [![notes] Changelog](/CHANGELOG.md)
- 
+
   [![samples] Samples](/samples)
 
 ---
@@ -107,21 +107,21 @@
 # Overview
 Easylogging++ is single header efficient logging library for C++ applications. It is extremely powerful, highly extendable and configurable to user's requirements. It provides ability to [write your own _sinks_](/samples/send-to-network) (via featured referred as `LogDispatchCallback`). This library is currently used by [hundreds of open-source projects on github](https://github.com/search?q=%22easylogging%2B%2B.h%22&type=Code&utf8=%E2%9C%93) and other open-source source control management sites.
 
-This manual is for Easylogging++ v9.96.4. For other versions please refer to corresponding [release](https://github.com/muflihun/easyloggingpp/releases) on github.
+This manual is for Easylogging++ v9.96.5. For other versions please refer to corresponding [release](https://github.com/muflihun/easyloggingpp/releases) on github.
 
 > You may also be interested in [Residue](https://github.com/muflihun/residue/) logging server.
 
  [![top] Goto Top](#table-of-contents)
- 
+
 ### Why yet another library
-If you are working on a small utility or large project in C++, this library can be handy. Its based on single header and only requires to link to single source file. (Originally it was header-only and was changed to use source file in [issue #445](https://github.com/muflihun/easyloggingpp/issues/445). You can still use header-only in [v9.89](https://github.com/muflihun/easyloggingpp/releases/tag/9.89)). 
+If you are working on a small utility or large project in C++, this library can be handy. Its based on single header and only requires to link to single source file. (Originally it was header-only and was changed to use source file in [issue #445](https://github.com/muflihun/easyloggingpp/issues/445). You can still use header-only in [v9.89](https://github.com/muflihun/easyloggingpp/releases/tag/9.89)).
 
 This library has been designed with various thoughts in mind (i.e, portability, performance, usability, features and easy to setup).
 
 Why yet another library? Well, answer is pretty straight forward, use it as you wrote it so you can fix issues (if any) as you go or raise them on github. In addition to that, I personally have not seen any logging library based on single-header with such a design where you can configure on the go, extend it to your needs and get fast performance. I have seen other single-header logging libraries for C++ but either they use external libraries, e.g, boost or Qt to support certain features like threading, regular expression or date etc. This library has everything built-in to prevent usage of external libraries, not that I don't like those libraries, in fact I love them, but because not all projects use these libraries, I couldn't take risk of depending on them.
 
  [![top] Goto Top](#table-of-contents)
- 
+
 ### Features at a glance
 Easylogging++ is feature-rich containing many features that both typical and advanced developer will require while writing a software;
  * [Highly configurable](#configuration)
@@ -142,7 +142,7 @@ Easylogging++ is feature-rich containing many features that both typical and adv
  * [And many more...](#extra-features)
 
  [![top] Goto Top](#table-of-contents)
- 
+
 # Getting Started
 ### Download
 Download latest version from [Latest Release](https://github.com/muflihun/easyloggingpp/releases/latest)
@@ -150,7 +150,7 @@ Download latest version from [Latest Release](https://github.com/muflihun/easylo
 For other releases, please visit [releases page](https://github.com/muflihun/easyloggingpp/releases). If you application does not support C++11, please consider using [v8.91](https://github.com/muflihun/easyloggingpp/tree/v8.91). This is stable version for C++98 and C++03, just lack some features.
 
  [![top] Goto Top](#table-of-contents)
- 
+
 ### Quick Start
 In order to get started with Easylogging++, you can follow three easy steps:
 * Download latest version
@@ -190,12 +190,12 @@ make install
 Following options are supported by Easylogging++ cmake and you can turn these options on using `-D<option>=ON`
 
  * `lib_utc_datetime` - Defines `ELPP_UTC_DATETIME`
- * `build_static_lib` - Builds static library for Easylogging++ 
+ * `build_static_lib` - Builds static library for Easylogging++
 
 With that said, you will still need `easylogging++.cc` file in order to compile. For header only, please check [v9.89](https://github.com/muflihun/easyloggingpp/releases/tag/9.89) and lower.
 
  [![top] Goto Top](#table-of-contents)
- 
+
 ### Setting Application Arguments
 It is always recommended to pass application arguments to Easylogging++. Some features of Easylogging++ require you to set application arguments, e.g, verbose logging to set verbose level or vmodules (explained later). In order to do that you can use helper macro or helper class;
 
@@ -206,7 +206,7 @@ int main(int argc, char* argv[]) {
 }
 ```
  [![top] Goto Top](#table-of-contents)
- 
+
 # Configuration
 ### Level
 In order to start configuring your logging library, you must understand severity levels. Easylogging++ deliberately does not use hierarchical logging in order to fully control what's enabled and what's not. That being said, there is still option to use hierarchical logging using `LoggingFlag::HierarchicalLogging`. Easylogging++ has following levels (ordered for hierarchical levels)
@@ -224,7 +224,7 @@ In order to start configuring your logging library, you must understand severity
 | Unknown  | Only applicable to hierarchical logging and is used to turn off logging completely.                                                                           |
 
  [![top] Goto Top](#table-of-contents)
- 
+
 ### Configure
 Easylogging++ is easy to configure. There are three possible ways to do so,
 * Using configuration file
@@ -253,7 +253,7 @@ Following table contains configurations supported by configuration file.
 | `Performance_Tracking`  |   bool   | Determines whether or not performance tracking is enabled. This does not depend on logger or level. Performance tracking always uses 'performance' logger unless specified|
 | `Max_Log_File_Size`     |   size_t | If log file size of corresponding level is >= specified size, log file will be truncated.                                                                                 |
 | `Log_Flush_Threshold`   |  size_t  | Specifies number of log entries to hold until we flush pending log data                                                                                                   |
-	
+
 
 Please do not use double-quotes anywhere in comment, you might end up in unexpected behaviour.
 
@@ -273,7 +273,7 @@ Sample Configuration File
    FORMAT               = "%datetime{%d/%M} %func %msg"
 ```
 
-##### Explanation 
+##### Explanation
 Configuration file contents in above sample is straightforward. We start with `GLOBAL` level in order to override all the levels. Any explicitly defined subsequent level will override configuration from `GLOBAL`. For example, all the levels except for `DEBUG` have the same format, i.e, datetime and log message. For `DEBUG` level, we have only date (with day and month), source function and log message. The rest of configurations for `DEBUG` are used from `GLOBAL`. Also, notice `{%d/%M}` in `DEBUG` format above, if you do not specify date format, default format is used. Default values of date/time is `%d/%M/%Y %h:%m:%s,%g` For more information on these format specifiers, please refer to [Date/Time Format Specifier](#datetime-format-specifiers) section below
 
 ##### Usage
@@ -296,7 +296,7 @@ int main(int argc, const char** argv) {
  > Your configuration file can be converted to `el::Configurations` object (using constructor) that can be used where ever it is needed (like in above example).
 
  [![top] Goto Top](#table-of-contents)
- 
+
 #### Using el::Configurations Class
 You can set configurations or reset configurations;
 ```c++
@@ -308,7 +308,7 @@ int main(int argc, const char** argv) {
    el::Configurations defaultConf;
    defaultConf.setToDefault();
     // Values are always std::string
-   defaultConf.set(el::Level::Info, 
+   defaultConf.set(el::Level::Info,
             el::ConfigurationType::Format, "%datetime %level %msg");
     // default logger uses default configurations
     el::Loggers::reconfigureLogger("default", defaultConf);
@@ -324,7 +324,7 @@ int main(int argc, const char** argv) {
  > Configuration just needs to be set once. If you are happy with default configuration, you may use it as well.
 
  [![top] Goto Top](#table-of-contents)
- 
+
 #### Using In line Configurations
 Inline configuration means you can set configurations in `std::string` but make sure you add all the new line characters etc. This is not recommended because it's always messy.
 ```c++
@@ -336,12 +336,12 @@ c.parseFromText("*GLOBAL:\n FORMAT = %level %msg");
  > Above code only sets Configurations object, you still need to re-configure logger/s using this configurations.
 
  [![top] Goto Top](#table-of-contents)
- 
+
 ### Default Configurations
 If you wish to have a configuration for existing and future loggers, you can use `el::Loggers::setDefaultConfigurations(el::Configurations& configurations, bool configureExistingLoggers = false)`. This is useful when you are working on fairly large scale, or using a third-party library that is already using Easylogging++. Any newly created logger will use default configurations. If you wish to configure existing loggers as well, you can set second argument to `true` (it defaults to `false`).
 
  [![top] Goto Top](#table-of-contents)
- 
+
 ### Global Configurations
 `Level::Global` is nothing to do with global configurations, it is concept where you can register configurations for all/or some loggers and even register new loggers using configuration file. Syntax of configuration file is:
 ```
@@ -366,7 +366,7 @@ int main(void) {
 Please note, it is not possible to register new logger using global configuration without defining its configuration. You must define at least single configuration. Other ways to register loggers are discussed in [Logging](#logging) section below.
 
  [![top] Goto Top](#table-of-contents)
- 
+
 ### Logging Format Specifiers
 You can customize format of logging using following specifiers:
 
@@ -389,10 +389,10 @@ You can customize format of logging using following specifiers:
 | `%msg`          | Actual log message                                                                          |
 | `%`             | Escape character (e.g, %%level will write %level)                                           |
 
-* Subject to compiler's availability of certain macros, e.g, `__LINE__`, `__FILE__` etc 
+* Subject to compiler's availability of certain macros, e.g, `__LINE__`, `__FILE__` etc
 
  [![top] Goto Top](#table-of-contents)
- 
+
 ### Date/Time Format Specifiers
 You can customize date/time format using following specifiers
 
@@ -436,7 +436,7 @@ int main(void) {
 ```
 
  [![top] Goto Top](#table-of-contents)
- 
+
 ### Logging Flags
 Form some parts of logging you can set logging flags; here are flags supported:
 
@@ -457,6 +457,7 @@ Form some parts of logging you can set logging flags; here are flags supported:
 | `CreateLoggerAutomatically (4096)`                          | Creates logger automatically when not available. |
 | `AutoSpacing (8192)`                          | Automatically adds spaces. E.g, `LOG(INFO) << "DODGE" << "THIS!";` will output "DODGE THIS!"|
 | `FixedTimeFormat (16384)`                          | Applicable to performace tracking only - this prevents formatting time. E.g, `1001 ms` will be logged as is, instead of formatting it as `1.01 sec`|
+| `IgnoreSigInt (32768)`                          | When application crashes ignore Interruption signal |
 
 You can set/unset these flags by using static `el::Loggers::addFlag` and `el::Loggers::removeFlag`. You can check to see if certain flag is available by using `el::Loggers::hasFlag`, all these functions take strongly-typed enum `el::LoggingFlag`
 
@@ -523,19 +524,19 @@ Some of logging options can be set by macros, this is a thoughtful decision, for
 | `ELPP_NO_GLOBAL_LOCK`  | Do not lock the whole storage on dispatch. This should be used with care. See [issue #580](https://github.com/muflihun/easyloggingpp/issues/580)|
 
  [![top] Goto Top](#table-of-contents)
- 
+
 ### Reading Configurations
 If you wish to read configurations of certain logger, you can do so by using `typedConfigurations()` function in Logger class.
 ```c++
 el::Logger* l = el::Loggers::getLogger("default");
 bool enabled = l->typedConfigurations()->enabled(el::Level::Info);
 // Or to read log format/pattern
-std::string format = 
+std::string format =
         l->typedConfigurations()->logFormat(el::Level::Info).format();
 ```
 
  [![top] Goto Top](#table-of-contents)
- 
+
 # Logging
 Logging in easylogging++ is done using collection of macros. This is to make it easier for user and to prevent them knowing about unnecessary greater details of how things are done.
 
@@ -578,9 +579,9 @@ UpdateManager::UpdateManager {
  > You can also write logs by using `Logger` class directly. This feature is available on compilers that support variadic templates. You can explore more by looking at `samples/STL/logger-log-functions.cpp`.
 
  [![top] Goto Top](#table-of-contents)
- 
+
 ### Conditional Logging
-Easylogging++ provides certain aspects of logging, one these aspects is conditional logging, i.e, log will be written only if certain condition fulfils. This comes very handy in some situations. 
+Easylogging++ provides certain aspects of logging, one these aspects is conditional logging, i.e, log will be written only if certain condition fulfils. This comes very handy in some situations.
 Helper macros end with _IF;
 * `LOG_IF(condition, LEVEL)`
 * `CLOG_IF(condition, LEVEL, logger ID)`
@@ -597,7 +598,7 @@ CLOG_IF(true, INFO, "performance") << "Always logged (performance logger)"
 Same macros are available for verbose logging with `V` in the beginning, i.e, `VLOG_IF` and `CVLOG_IF`. see verbose logging section below for further information. You may have as complicated conditions as you want depending on your need.
 
  [![top] Goto Top](#table-of-contents)
- 
+
 ### Occasional Logging
 Occasional logging is another useful aspect of logging with Easylogging++. This means a log will be written if it's hit certain times or part of certain times, e.g, every 10th hit or 100th hit or 2nd hit.
 Helper macros end with `_EVERY_N`;
@@ -630,14 +631,14 @@ for (int i = 1; i <= 100; ++i) {
  > Same versions of macros are available for `DEBUG` only mode, these macros start with `D` (for debug) followed by the same name. e.g, `DLOG` to log only in debug mode (i.e, when `_DEBUG` is defined or `NDEBUG` is undefined)
 
  [![top] Goto Top](#table-of-contents)
- 
+
 ### `printf` Like Logging
 For compilers that support C++11's variadic templates, ability to log like "printf" is available. This is done by using `Logger` class. This feature is thread and type safe (as we do not use any macros like `LOG(INFO)` etc)
 
 This is done in two steps:
  1. Pulling registered logger using `el::Loggers::getLogger(<logger_id>);`
  2. Using one of logging functions
- 
+
 The only difference from `printf` is that logging using these functions require `%v` for each arg (This is for type-safety); instead of custom format specifiers. You can escape this by `%%v`
 
 Following are various function signatures:
@@ -648,7 +649,7 @@ Following are various function signatures:
  * `fatal(const char*, const T&, const Args&...)`
  * `trace(const char*, const T&, const Args&...)`
  * `verbose(int vlevel, const char*, const T&, const Args&...)`
- 
+
 #### Simple example:
 
 ```c++
@@ -682,7 +683,7 @@ Verbose logging is useful in every software to record more information than usua
 * `CVLOG(verbose-level, logger ID)`
 
  [![top] Goto Top](#table-of-contents)
- 
+
 #### Conditional and Occasional Logging
 Verbose logging also has conditional and occasional logging aspects i.e,
 * `VLOG_IF(condition, verbose-level)`
@@ -696,14 +697,14 @@ Verbose logging also has conditional and occasional logging aspects i.e,
 
  [![top] Goto Top](#table-of-contents)
 
- 
+
 #### Verbose-Level
 Verbose level is level of verbosity that can have range of 1-9. Verbose level will not be active unless you either set application arguments for it. Please read through [Application Arguments](#application-arguments) section to understand more about verbose logging.
 
 In order to change verbose level on the fly, please use `Loggers::setVerboseLevel(base::type::VerboseLevel)` aka `Loggers::setVerboseLevel(int)` function. (You can check current verbose level by `Loggers::verboseLevel()`
 
  [![top] Goto Top](#table-of-contents)
- 
+
 #### Check If Verbose Logging Is On
 You can use a macro `VLOG_IS_ON(verbose-level)` to check to see if certain logging is on for source file for specified verbose level. This returns boolean that you can embed into if condition.
 ```c++
@@ -713,7 +714,7 @@ if (VLOG_IS_ON(2)) {
 ```
 
  [![top] Goto Top](#table-of-contents)
- 
+
 #### VModule
 VModule is functionality for verbose logging (as mentioned in above table) where you can specify verbosity by modules/source file. Following are some examples with explanation; Any of vmodule below starts with `-vmodule=` and `LoggingFlag::DisableVModulesExtensions` flag not set. Vmodule can completely be disabled by adding flag `LoggingFlag::DisableVModules`
 
@@ -734,7 +735,7 @@ Example with no `LoggingFlag::AllowVerboseIfModuleNotSpecified` flag;
 In order to change vmodules on the fly (instead of via command line args) - use `Loggers::setVModules(const char*)` where `const char*` represents the modules e.g, `main=3,parser*=4` (as per above example)
 
  [![top] Goto Top](#table-of-contents)
- 
+
 ### Registering New Loggers
 Loggers are unique in logger repository by ID. You can register new logger the same way as you would get logger. Using `getLogger(.., ..)` from `el::Loggers` helper class. This function takes two params, first being ID and second being boolean (optional) to whether or not to register new logger if does not already exist and returns pointer to existing (or newly created) el::Logger class. This second param is optional and defaults to true. If you set it to false and logger does not exist already, it will return nullptr.
 
@@ -746,7 +747,7 @@ By default, Easylogging++ registers three loggers (+ an internal logger);
 If you wish to register a new logger, say e.g, with ID `business`
 ```c++
 el::Logger* businessLogger = el::Loggers::getLogger("business");
-```	
+```
 
 This will register a new logger if it does not already exist otherwise it will get an existing one. But if you have passed in `false` to the second param and logger does not already exist, `businessLogger` will be nullptr.
 
@@ -773,7 +774,7 @@ Let's say we have an application that uses easylogging++ and has its own configu
 
  * Instead of using `INITIALIZE_EASYLOGGINGPP` you use `SHARE_EASYLOGGINGPP(access-function-to-repository)`
  * Instead of using `INITIALIZE_EASYLOGGINGPP` you use `INITIALIZE_NULL_EASYLOGGINGPP` and then `el::Helpers::setStorage(el::base::type::StoragePointer)`
- 
+
 After you share repository, you can reconfigure the only repository (i.e, the one that is used by application and library both), and use both to write logs.
 
  [![top] Goto Top](#table-of-contents)
@@ -786,14 +787,14 @@ Some features require you to define macros (marked as prerequisite in each secti
 ### Performance Tracking
 Prerequisite: Define macro `ELPP_FEATURE_PERFORMANCE_TRACKING`
 
-One of the most notable features of Easylogging++ is its ability to track performance of your function or block of function. 
+One of the most notable features of Easylogging++ is its ability to track performance of your function or block of function.
 Please note, this is not backward compatible as previously we had macros that user must had defined in order to track performance and I am sure many users had avoided in doing so. (Read v8.91 ReadMe for older way of doing it)
 The new way of tracking performance is much easier and reliable. All you need to do is use one of two macros from where you want to start tracking.
 * `TIMED_FUNC(obj-name)`
 * `TIMED_SCOPE(obj-name, block-name)`
 * `TIMED_BLOCK(obj-name, block-name)`
 
-An example that just uses usleep 
+An example that just uses usleep
 ```c++
 void performHeavyTask(int iter) {
    TIMED_FUNC(timerObj);
@@ -807,7 +808,7 @@ void performHeavyTask(int iter) {
    }
 }
 ```
-	 
+
 The result of above execution for iter = 10, is as following
 ```
 06:22:31,368 INFO Executed [heavy-iter] in [10 ms]
@@ -825,7 +826,7 @@ The result of above execution for iter = 10, is as following
 
 In the above example, we have used both the macros. In line-2 we have `TIMED_FUNC` with object pointer name timerObj and line-7 we have TIMED_SCOPE with object pointer name `timerBlkObj` and block name `heavy-iter`. Notice how block name is thrown out to the logs with every hit.  (Note: `TIMED_FUNC` is `TIMED_SCOPE` with block name = function name)
 
-You might wonder why do we need object name. Well easylogging++ performance tracking feature takes it further and provides ability to add, what's called checkpoints. 
+You might wonder why do we need object name. Well easylogging++ performance tracking feature takes it further and provides ability to add, what's called checkpoints.
 Checkpoints have two macros:
 * `PERFORMANCE_CHECKPOINT(timed-block-obj-name)`
 * `PERFORMANCE_CHECKPOINT_WITH_ID(timed-block-obj-name, id)`
@@ -900,12 +901,12 @@ Notes:
  > You may be interested in [python script to parse performance logs](https://github.com/muflihun/easyloggingpp/issues/206)
 
  [![top] Goto Top](#table-of-contents)
- 
+
 #### Conditional Performance Tracking
 If you want to enable performance tracking for certain conditions only, e.g. based on a certain verbosity level, you can use the variants `TIMED_FUNC_IF` or `TIMED_SCOPE_IF`.
- 
+
  A verbosity level example is given below
- 
+
 ```c++
  void performHeavyTask(int iter) {
     // enable performance tracking for verbosity level 4 or higher
@@ -915,7 +916,7 @@ If you want to enable performance tracking for certain conditions only, e.g. bas
 ```
 
  [![top] Goto Top](#table-of-contents)
- 
+
 #### Make Use of Performance Tracking Data
 If you wish to capture performance tracking data right after it is finished, you can do so by extending `el::PerformanceTrackingCallback`.
 
@@ -942,7 +943,7 @@ There is a [sample](/samples/STL/logrotate.cpp) available that you can use as ba
 ### Crash Handling
 Prerequisite: Define macro `ELPP_FEATURE_CRASH_LOG`
 
-Easylogging++ provides ability to handle unexpected crashes for GCC compilers. This is active by default and can be disabled by defining macro `ELPP_DISABLE_DEFAULT_CRASH_HANDLING`. By doing so you are telling library not to handle any crashes. Later on if you wish to handle crash yourself, you can assign crash handler of type void func(int) where int is signal caught. 
+Easylogging++ provides ability to handle unexpected crashes for GCC compilers. This is active by default and can be disabled by defining macro `ELPP_DISABLE_DEFAULT_CRASH_HANDLING`. By doing so you are telling library not to handle any crashes. Later on if you wish to handle crash yourself, you can assign crash handler of type void func(int) where int is signal caught.
 
 Following signals are handled;
 * SIGABRT (If `ELPP_HANDLE_SIGABRT` macro is defined)
@@ -965,7 +966,7 @@ Following are some useful macros that you can define to change the behaviour
  [![top] Goto Top](#table-of-contents)
 
 #### Installing Custom Crash Handlers
-You can use your own crash handler by using `el::Helpers::setCrashHandler(const el::base::debug::CrashHandler::Handler&);`. 
+You can use your own crash handler by using `el::Helpers::setCrashHandler(const el::base::debug::CrashHandler::Handler&);`.
 
 > Make sure to abort application at the end of your crash handler using `el::Helpers::crashAbort(int)`. If you fail to do so, you will get into endless loop of crashes.
 
@@ -1007,14 +1008,14 @@ Prerequisite: Define macro `ELPP_FEATURE_CRASH_LOG`
 Easylogging++ supports stack trace printing for GCC compilers. You can print stack trace at anytime by calling `el::base::debug::StackTrace()`, formatting will be done automatically. Note, if you are using non-GCC compiler, you will end-up getting empty output.
 
  [![top] Goto Top](#table-of-contents)
- 
+
 ### Multi-threading
 Prerequisite: Define macro `ELPP_THREAD_SAFE`
 
 Easylogging++ is thread-safe. By default thread-safety is disabled. You can enable it by defining `ELPP_THREAD_SAFE` otherwise you will see unexpected results. This is intentional to make library efficient for single threaded application.
 
  [![top] Goto Top](#table-of-contents)
- 
+
 ### CHECK Macros
 Easylogging++ supports CHECK macros, with these macros you can quickly check whether certain condition fulfills or not. If not Easylogging++ writes FATAL log, causing application to stop (unless defined macro to prevent stopping application on fatal).
 
@@ -1037,7 +1038,7 @@ Easylogging++ supports CHECK macros, with these macros you can quickly check whe
 > Same versions of macros are available for `DEBUG` only mode, these macros start with `D` (for debug) followed by the same name. e.g, `DCHECK` to check only in debug mode (i.e, when `_DEBUG` is defined or `NDEBUG` is undefined)
 
  [![top] Goto Top](#table-of-contents)
- 
+
 ### Logging perror()
 Easylogging++ supports `perror()` styled logging using `PLOG(LEVEL)`, `PLOG_IF(Condition, LEVEL)`, and `PCHECK()` using `default` logger; and for custom logger use `CPLOG(LEVEL, LoggerId)`, `CPLOG_IF(Condition, LEVEL, LoggerId)`. This will append `: log-error [errno]` in the end of log line.
 
@@ -1073,7 +1074,7 @@ Syslog support for Easylogging++ only supports following levels; each level is c
 Following levels are not supported and correspond to `LOG_NOTICE`: TRACE, whereas VERBOSE level is completely not supported
 
  [![top] Goto Top](#table-of-contents)
- 
+
 ### STL Logging
 Prerequisite: Define macro `ELPP_STL_LOGGING`
 
@@ -1104,7 +1105,7 @@ Some C++11 specific templates are supported by further explicit macro definition
 Standard manipulators are also supported, in addition std::stringstream is also supported.
 
 [![top] Goto Top](#table-of-contents)
- 
+
 ### Qt Logging
 Prerequisite: Define macro `ELPP_QT_LOGGING`
 
@@ -1269,7 +1270,7 @@ This may not be practically best implementation but you get the point.
 ### Manually Flushing and Rolling Log Files
 You can manually flush log files using `el::Logger::flush()` (to flush single logger with all referencing log files) or `el::Loggers::flushAll()` (to flush all log files for all levels).
 
-If you have not set flag `LoggingFlag::StrictLogFileSizeCheck` for some reason, you can manually check for log files that need rolling; by using `el::Helpers::validateFileRolling(el::Logger*, const el::Level&)`. 
+If you have not set flag `LoggingFlag::StrictLogFileSizeCheck` for some reason, you can manually check for log files that need rolling; by using `el::Helpers::validateFileRolling(el::Logger*, const el::Level&)`.
 
  [![top] Goto Top](#table-of-contents)
 
@@ -1296,8 +1297,8 @@ class Client
     boost::asio::ip::tcp::socket socket;
 
 public:
-    Client(boost::asio::io_service* svc, const std::string& host, const std::string& port) 
-        : io_service(svc), socket(*io_service) 
+    Client(boost::asio::io_service* svc, const std::string& host, const std::string& port)
+        : io_service(svc), socket(*io_service)
     {
         boost::asio::ip::tcp::resolver resolver(*io_service);
         boost::asio::ip::tcp::resolver::iterator endpoint = resolver.resolve(boost::asio::ip::tcp::resolver::query(host, port));
@@ -1326,7 +1327,7 @@ private:
   const el::LogDispatchData* m_data;
   boost::asio::io_service m_svc;
   std::unique_ptr<Client> m_client;
-  
+
   void dispatch(el::base::type::string_t&& logLine) noexcept
   {
       m_client->send(logLine);
@@ -1342,10 +1343,10 @@ int main() {
     NetworkDispatcher* dispatcher = el::Helpers::logDispatchCallback<NetworkDispatcher>("NetworkDispatcher");
     dispatcher->setEnabled(true);
     dispatcher->updateServer("127.0.0.1", 9090);
-      
+
     // Start logging and normal program...
     LOG(INFO) << "First network log";
-        
+
     // You can even use a different logger, say "network" and send using a different log pattern
 }
 ```
@@ -1360,7 +1361,7 @@ If you wish to capture event of logger registration (and potentially want to rec
  > DO NOT LOG ANYTHING IN THIS HANDLER
 
  [![top] Goto Top](#table-of-contents)
- 
+
 ### Asynchronous Logging
 Prerequisite: Define macro `ELPP_EXPERIMENTAL_ASYNC`
 
@@ -1372,7 +1373,7 @@ Please note:
 * You should not rely on asynchronous logging in production, this is because feature is in experiemental stages.
 
  [![top] Goto Top](#table-of-contents)
- 
+
 ### Helper Classes
 There are static helper classes available to make it easy to do stuffs;
 
@@ -1382,18 +1383,18 @@ There are static helper classes available to make it easy to do stuffs;
 You can do various cool stuffs using functions in these classes, see [this issue](https://github.com/muflihun/easyloggingpp/issues/210) for instance.
 
  [![top] Goto Top](#table-of-contents)
- 
+
 # Contribution
 ### Submitting Patches
 You can submit patches to `develop` branch and we will try and merge them. Since it's based on single header, it can be sometimes difficult to merge without having merge conflicts.
 
  [![top] Goto Top](#table-of-contents)
- 
+
 ### Reporting a Bug
 If you have found a bug and wish to report it, feel free to do so at [github issue tracker](https://github.com/muflihun/easyloggingpp/issues?state=open). I will try to look at it as soon as possible. Some information should be provided to make it easy to reproduce;
 * Platform (OS, Compiler)
 * Log file location
-* Macros defined (on compilation) OR simple compilation 
+* Macros defined (on compilation) OR simple compilation
 * Please assign issue label.
 
 Try to provide as much information as possible. Any bug with no clear information will be ignored and closed.
@@ -1444,9 +1445,9 @@ Easylogging++ has also been tested with following C++ libraries;
 |![gtkmm]     | gtkmm                  | Tested with gtkmm 2.4                                                               |
 
  [![top] Goto Top](#table-of-contents)
- 
+
  ## Build Matrix
- 
+
  | Branch | Platform | Build Status |
  | -------- |:------------:|:------------:|
  | `develop` | GNU/Linux 4.4 / Ubuntu 4.8.4 64-bit / `clang++` | [![Build Status](https://travis-matrix-badges.herokuapp.com/repos/muflihun/easyloggingpp/branches/develop/1)](https://travis-ci.org/muflihun/easyloggingpp) |
@@ -1459,9 +1460,9 @@ Easylogging++ has also been tested with following C++ libraries;
  | `master` | GNU/Linux 4.4 / Ubuntu 4.8.4 64-bit / `g++-5` | [![Build Status](https://travis-matrix-badges.herokuapp.com/repos/muflihun/easyloggingpp/branches/master/3)](https://travis-ci.org/muflihun/easyloggingpp) |
  | `master` | GNU/Linux 4.4 / Ubuntu 4.8.4 64-bit / `g++-6` | [![Build Status](https://travis-matrix-badges.herokuapp.com/repos/muflihun/easyloggingpp/branches/master/4)](https://travis-ci.org/muflihun/easyloggingpp) |
  | `master` | GNU/Linux 4.4 / Ubuntu 4.8.4 64-bit / `g++-7` | [![Build Status](https://travis-matrix-badges.herokuapp.com/repos/muflihun/easyloggingpp/branches/master/5)](https://travis-ci.org/muflihun/easyloggingpp) |
- 
+
   [![top] Goto Top](#table-of-contents)
- 
+
 # Licence
 ```
 The MIT License (MIT)
@@ -1491,7 +1492,7 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ```
 
  [![top] Goto Top](#table-of-contents)
- 
+
 # Disclaimer
 Icons used in this manual (in compatibility section) are solely for information readability purposes. I do not own these icons. If anyone has issues with usage of these icon, please feel free to contact me via company's email and I will look for an alternative. Company's email address is required so that I can verify the ownership, any other email address for this purpose will be ignored.
 
@@ -1499,7 +1500,7 @@ Icons used in this manual (in compatibility section) are solely for information
 
 
  [![top] Goto Top](#table-of-contents)
- 
+
   [banner]: https://muflihun.github.io/easyloggingpp/images/banner.png?v=4
   [ubuntu]: https://muflihun.github.io/easyloggingpp/images/icons/ubuntu.png?v=2
   [mint]: https://muflihun.github.io/easyloggingpp/images/icons/linux-mint.png?v=2
@@ -1535,4 +1536,3 @@ Icons used in this manual (in compatibility section) are solely for information
   [notes]: https://muflihun.github.io/easyloggingpp/images/notes.png?v=4
   [top]: https://muflihun.github.io/easyloggingpp/images/up.png?v=4
   [www]: https://muflihun.github.io/easyloggingpp/images/logo-www.png?v=6
-  
diff --git a/src/easylogging++.cc b/src/easylogging++.cc
index f945b7589..d79174fb2 100644
--- a/src/easylogging++.cc
+++ b/src/easylogging++.cc
@@ -1,7 +1,7 @@
 //
 //  Bismillah ar-Rahmaan ar-Raheem
 //
-//  Easylogging++ v9.96.4
+//  Easylogging++ v9.96.5
 //  Cross-platform logging library for C++ applications
 //
 //  Copyright (c) 2012-2018 Muflihun Labs
@@ -3097,11 +3097,11 @@ void Loggers::clearVModules(void) {
 // VersionInfo
 
 const std::string VersionInfo::version(void) {
-  return std::string("9.96.4");
+  return std::string("9.96.5");
 }
 /// @brief Release date of current version
 const std::string VersionInfo::releaseDate(void) {
-  return std::string("03-04-2018 1019hrs");
+  return std::string("07-09-2018 0950hrs");
 }
 
 } // namespace el
diff --git a/src/easylogging++.h b/src/easylogging++.h
index e85c2424c..6e63afe59 100644
--- a/src/easylogging++.h
+++ b/src/easylogging++.h
@@ -1,7 +1,7 @@
 //
 //  Bismillah ar-Rahmaan ar-Raheem
 //
-//  Easylogging++ v9.96.4
+//  Easylogging++ v9.96.5
 //  Single-header only, cross-platform logging library for C++ applications
 //
 //  Copyright (c) 2012-2018 Muflihun Labs
diff --git a/tools/release.sh b/tools/release.sh
index 1d06448ac..d49d66946 100755
--- a/tools/release.sh
+++ b/tools/release.sh
@@ -1,8 +1,8 @@
 #!/bin/bash
 
-# Bash script that helps with releasing new versions of EasyLogging++
-# Revision: 1.4
-# @author mkhan3189
+# Bash script that helps with releasing new versions of Easylogging++
+# Revision: 1.5
+# author @abumusamq
 #
 # Usage:
 #        ./release.sh [repo-root] [homepage-repo-root] [curr-version] [new-version] [do-not-ask]
@@ -46,7 +46,6 @@ if [ "$confirm" = "y" ]; then
   sed -i '' -e "s/Easylogging++ v$CURR_VERSION*/Easylogging++ v$NEW_VERSION/g" $1/src/easylogging++.h
   sed -i '' -e "s/Easylogging++ v$CURR_VERSION*/Easylogging++ v$NEW_VERSION/g" $1/src/easylogging++.cc
   sed -i '' -e "s/Easylogging++ v$CURR_VERSION*/Easylogging++ v$NEW_VERSION/g" $1/README.md
-  sed -i '' -e "s/v$CURR_VERSION/v$NEW_VERSION/g" $1/Message.md
   sed -i '' -e "s/return std::string(\"$CURR_VERSION\");/return std\:\:string(\"$NEW_VERSION\");/g" $1/src/easylogging++.cc
   sed -i '' -e "s/return std::string(\"$CURR_RELEASE_DATE\");/return std\:\:string(\"$NEW_RELEASE_DATE\");/g" $1/src/easylogging++.cc
   sed -i '' -e "s/\[Unreleased\]/\[$NEW_VERSION\] - $NEW_RELEASE_DATE_SIMPLE/g" $1/CHANGELOG.md
@@ -70,8 +69,8 @@ if [ "$confirm" = "y" ]; then
   cp $1/src/easylogging++.h .
   cp $1/src/easylogging++.cc .
   cp $1/CHANGELOG.md CHANGELOG.txt
+  cp $1/README.md README.txt
   cp $1/LICENSE LICENSE.txt
-  cp $1/MESSAGE.md README.txt
   zip easyloggingpp_v$NEW_VERSION.zip easylogging++.h easylogging++.cc LICENSE.txt CHANGELOG.txt README.txt
   tar -pczf easyloggingpp_v$NEW_VERSION.tar.gz easylogging++.h easylogging++.cc LICENSE.txt CHANGELOG.txt README.txt
   mv easyloggingpp_v$NEW_VERSION.zip $2/