diff --git a/source/apta.cpp b/source/apta.cpp
index e266ce29..13ef239f 100755
--- a/source/apta.cpp
+++ b/source/apta.cpp
@@ -13,6 +13,7 @@
 #include "utility/loguru.hpp"
 #include "input/abbadingoreader.h"
 #include "input/inputdatalocator.h"
+#include "input/parsers/abbadingoparser.h"
 
 using namespace std;
 
@@ -40,11 +41,9 @@ apta::apta(){
 }
 
 void apta::print_dot(iostream& output){
-    int ncounter = 0;
     // needed for the correct printing of intermediate models after undoing merges
-    for(APTA_iterator Ait = APTA_iterator(root); *Ait != 0; ++Ait){
-        (*Ait)->number = ncounter++;
-    }
+    // Hielke: Fix numbering of states properly with suggestion in #23.
+    merger->renumber_states();
 
     output << "digraph DFA {\n";
     output << "\t" << root->find()->number << " [label=\"root\" shape=box];\n";
@@ -70,23 +69,19 @@ void apta::print_dot(iostream& output){
 
         output << "\t" << n->number << " [ label=\"";
         if(DEBUGGING){
-            output << n << ":#" << "\n";
-            output << "rep#" << n->representative << "\n";
+            output << n << ":#" << "\\n";
+            output << "rep#" << n->representative << "\\n";
         }
-
-        output << n->number << ":#" << n->size << "\n";
+        output << n->number << " #" << n->size << " ";
         n->data->print_state_label(output);
-        output << "\" ";
         n->data->print_state_style(output);
-        if (!n->red) output << " style=dotted";
-        
-        //output << n->number << " #" << n->size << "\" ";
-        //if (n->is_red()) output << ", style=filled, fillcolor=\"firebrick1\"";
-        //else if (n->is_blue()) output << ", style=filled, fillcolor=\"dodgerblue1\"";
-        //else if (n->is_white()) output << ", style=filled, fillcolor=\"ghostwhite\"";
-        //output << ", width=" << log(1 + log(1 + n->size));
-        //output << ", height=" << log(1 + log(1 + n->size));
+        output << "\" ";
 
+        if (n->is_red()) output << ", style=filled, fillcolor=\"firebrick1\"";
+        else if (n->is_blue()) output << ", style=filled, fillcolor=\"dodgerblue1\"";
+        else if (n->is_white()) output << ", style=filled, fillcolor=\"ghostwhite\"";
+        output << ", width=" << log(1 + log(1 + n->size));
+        output << ", height=" << log(1 + log(1 + n->size));
         output << ", penwidth=" << log(1 + n->size);
         output << "];\n";
 
@@ -108,18 +103,14 @@ void apta::print_dot(iostream& output){
 
             output << "\t\t" << n->number << " -> " << child->number << " [label=\"";
 
-            output << inputdata_locator::get()->get_symbol(it->first) << endl;
-
-            //n->data->print_transition_label(output, it->first);
-            
-            
+            output << inputdata_locator::get()->get_symbol(it->first) << " ";
+            n->data->print_transition_label(output, it->first);
             for(auto & min_attribute_value : g->min_attribute_values){
-                output << " " << inputdata_locator::get()->get_attribute(min_attribute_value.first) << " >= " << min_attribute_value.second;
+                output << "\\n" << inputdata_locator::get()->get_attribute(min_attribute_value.first) << " >= " << min_attribute_value.second;
             }
             for(auto & max_attribute_value : g->max_attribute_values){
-                output << " " << inputdata_locator::get()->get_attribute(max_attribute_value.first) << " < " << max_attribute_value.second;
+                output << "\\n" << inputdata_locator::get()->get_attribute(max_attribute_value.first) << " < " << max_attribute_value.second;
             }
-
             output << "\" ";
             output << ", penwidth=" << log(1 + n->size);
             output << " ];\n";
@@ -176,12 +167,10 @@ void apta_node::print_json_transitions(iostream& output){
 
 void apta::print_json(iostream& output){
     set_json_depths();
-    int count = 0;
     root->depth = 0;
-    for(merged_APTA_iterator Ait = merged_APTA_iterator(root); *Ait != nullptr; ++Ait){
-        apta_node* n = *Ait;
-        n->number = count++;
-    }
+    // needed for the correct printing of intermediate models after undoing merges
+    // Hielke: Fix numbering of states properly with suggestion in #23.
+    merger->renumber_states();
 
     output << "{\n";
     output << "\t\"types\" : [\n";
@@ -330,8 +319,13 @@ void apta::read_json(istream& input_stream){
         string trace = n["trace"];
         istringstream trace_stream(trace);
         node->access_trace = mem_store::create_trace();
-        // TODO: verify this with Sicco (robert)
-        // idat.read_abbadingo_sequence(trace_stream,node->access_trace);
+
+        auto parser = abbadingoparser::single_trace(trace_stream);
+        auto strategy = read_all();
+        auto trace_maybe = inputdata_locator::get()->read_trace(parser, strategy);
+        if (trace_maybe.has_value()) {
+            node->access_trace = trace_maybe.value();
+        }
     }
     for (int i = 1; i < read_apta["nodes"].size(); ++i) {
         json n = read_apta["nodes"][i];
@@ -447,7 +441,8 @@ void apta_node::initialize(apta_node* n){
     representative_of = nullptr;
     tails_head = nullptr;
     access_trace = nullptr;
-    number = -1;
+    // keep the old node number
+    // number = -1;
     size = 0;
     final = 0;
     depth = 0;
@@ -821,4 +816,4 @@ void apta::set_json_depths() const {
             it++;
         }
     }
-}
\ No newline at end of file
+}
diff --git a/source/evaluation/mealy.cpp b/source/evaluation/mealy.cpp
index 85caf619..f72413e4 100755
--- a/source/evaluation/mealy.cpp
+++ b/source/evaluation/mealy.cpp
@@ -99,7 +99,7 @@ void mealy::reset(state_merger* merger){
 
 
 void mealy_data::print_transition_label(iostream& output, int symbol){
-   output << int_output[outputs[symbol]];
+   output << "/" << int_output[outputs[symbol]];
 };
 
 string mealy_data::predict_data(tail* t){
diff --git a/source/input/parsers/abbadingoparser.cpp b/source/input/parsers/abbadingoparser.cpp
index 045f756d..83f429e3 100644
--- a/source/input/parsers/abbadingoparser.cpp
+++ b/source/input/parsers/abbadingoparser.cpp
@@ -18,7 +18,7 @@
 #include <sstream>
 #include <chrono>
 
-void abbadingoparser::parse_header() {
+void abbadingoparser::parse_header(std::istream &inputstream) {
     std::string line;
     std::getline(inputstream, line);
 
@@ -166,3 +166,21 @@ std::optional<symbol_info> abbadingoparser::next() {
     symbols.pop_front();
     return cur_symbol;
 }
+
+/**
+ * Helper method to read a single abbadingo formatted trace
+ * Currently does not support trace or symbol attributes
+ *
+ * @param trace an input stream containing an abbadingo formatted trace.
+ * @return a parser for the trace.
+ */
+abbadingoparser abbadingoparser::single_trace(std::istream &trace) {
+
+    abbadingoparser parser(trace, false);
+
+    std::stringstream header;
+    header << "1 0\n";
+    parser.parse_header(header);
+
+    return parser;
+}
diff --git a/source/input/parsers/abbadingoparser.h b/source/input/parsers/abbadingoparser.h
index 8d206b17..918868de 100644
--- a/source/input/parsers/abbadingoparser.h
+++ b/source/input/parsers/abbadingoparser.h
@@ -22,18 +22,24 @@ class abbadingoparser: public parser {
     std::vector<attribute_info> trace_attr_prototypes;
     std::vector<attribute_info> symbol_attr_prototypes;
 
+
+
 public:
-    abbadingoparser(std::istream &input)
+    explicit abbadingoparser(std::istream &input, bool header = true)
     : inputstream(input)
     {
-        parse_header();
+        if (header) {
+            parse_header(inputstream);
+        }
     }
 
-    void parse_header();
+    void parse_header(std::istream &inputstream);
 
     bool read_abbadingo_trace();
 
     std::optional<symbol_info> next();
+
+    static abbadingoparser single_trace(std::istream &input);
 };
 
 
diff --git a/source/input/parsers/grammar/abbadingoheader.h b/source/input/parsers/grammar/abbadingoheader.h
index bfd6b46d..9a15184b 100644
--- a/source/input/parsers/grammar/abbadingoheader.h
+++ b/source/input/parsers/grammar/abbadingoheader.h
@@ -137,7 +137,7 @@ namespace {
 
         // The complete abbadingo header: number:dsft/name1,... number:dsft/name2,...
         struct abbadingo_header_p {
-            static constexpr auto rule = dsl::twice(dsl::p<abbadingo_header_part_p>, dsl::trailing_sep(dsl::ascii::space));
+            static constexpr auto rule = dsl::twice(dsl::p<abbadingo_header_part_p>, dsl::trailing_sep(dsl::ascii::space)) + (dsl::newline | dsl::eof);
             static constexpr auto value = lexy::construct<abbadingo_header_info>;
         };
     }
diff --git a/source/state_merger.cpp b/source/state_merger.cpp
index 8c1fbb43..efeea074 100755
--- a/source/state_merger.cpp
+++ b/source/state_merger.cpp
@@ -1081,6 +1081,12 @@ void state_merger::print_dot(const string& file_name)
     output1.close();
 }
 
+void state_merger::print_dot(ostream& output)
+{
+    todot();
+    output << dot_output;
+}
+
 void state_merger::print_json(const string& file_name)
 {
     tojson();
diff --git a/source/state_merger.h b/source/state_merger.h
index 66b200c1..e55270c5 100755
--- a/source/state_merger.h
+++ b/source/state_merger.h
@@ -127,6 +127,7 @@ class state_merger{
     bool split_init(apta_node *red, tail *t, int attr, int depth, bool evaluate, bool perform, bool test);
 
     void print_dot(const string& file_name);
+    void print_dot(ostream& output);
 
     void print_json(const string& file_name);
 
diff --git a/source/utility/CLI11.hpp b/source/utility/CLI11.hpp
old mode 100755
new mode 100644
index 8f958076..68244d38
--- a/source/utility/CLI11.hpp
+++ b/source/utility/CLI11.hpp
@@ -1,11 +1,11 @@
 #pragma once
 
-// CLI11: Version 1.9.0
+// CLI11: Version 1.9.1
 // Originally designed by Henry Schreiner
 // https://github.com/CLIUtils/CLI11
 //
 // This is a standalone header file generated by MakeSingleHeader.py in CLI11/scripts
-// from: v1.9.0
+// from: v1.9.1
 //
 // From LICENSE:
 //
@@ -62,18 +62,18 @@
 #include <vector>
 
 
-// Verbatim copy from CLI/Version.hpp:
+// Verbatim copy from Version.hpp:
 
 
 #define CLI11_VERSION_MAJOR 1
 #define CLI11_VERSION_MINOR 9
-#define CLI11_VERSION_PATCH 0
-#define CLI11_VERSION "1.9.0"
+#define CLI11_VERSION_PATCH 1
+#define CLI11_VERSION "1.9.1"
 
 
 
 
-// Verbatim copy from CLI/Macros.hpp:
+// Verbatim copy from Macros.hpp:
 
 
 // The following version macro is very similar to the one in PyBind11
@@ -112,7 +112,7 @@
 
 
 
-// Verbatim copy from CLI/Validators.hpp:
+// Verbatim copy from Validators.hpp:
 
 
 // C standard library
@@ -125,7 +125,14 @@
 #else
 #include <filesystem>
 #if defined __cpp_lib_filesystem && __cpp_lib_filesystem >= 201703
+#if defined _GLIBCXX_RELEASE && _GLIBCXX_RELEASE >= 9
 #define CLI11_HAS_FILESYSTEM 1
+#elif defined(__GLIBCXX__)
+// if we are using gcc and Version <9 default to no filesystem
+#define CLI11_HAS_FILESYSTEM 0
+#else
+#define CLI11_HAS_FILESYSTEM 1
+#endif
 #else
 #define CLI11_HAS_FILESYSTEM 0
 #endif
@@ -134,7 +141,7 @@
 #endif
 
 #if defined CLI11_HAS_FILESYSTEM && CLI11_HAS_FILESYSTEM > 0
-#include <filesystem> // NOLINT(build/include)
+#include <filesystem>  // NOLINT(build/include)
 #else
 #include <sys/stat.h>
 #include <sys/types.h>
@@ -142,15 +149,15 @@
 
 
 
-// From CLI/Version.hpp:
+// From Version.hpp:
 
 
 
-// From CLI/Macros.hpp:
+// From Macros.hpp:
 
 
 
-// From CLI/StringTools.hpp:
+// From StringTools.hpp:
 
 namespace CLI {
 
@@ -165,7 +172,7 @@ std::ostream &operator<<(std::ostream &in, const T &item) {
     return in << static_cast<typename std::underlying_type<T>::type>(item);
 }
 
-} // namespace enums
+}  // namespace enums
 
 /// Export to CLI namespace
 using enums::operator<<;
@@ -179,9 +186,9 @@ constexpr int expected_max_vector_size{1 << 29};
 inline std::vector<std::string> split(const std::string &s, char delim) {
     std::vector<std::string> elems;
     // Check to see if empty string, give consistent result
-    if(s.empty())
+    if(s.empty()) {
         elems.emplace_back();
-    else {
+    } else {
         std::stringstream ss;
         ss.str(s);
         std::string item;
@@ -401,8 +408,9 @@ inline std::ptrdiff_t find_member(std::string name,
         it = std::find_if(std::begin(names), std::end(names), [&name](std::string local_name) {
             return detail::remove_underscore(local_name) == name;
         });
-    } else
+    } else {
         it = std::find(std::begin(names), std::end(names), name);
+    }
 
     return (it != std::end(names)) ? (it - std::begin(names)) : (-1);
 }
@@ -434,7 +442,7 @@ inline std::vector<std::string> split_up(std::string str, char delimiter = '\0')
         if(delims.find_first_of(str[0]) != std::string::npos) {
             keyChar = str[0];
             auto end = str.find_first_of(keyChar, 1);
-            while((end != std::string::npos) && (str[end - 1] == '\\')) { // deal with escaped quotes
+            while((end != std::string::npos) && (str[end - 1] == '\\')) {  // deal with escaped quotes
                 end = str.find_first_of(keyChar, end + 1);
                 embeddedQuote = true;
             }
@@ -492,7 +500,7 @@ inline std::size_t escape_detect(std::string &str, std::size_t offset) {
         auto astart = str.find_last_of("-/ \"\'`", offset - 1);
         if(astart != std::string::npos) {
             if(str[astart] == ((str[offset] == '=') ? '-' : '/'))
-                str[offset] = ' '; // interpret this as a space so the split_up works properly
+                str[offset] = ' ';  // interpret this as a space so the split_up works properly
         }
     }
     return offset + 1;
@@ -510,11 +518,11 @@ inline std::string &add_quotes_if_needed(std::string &str) {
     return str;
 }
 
-} // namespace detail
+}  // namespace detail
 
-} // namespace CLI
+}  // namespace CLI
 
-// From CLI/Error.hpp:
+// From Error.hpp:
 
 namespace CLI {
 
@@ -747,11 +755,11 @@ class RequiredError : public ParseError {
 class ArgumentMismatch : public ParseError {
     CLI11_ERROR_DEF(ParseError, ArgumentMismatch)
     CLI11_ERROR_SIMPLE(ArgumentMismatch)
-    ArgumentMismatch(std::string name, int expected, std::size_t recieved)
+    ArgumentMismatch(std::string name, int expected, std::size_t received)
         : ArgumentMismatch(expected > 0 ? ("Expected exactly " + std::to_string(expected) + " arguments to " + name +
-                                           ", got " + std::to_string(recieved))
+                                           ", got " + std::to_string(received))
                                         : ("Expected at least " + std::to_string(-expected) + " arguments to " + name +
-                                           ", got " + std::to_string(recieved)),
+                                           ", got " + std::to_string(received)),
                            ExitCodes::ArgumentMismatch) {}
 
     static ArgumentMismatch AtLeast(std::string name, int num, std::size_t received) {
@@ -838,9 +846,9 @@ class OptionNotFound : public Error {
 
 /// @}
 
-} // namespace CLI
+}  // namespace CLI
 
-// From CLI/TypeTools.hpp:
+// From TypeTools.hpp:
 
 namespace CLI {
 
@@ -854,7 +862,7 @@ enum class enabler {};
 
 /// An instance to use in EnableIf
 constexpr enabler dummy = {};
-} // namespace detail
+}  // namespace detail
 
 /// A copy of enable_if_t from C++14, compatible with C++11.
 ///
@@ -1049,15 +1057,24 @@ template <typename S> class is_tuple_like {
 };
 
 /// Convert an object to a string (directly forward if this can become a string)
-template <typename T, enable_if_t<std::is_constructible<std::string, T>::value, detail::enabler> = detail::dummy>
+template <typename T, enable_if_t<std::is_convertible<T, std::string>::value, detail::enabler> = detail::dummy>
 auto to_string(T &&value) -> decltype(std::forward<T>(value)) {
     return std::forward<T>(value);
 }
 
+/// Construct a string from the object
+template <typename T,
+          enable_if_t<std::is_constructible<std::string, T>::value && !std::is_convertible<T, std::string>::value,
+                      detail::enabler> = detail::dummy>
+std::string to_string(const T &value) {
+    return std::string(value);
+}
+
 /// Convert an object to a string (streaming must be supported for that type)
 template <typename T,
-          enable_if_t<!std::is_constructible<std::string, T>::value && is_ostreamable<T>::value, detail::enabler> =
-              detail::dummy>
+          enable_if_t<!std::is_convertible<std::string, T>::value && !std::is_constructible<std::string, T>::value &&
+                          is_ostreamable<T>::value,
+                      detail::enabler> = detail::dummy>
 std::string to_string(T &&value) {
     std::stringstream stream;
     stream << value;
@@ -1379,7 +1396,7 @@ inline std::string type_name() {
 // Lexical cast
 
 /// Convert a flag into an integer value  typically binary flags
-inline int64_t to_flag_value(std::string val) {
+inline std::int64_t to_flag_value(std::string val) {
     static const std::string trueString("true");
     static const std::string falseString("false");
     if(val == trueString) {
@@ -1389,10 +1406,10 @@ inline int64_t to_flag_value(std::string val) {
         return -1;
     }
     val = detail::to_lower(val);
-    int64_t ret;
+    std::int64_t ret;
     if(val.size() == 1) {
         if(val[0] >= '1' && val[0] <= '9') {
-            return (static_cast<int64_t>(val[0]) - '0');
+            return (static_cast<std::int64_t>(val[0]) - '0');
         }
         switch(val[0]) {
         case '0':
@@ -1442,7 +1459,7 @@ template <typename T,
           enable_if_t<classify_object<T>::value == object_category::unsigned_integral, detail::enabler> = detail::dummy>
 bool lexical_cast(const std::string &input, T &output) {
     if(!input.empty() && input.front() == '-')
-        return false; // std::stoull happily converts negative values to junk without any errors.
+        return false;  // std::stoull happily converts negative values to junk without any errors.
 
     try {
         std::size_t n = 0;
@@ -1622,7 +1639,7 @@ bool lexical_assign(const std::string &input, T &output) {
     XC val{};
     bool parse_result = input.empty() ? true : lexical_cast<XC>(input, val);
     if(parse_result) {
-        output = T(val); // use () form of constructor to allow some implicit conversions
+        output = T(val);  // use () form of constructor to allow some implicit conversions
     }
     return parse_result;
 }
@@ -1803,7 +1820,7 @@ bool lexical_conversion(const std::vector<std ::string> &strings, T &output) {
 template <typename T,
           enable_if_t<std::is_integral<T>::value && std::is_unsigned<T>::value, detail::enabler> = detail::dummy>
 void sum_flag_vector(const std::vector<std::string> &flags, T &output) {
-    int64_t count{0};
+    std::int64_t count{0};
     for(auto &flag : flags) {
         count += detail::to_flag_value(flag);
     }
@@ -1818,17 +1835,17 @@ void sum_flag_vector(const std::vector<std::string> &flags, T &output) {
 template <typename T,
           enable_if_t<std::is_integral<T>::value && std::is_signed<T>::value, detail::enabler> = detail::dummy>
 void sum_flag_vector(const std::vector<std::string> &flags, T &output) {
-    int64_t count{0};
+    std::int64_t count{0};
     for(auto &flag : flags) {
         count += detail::to_flag_value(flag);
     }
     output = static_cast<T>(count);
 }
 
-} // namespace detail
-} // namespace CLI
+}  // namespace detail
+}  // namespace CLI
 
-// From CLI/Split.hpp:
+// From Split.hpp:
 
 namespace CLI {
 namespace detail {
@@ -1950,10 +1967,10 @@ get_names(const std::vector<std::string> &input) {
         short_names, long_names, pos_name);
 }
 
-} // namespace detail
-} // namespace CLI
+}  // namespace detail
+}  // namespace CLI
 
-// From CLI/ConfigFwd.hpp:
+// From ConfigFwd.hpp:
 
 namespace CLI {
 
@@ -2068,9 +2085,9 @@ class ConfigTOML : public ConfigINI {
         valueDelimiter = '=';
     }
 };
-} // namespace CLI
+}  // namespace CLI
 
-// From CLI/Validators.hpp:
+// From Validators.hpp:
 
 namespace CLI {
 
@@ -2129,14 +2146,14 @@ class Validator {
             }
         }
         return retstring;
-    };
+    }
 
     /// This is the required operator for a Validator - provided to help
     /// users (CLI11 uses the member `func` directly)
     std::string operator()(const std::string &str) const {
         std::string value = str;
         return (active_) ? func_(value) : std::string{};
-    };
+    }
 
     /// Specify the type string
     Validator &description(std::string validator_desc) {
@@ -2190,13 +2207,13 @@ class Validator {
     Validator &application_index(int app_index) {
         application_index_ = app_index;
         return *this;
-    };
+    }
     /// Specify the application index of a validator
     Validator application_index(int app_index) const {
         Validator newval(*this);
         newval.application_index_ = app_index;
         return newval;
-    };
+    }
     /// Get the current value of the application index
     int get_application_index() const { return application_index_; }
     /// Get a boolean if the validator is active
@@ -2292,7 +2309,7 @@ class Validator {
             return std::string(1, '(') + f1 + ')' + merger + '(' + f2 + ')';
         };
     }
-}; // namespace CLI
+};  // namespace CLI
 
 /// Class wrapping some of the accessors of Validator
 class CustomValidator : public Validator {
@@ -2304,7 +2321,7 @@ class CustomValidator : public Validator {
 namespace detail {
 
 /// CLI enumeration of different file types
-enum class path_type { nonexistant, file, directory };
+enum class path_type { nonexistent, file, directory };
 
 #if defined CLI11_HAS_FILESYSTEM && CLI11_HAS_FILESYSTEM > 0
 /// get the type of the path from a file name
@@ -2312,12 +2329,12 @@ inline path_type check_path(const char *file) noexcept {
     std::error_code ec;
     auto stat = std::filesystem::status(file, ec);
     if(ec) {
-        return path_type::nonexistant;
+        return path_type::nonexistent;
     }
     switch(stat.type()) {
     case std::filesystem::file_type::none:
     case std::filesystem::file_type::not_found:
-        return path_type::nonexistant;
+        return path_type::nonexistent;
     case std::filesystem::file_type::directory:
         return path_type::directory;
     case std::filesystem::file_type::symlink:
@@ -2345,7 +2362,7 @@ inline path_type check_path(const char *file) noexcept {
         return ((buffer.st_mode & S_IFDIR) != 0) ? path_type::directory : path_type::file;
     }
 #endif
-    return path_type::nonexistant;
+    return path_type::nonexistent;
 }
 #endif
 /// Check for an existing file (returns error message if check fails)
@@ -2354,7 +2371,7 @@ class ExistingFileValidator : public Validator {
     ExistingFileValidator() : Validator("FILE") {
         func_ = [](std::string &filename) {
             auto path_result = check_path(filename.c_str());
-            if(path_result == path_type::nonexistant) {
+            if(path_result == path_type::nonexistent) {
                 return "File does not exist: " + filename;
             }
             if(path_result == path_type::directory) {
@@ -2371,7 +2388,7 @@ class ExistingDirectoryValidator : public Validator {
     ExistingDirectoryValidator() : Validator("DIR") {
         func_ = [](std::string &filename) {
             auto path_result = check_path(filename.c_str());
-            if(path_result == path_type::nonexistant) {
+            if(path_result == path_type::nonexistent) {
                 return "Directory does not exist: " + filename;
             }
             if(path_result == path_type::file) {
@@ -2388,7 +2405,7 @@ class ExistingPathValidator : public Validator {
     ExistingPathValidator() : Validator("PATH(existing)") {
         func_ = [](std::string &filename) {
             auto path_result = check_path(filename.c_str());
-            if(path_result == path_type::nonexistant) {
+            if(path_result == path_type::nonexistent) {
                 return "Path does not exist: " + filename;
             }
             return std::string();
@@ -2402,7 +2419,7 @@ class NonexistentPathValidator : public Validator {
     NonexistentPathValidator() : Validator("PATH(non-existing)") {
         func_ = [](std::string &filename) {
             auto path_result = check_path(filename.c_str());
-            if(path_result != path_type::nonexistant) {
+            if(path_result != path_type::nonexistent) {
                 return "Path already exists: " + filename;
             }
             return std::string();
@@ -2481,7 +2498,7 @@ class Number : public Validator {
     }
 };
 
-} // namespace detail
+}  // namespace detail
 
 // Static is not needed here, because global const implies static.
 
@@ -2583,7 +2600,7 @@ typename std::remove_reference<T>::type &smart_deref(T &value) {
 /// Generate a string representation of a set
 template <typename T> std::string generate_set(const T &set) {
     using element_t = typename detail::element_type<T>::type;
-    using iteration_type_t = typename detail::pair_adaptor<element_t>::value_type; // the type of the object pair
+    using iteration_type_t = typename detail::pair_adaptor<element_t>::value_type;  // the type of the object pair
     std::string out(1, '{');
     out.append(detail::join(
         detail::smart_deref(set),
@@ -2596,7 +2613,7 @@ template <typename T> std::string generate_set(const T &set) {
 /// Generate a string representation of a map
 template <typename T> std::string generate_map(const T &map, bool key_only = false) {
     using element_t = typename detail::element_type<T>::type;
-    using iteration_type_t = typename detail::pair_adaptor<element_t>::value_type; // the type of the object pair
+    using iteration_type_t = typename detail::pair_adaptor<element_t>::value_type;  // the type of the object pair
     std::string out(1, '{');
     out.append(detail::join(
         detail::smart_deref(map),
@@ -2707,7 +2724,7 @@ typename std::enable_if<std::is_floating_point<T>::value, bool>::type checked_mu
     return true;
 }
 
-} // namespace detail
+}  // namespace detail
 /// Verify items are in a set
 class IsMember : public Validator {
   public:
@@ -2727,11 +2744,11 @@ class IsMember : public Validator {
 
         // Get the type of the contained item - requires a container have ::value_type
         // if the type does not have first_type and second_type, these are both value_type
-        using element_t = typename detail::element_type<T>::type;            // Removes (smart) pointers if needed
-        using item_t = typename detail::pair_adaptor<element_t>::first_type; // Is value_type if not a map
+        using element_t = typename detail::element_type<T>::type;             // Removes (smart) pointers if needed
+        using item_t = typename detail::pair_adaptor<element_t>::first_type;  // Is value_type if not a map
 
-        using local_item_t = typename IsMemberType<item_t>::type; // This will convert bad types to good ones
-                                                                  // (const char * to std::string)
+        using local_item_t = typename IsMemberType<item_t>::type;  // This will convert bad types to good ones
+                                                                   // (const char * to std::string)
 
         // Make a local copy of the filter function, using a std::function if not one already
         std::function<local_item_t(local_item_t)> filter_fn = filter_function;
@@ -2744,7 +2761,7 @@ class IsMember : public Validator {
         func_ = [set, filter_fn](std::string &input) {
             local_item_t b;
             if(!detail::lexical_cast(input, b)) {
-                throw ValidationError(input); // name is added later
+                throw ValidationError(input);  // name is added later
             }
             if(filter_fn) {
                 b = filter_fn(b);
@@ -2800,10 +2817,10 @@ class Transformer : public Validator {
                       "mapping must produce value pairs");
         // Get the type of the contained item - requires a container have ::value_type
         // if the type does not have first_type and second_type, these are both value_type
-        using element_t = typename detail::element_type<T>::type;            // Removes (smart) pointers if needed
-        using item_t = typename detail::pair_adaptor<element_t>::first_type; // Is value_type if not a map
-        using local_item_t = typename IsMemberType<item_t>::type;            // This will convert bad types to good ones
-                                                                             // (const char * to std::string)
+        using element_t = typename detail::element_type<T>::type;             // Removes (smart) pointers if needed
+        using item_t = typename detail::pair_adaptor<element_t>::first_type;  // Is value_type if not a map
+        using local_item_t = typename IsMemberType<item_t>::type;             // Will convert bad types to good ones
+                                                                              // (const char * to std::string)
 
         // Make a local copy of the filter function, using a std::function if not one already
         std::function<local_item_t(local_item_t)> filter_fn = filter_function;
@@ -2858,12 +2875,11 @@ class CheckedTransformer : public Validator {
                       "mapping must produce value pairs");
         // Get the type of the contained item - requires a container have ::value_type
         // if the type does not have first_type and second_type, these are both value_type
-        using element_t = typename detail::element_type<T>::type;            // Removes (smart) pointers if needed
-        using item_t = typename detail::pair_adaptor<element_t>::first_type; // Is value_type if not a map
-        using local_item_t = typename IsMemberType<item_t>::type;            // This will convert bad types to good ones
-                                                                             // (const char * to std::string)
-        using iteration_type_t = typename detail::pair_adaptor<element_t>::value_type; // the type of the object pair //
-                                                                                       // the type of the object pair
+        using element_t = typename detail::element_type<T>::type;             // Removes (smart) pointers if needed
+        using item_t = typename detail::pair_adaptor<element_t>::first_type;  // Is value_type if not a map
+        using local_item_t = typename IsMemberType<item_t>::type;             // Will convert bad types to good ones
+                                                                              // (const char * to std::string)
+        using iteration_type_t = typename detail::pair_adaptor<element_t>::value_type;  // the type of the object pair
 
         // Make a local copy of the filter function, using a std::function if not one already
         std::function<local_item_t(local_item_t)> filter_fn = filter_function;
@@ -3071,7 +3087,7 @@ class AsNumberWithUnit : public Validator {
 ///   "2 EiB" => 2^61 // Units up to exibyte are supported
 class AsSizeValue : public AsNumberWithUnit {
   public:
-    using result_t = uint64_t;
+    using result_t = std::uint64_t;
 
     /// If kb_is_1000 is true,
     /// interpret 'kb', 'k' as 1000 and 'kib', 'ki' as 1024
@@ -3147,12 +3163,12 @@ inline std::pair<std::string, std::string> split_program_name(std::string comman
     return vals;
 }
 
-} // namespace detail
+}  // namespace detail
 /// @}
 
-} // namespace CLI
+}  // namespace CLI
 
-// From CLI/FormatterFwd.hpp:
+// From FormatterFwd.hpp:
 
 namespace CLI {
 
@@ -3165,9 +3181,9 @@ class App;
 /// the second argument.
 
 enum class AppFormatMode {
-    Normal, //< The normal, detailed help
-    All,    //< A fully expanded help
-    Sub,    //< Used when printed as part of expanded subcommand
+    Normal,  ///< The normal, detailed help
+    All,     ///< A fully expanded help
+    Sub,     ///< Used when printed as part of expanded subcommand
 };
 
 /// This is the minimum requirements to run a formatter.
@@ -3196,7 +3212,7 @@ class FormatterBase {
     FormatterBase(FormatterBase &&) = default;
 
     /// Adding a destructor in this form to work around bug in GCC 4.7
-    virtual ~FormatterBase() noexcept {} // NOLINT(modernize-use-equals-default)
+    virtual ~FormatterBase() noexcept {}  // NOLINT(modernize-use-equals-default)
 
     /// This is the key method that puts together help
     virtual std::string make_help(const App *, std::string, AppFormatMode) const = 0;
@@ -3241,7 +3257,7 @@ class FormatterLambda final : public FormatterBase {
     explicit FormatterLambda(funct_t funct) : lambda_(std::move(funct)) {}
 
     /// Adding a destructor (mostly to make GCC 4.7 happy)
-    ~FormatterLambda() noexcept override {} // NOLINT(modernize-use-equals-default)
+    ~FormatterLambda() noexcept override {}  // NOLINT(modernize-use-equals-default)
 
     /// This will simply call the lambda function
     std::string make_help(const App *app, std::string name, AppFormatMode mode) const override {
@@ -3318,9 +3334,9 @@ class Formatter : public FormatterBase {
     ///@}
 };
 
-} // namespace CLI
+}  // namespace CLI
 
-// From CLI/Option.hpp:
+// From Option.hpp:
 
 namespace CLI {
 
@@ -3334,11 +3350,11 @@ class App;
 using Option_p = std::unique_ptr<Option>;
 /// Enumeration of the multiOption Policy selection
 enum class MultiOptionPolicy : char {
-    Throw,     //!< Throw an error if any extra arguments were given
-    TakeLast,  //!< take only the last Expected number of arguments
-    TakeFirst, //!< take only the first Expected number of arguments
-    Join,      //!< merge all the arguments together into a single string via the delimiter character default('\n')
-    TakeAll    //!< just get all the passed argument regardless
+    Throw,      //!< Throw an error if any extra arguments were given
+    TakeLast,   //!< take only the last Expected number of arguments
+    TakeFirst,  //!< take only the first Expected number of arguments
+    Join,       //!< merge all the arguments together into a single string via the delimiter character default('\n')
+    TakeAll     //!< just get all the passed argument regardless
 };
 
 /// This is the CRTP base class for Option and OptionDefaults. It was designed this way
@@ -3617,10 +3633,10 @@ class Option : public OptionBase<Option> {
     results_t proc_results_{};
     /// enumeration for the option state machine
     enum class option_state {
-        parsing = 0,      //!< The option is currently collecting parsed results
-        validated = 2,    //!< the results have been validated
-        reduced = 4,      //!< a subset of results has been generated
-        callback_run = 6, //!< the callback has been executed
+        parsing = 0,       //!< The option is currently collecting parsed results
+        validated = 2,     //!< the results have been validated
+        reduced = 4,       //!< a subset of results has been generated
+        callback_run = 6,  //!< the callback has been executed
     };
     /// Whether the callback has run (needed for INI parsing)
     option_state current_option_state_{option_state::parsing};
@@ -3807,7 +3823,7 @@ class Option : public OptionBase<Option> {
 
     /// Can find a string if needed
     template <typename T = App> Option *needs(std::string opt_name) {
-        auto opt = dynamic_cast<T *>(parent_)->get_option_no_throw(opt_name);
+        auto opt = static_cast<T *>(parent_)->get_option_no_throw(opt_name);
         if(opt == nullptr) {
             throw IncorrectConstruction::MissingOption(opt_name);
         }
@@ -3849,7 +3865,7 @@ class Option : public OptionBase<Option> {
 
     /// Can find a string if needed
     template <typename T = App> Option *excludes(std::string opt_name) {
-        auto opt = dynamic_cast<T *>(parent_)->get_option_no_throw(opt_name);
+        auto opt = static_cast<T *>(parent_)->get_option_no_throw(opt_name);
         if(opt == nullptr) {
             throw IncorrectConstruction::MissingOption(opt_name);
         }
@@ -3886,7 +3902,7 @@ class Option : public OptionBase<Option> {
     template <typename T = App> Option *ignore_case(bool value = true) {
         if(!ignore_case_ && value) {
             ignore_case_ = value;
-            auto *parent = dynamic_cast<T *>(parent_);
+            auto *parent = static_cast<T *>(parent_);
             for(const Option_p &opt : parent->options_) {
                 if(opt.get() == this) {
                     continue;
@@ -3911,7 +3927,7 @@ class Option : public OptionBase<Option> {
 
         if(!ignore_underscore_ && value) {
             ignore_underscore_ = value;
-            auto *parent = dynamic_cast<T *>(parent_);
+            auto *parent = static_cast<T *>(parent_);
             for(const Option_p &opt : parent->options_) {
                 if(opt.get() == this) {
                     continue;
@@ -3932,8 +3948,8 @@ class Option : public OptionBase<Option> {
     Option *multi_option_policy(MultiOptionPolicy value = MultiOptionPolicy::Throw) {
         if(value != multi_option_policy_) {
             if(multi_option_policy_ == MultiOptionPolicy::Throw && expected_max_ == detail::expected_max_vector_size &&
-               expected_min_ > 1) { // this bizarre condition is to maintain backwards compatibility
-                                    // with the previous behavior of expected_ with vectors
+               expected_min_ > 1) {  // this bizarre condition is to maintain backwards compatibility
+                                     // with the previous behavior of expected_ with vectors
                 expected_max_ = expected_min_;
             }
             multi_option_policy_ = value;
@@ -4028,11 +4044,11 @@ class Option : public OptionBase<Option> {
     /// Will include / prefer the positional name if positional is true.
     /// If all_options is false, pick just the most descriptive name to show.
     /// Use `get_name(true)` to get the positional name (replaces `get_pname`)
-    std::string get_name(bool positional = false, //<[input] Show the positional name
-                         bool all_options = false //<[input] Show every option
+    std::string get_name(bool positional = false,  ///< Show the positional name
+                         bool all_options = false  ///< Show every option
                          ) const {
         if(get_group().empty())
-            return {}; // Hidden
+            return {};  // Hidden
 
         if(all_options) {
 
@@ -4123,7 +4139,7 @@ class Option : public OptionBase<Option> {
                 return lname;
 
         if(ignore_case_ ||
-           ignore_underscore_) { // We need to do the inverse, in case we are ignore_case or ignore underscore
+           ignore_underscore_) {  // We need to do the inverse, in case we are ignore_case or ignore underscore
             for(const std::string &sname : other.snames_)
                 if(check_sname(sname))
                     return sname;
@@ -4275,7 +4291,7 @@ class Option : public OptionBase<Option> {
             results_t res;
             if(results_.empty()) {
                 if(!default_str_.empty()) {
-                    //_add_results takes an rvalue only
+                    // _add_results takes an rvalue only
                     _add_result(std::string(default_str_), res);
                     _validate_results(res);
                     results_t extra;
@@ -4391,7 +4407,7 @@ class Option : public OptionBase<Option> {
         try {
             add_result(val_str);
             if(run_callback_for_default_) {
-                run_callback(); // run callback sets the state we need to reset it again
+                run_callback();  // run callback sets the state we need to reset it again
                 current_option_state_ = option_state::parsing;
             } else {
                 _validate_results(results_);
@@ -4427,7 +4443,7 @@ class Option : public OptionBase<Option> {
     void _validate_results(results_t &res) const {
         // Run the Validators (can change the string)
         if(!validators_.empty()) {
-            if(type_size_max_ > 1) { // in this context index refers to the index in the type
+            if(type_size_max_ > 1) {  // in this context index refers to the index in the type
                 int index = 0;
                 if(get_items_expected_max() < static_cast<int>(res.size()) &&
                    multi_option_policy_ == CLI::MultiOptionPolicy::TakeLast) {
@@ -4437,7 +4453,7 @@ class Option : public OptionBase<Option> {
 
                 for(std::string &result : res) {
                     if(result.empty() && type_size_max_ != type_size_min_ && index >= 0) {
-                        index = 0; // reset index for variable size chunks
+                        index = 0;  // reset index for variable size chunks
                         continue;
                     }
                     auto err_msg = _validate(result, (index >= 0) ? (index % type_size_max_) : index);
@@ -4543,7 +4559,7 @@ class Option : public OptionBase<Option> {
     int _add_result(std::string &&result, std::vector<std::string> &res) const {
         int result_count = 0;
         if(allow_extra_args_ && !result.empty() && result.front() == '[' &&
-           result.back() == ']') { // this is now a vector string likely from the default or user entry
+           result.back() == ']') {  // this is now a vector string likely from the default or user entry
             result.pop_back();
 
             for(auto &var : CLI::detail::split(result.substr(1), ',')) {
@@ -4571,11 +4587,11 @@ class Option : public OptionBase<Option> {
         }
         return result_count;
     }
-}; // namespace CLI
+};  // namespace CLI
 
-} // namespace CLI
+}  // namespace CLI
 
-// From CLI/App.hpp:
+// From App.hpp:
 
 namespace CLI {
 
@@ -4591,12 +4607,12 @@ namespace CLI {
 namespace detail {
 enum class Classifier { NONE, POSITIONAL_MARK, SHORT, LONG, WINDOWS, SUBCOMMAND, SUBCOMMAND_TERMINATOR };
 struct AppFriend;
-} // namespace detail
+}  // namespace detail
 
 namespace FailureMessage {
 std::string simple(const App *app, const Error &e);
 std::string help(const App *app, const Error &e);
-} // namespace FailureMessage
+}  // namespace FailureMessage
 
 /// enumeration of modes of how to deal with extras in config files
 
@@ -5012,7 +5028,7 @@ class App {
             auto *p = (parent_ != nullptr) ? _get_fallthrough_parent() : this;
             auto &match = _compare_subcommand_names(*this, *p);
             if(!match.empty()) {
-                ignore_case_ = false; // we are throwing so need to be exception invariant
+                ignore_case_ = false;  // we are throwing so need to be exception invariant
                 throw OptionAlreadyAdded("ignore case would cause subcommand name conflicts: " + match);
             }
         }
@@ -5134,7 +5150,7 @@ class App {
             }
         }
         // this line should not be reached the above loop should trigger the throw
-        throw(OptionAlreadyAdded("added option matched existing option name")); // LCOV_EXCL_LINE
+        throw(OptionAlreadyAdded("added option matched existing option name"));  // LCOV_EXCL_LINE
     }
 
     /// Add option for assigning to a variable
@@ -5142,11 +5158,11 @@ class App {
               typename ConvertTo = AssignTo,
               enable_if_t<!std::is_const<ConvertTo>::value, detail::enabler> = detail::dummy>
     Option *add_option(std::string option_name,
-                       AssignTo &variable, ///< The variable to set
+                       AssignTo &variable,  ///< The variable to set
                        std::string option_description = "",
                        bool defaulted = false) {
 
-        auto fun = [&variable](const CLI::results_t &res) { // comment for spacing
+        auto fun = [&variable](const CLI::results_t &res) {  // comment for spacing
             return detail::lexical_conversion<AssignTo, ConvertTo>(res, variable);
         };
 
@@ -5167,7 +5183,7 @@ class App {
     /// Add option for a callback of a specific type
     template <typename T>
     Option *add_option_function(std::string option_name,
-                                const std::function<void(const T &)> &func, ///< the callback to execute
+                                const std::function<void(const T &)> &func,  ///< the callback to execute
                                 std::string option_description = "") {
 
         auto fun = [func](const CLI::results_t &res) {
@@ -5279,7 +5295,7 @@ class App {
     template <typename T,
               enable_if_t<std::is_integral<T>::value && !is_bool<T>::value, detail::enabler> = detail::dummy>
     Option *add_flag(std::string flag_name,
-                     T &flag_count, ///< A variable holding the count
+                     T &flag_count,  ///< A variable holding the count
                      std::string flag_description = "") {
         flag_count = 0;
         CLI::callback_t fun = [&flag_count](const CLI::results_t &res) {
@@ -5302,7 +5318,7 @@ class App {
                               !std::is_constructible<std::function<void(int)>, T>::value,
                           detail::enabler> = detail::dummy>
     Option *add_flag(std::string flag_name,
-                     T &flag_result, ///< A variable holding true if passed
+                     T &flag_result,  ///< A variable holding true if passed
                      std::string flag_description = "") {
 
         CLI::callback_t fun = [&flag_result](const CLI::results_t &res) {
@@ -5312,10 +5328,11 @@ class App {
     }
 
     /// Vector version to capture multiple flags.
-    template <typename T,
-              enable_if_t<!std::is_assignable<std::function<void(int64_t)>, T>::value, detail::enabler> = detail::dummy>
+    template <
+        typename T,
+        enable_if_t<!std::is_assignable<std::function<void(std::int64_t)>, T>::value, detail::enabler> = detail::dummy>
     Option *add_flag(std::string flag_name,
-                     std::vector<T> &flag_results, ///< A vector of values with the flag results
+                     std::vector<T> &flag_results,  ///< A vector of values with the flag results
                      std::string flag_description = "") {
         CLI::callback_t fun = [&flag_results](const CLI::results_t &res) {
             bool retval = true;
@@ -5332,7 +5349,7 @@ class App {
 
     /// Add option for callback that is triggered with a true flag and takes no arguments
     Option *add_flag_callback(std::string flag_name,
-                              std::function<void(void)> function, ///< A function to call, void(void)
+                              std::function<void(void)> function,  ///< A function to call, void(void)
                               std::string flag_description = "") {
 
         CLI::callback_t fun = [function](const CLI::results_t &res) {
@@ -5348,11 +5365,11 @@ class App {
 
     /// Add option for callback with an integer value
     Option *add_flag_function(std::string flag_name,
-                              std::function<void(int64_t)> function, ///< A function to call, void(int)
+                              std::function<void(std::int64_t)> function,  ///< A function to call, void(int)
                               std::string flag_description = "") {
 
         CLI::callback_t fun = [function](const CLI::results_t &res) {
-            int64_t flag_count = 0;
+            std::int64_t flag_count = 0;
             detail::sum_flag_vector(res, flag_count);
             function(flag_count);
             return true;
@@ -5364,7 +5381,7 @@ class App {
 #ifdef CLI11_CPP14
     /// Add option for callback (C++14 or better only)
     Option *add_flag(std::string flag_name,
-                     std::function<void(int64_t)> function, ///< A function to call, void(int64_t)
+                     std::function<void(std::int64_t)> function,  ///< A function to call, void(std::int64_t)
                      std::string flag_description = "") {
         return add_flag_function(std::move(flag_name), std::move(function), std::move(flag_description));
     }
@@ -5373,8 +5390,8 @@ class App {
     /// Add set of options (No default, temp reference, such as an inline set) DEPRECATED
     template <typename T>
     Option *add_set(std::string option_name,
-                    T &member,           ///< The selected member of the set
-                    std::set<T> options, ///< The set of possibilities
+                    T &member,            ///< The selected member of the set
+                    std::set<T> options,  ///< The set of possibilities
                     std::string option_description = "") {
 
         Option *opt = add_option(option_name, member, std::move(option_description));
@@ -5385,8 +5402,8 @@ class App {
     /// Add set of options (No default, set can be changed afterwards - do not destroy the set) DEPRECATED
     template <typename T>
     Option *add_mutable_set(std::string option_name,
-                            T &member,                  ///< The selected member of the set
-                            const std::set<T> &options, ///< The set of possibilities
+                            T &member,                   ///< The selected member of the set
+                            const std::set<T> &options,  ///< The set of possibilities
                             std::string option_description = "") {
 
         Option *opt = add_option(option_name, member, std::move(option_description));
@@ -5397,8 +5414,8 @@ class App {
     /// Add set of options (with default, static set, such as an inline set) DEPRECATED
     template <typename T>
     Option *add_set(std::string option_name,
-                    T &member,           ///< The selected member of the set
-                    std::set<T> options, ///< The set of possibilities
+                    T &member,            ///< The selected member of the set
+                    std::set<T> options,  ///< The set of possibilities
                     std::string option_description,
                     bool defaulted) {
 
@@ -5410,8 +5427,8 @@ class App {
     /// Add set of options (with default, set can be changed afterwards - do not destroy the set) DEPRECATED
     template <typename T>
     Option *add_mutable_set(std::string option_name,
-                            T &member,                  ///< The selected member of the set
-                            const std::set<T> &options, ///< The set of possibilities
+                            T &member,                   ///< The selected member of the set
+                            const std::set<T> &options,  ///< The set of possibilities
                             std::string option_description,
                             bool defaulted) {
 
@@ -5479,7 +5496,7 @@ class App {
         // Remove existing config if present
         if(config_ptr_ != nullptr) {
             remove_option(config_ptr_);
-            config_ptr_ = nullptr; // need to remove the config_ptr completely
+            config_ptr_ = nullptr;  // need to remove the config_ptr completely
         }
 
         // Only add config if option passed
@@ -5522,7 +5539,7 @@ class App {
     /// creates an option group as part of the given app
     template <typename T = Option_group>
     T *add_option_group(std::string group_name, std::string group_description = "") {
-        auto option_group = std::make_shared<T>(std::move(group_description), group_name, nullptr);
+        auto option_group = std::make_shared<T>(std::move(group_description), group_name, this);
         auto ptr = option_group.get();
         // move to App_p for overload resolution on older gcc versions
         App_p app_ptr = std::dynamic_pointer_cast<App>(option_group);
@@ -5531,7 +5548,7 @@ class App {
     }
 
     ///@}
-    /// @name Subcommmands
+    /// @name Subcommands
     ///@{
 
     /// Add a subcommand. Inherits INHERITABLE and OptionDefaults, and help flag
@@ -5654,7 +5671,7 @@ class App {
         for(auto &sub : subcommands_) {
             cnt += sub->count_all();
         }
-        if(!get_name().empty()) { // for named subcommands add the number of times the subcommand was called
+        if(!get_name().empty()) {  // for named subcommands add the number of times the subcommand was called
             cnt += parsed_;
         }
         return cnt;
@@ -5793,8 +5810,9 @@ class App {
                 name_ = nstr.first;
             }
             commandline = std::move(nstr.second);
-        } else
+        } else {
             detail::trim(commandline);
+        }
         // the next section of code is to deal with quoted arguments after an '=' or ':' for windows like operations
         if(!commandline.empty()) {
             commandline = detail::find_and_modify(commandline, "=", detail::escape_detect);
@@ -5860,15 +5878,15 @@ class App {
     int exit(const Error &e, std::ostream &out = std::cout, std::ostream &err = std::cerr) const {
 
         /// Avoid printing anything if this is a CLI::RuntimeError
-        if(dynamic_cast<const CLI::RuntimeError *>(&e) != nullptr)
+        if(e.get_name() == "RuntimeError")
             return e.get_exit_code();
 
-        if(dynamic_cast<const CLI::CallForHelp *>(&e) != nullptr) {
+        if(e.get_name() == "CallForHelp") {
             out << help();
             return e.get_exit_code();
         }
 
-        if(dynamic_cast<const CLI::CallForAllHelp *>(&e) != nullptr) {
+        if(e.get_name() == "CallForAllHelp") {
             out << help("", AppFormatMode::All);
             return e.get_exit_code();
         }
@@ -6070,7 +6088,12 @@ class App {
 
     /// Access the config formatter as a configBase pointer
     std::shared_ptr<ConfigBase> get_config_formatter_base() const {
+        // This is safer as a dynamic_cast if we have RTTI, as Config -> ConfigBase
+#if defined(__cpp_rtti) || (defined(__GXX_RTTI) && __GXX_RTTI) || (defined(_HAS_STATIC_RTTI) && (_HAS_STATIC_RTTI == 0))
         return std::dynamic_pointer_cast<ConfigBase>(config_formatter_);
+#else
+        return std::static_pointer_cast<ConfigBase>(config_formatter_);
+#endif
     }
 
     /// Get the app or subcommand description
@@ -6427,7 +6450,7 @@ class App {
                 app->name_.clear();
             }
             if(app->name_.empty()) {
-                app->fallthrough_ = false; // make sure fallthrough_ is false to prevent infinite loop
+                app->fallthrough_ = false;  // make sure fallthrough_ is false to prevent infinite loop
                 app->prefix_command_ = false;
             }
             // make sure the parent is set to be this object in preparation for parse
@@ -7203,14 +7226,14 @@ class App {
         int max_num = op->get_items_expected_max();
 
         // Make sure we always eat the minimum for unlimited vectors
-        int collected = 0;    // total number of arguments collected
-        int result_count = 0; // local variable for number of results in a single arg string
+        int collected = 0;     // total number of arguments collected
+        int result_count = 0;  // local variable for number of results in a single arg string
         // deal with purely flag like things
         if(max_num == 0) {
             auto res = op->get_flag_value(arg_name, value);
             op->add_result(res);
             parse_order_.push_back(op.get());
-        } else if(!value.empty()) { // --this=value
+        } else if(!value.empty()) {  // --this=value
             op->add_result(value, result_count);
             parse_order_.push_back(op.get());
             collected += result_count;
@@ -7231,11 +7254,11 @@ class App {
             collected += result_count;
         }
 
-        if(min_num > collected) { // if we have run out of arguments and the minimum was not met
+        if(min_num > collected) {  // if we have run out of arguments and the minimum was not met
             throw ArgumentMismatch::TypedAtLeast(op->get_name(), min_num, op->get_type_name());
         }
 
-        if(max_num > collected || op->get_allow_extra_args()) { // we allow optional arguments
+        if(max_num > collected || op->get_allow_extra_args()) {  // we allow optional arguments
             auto remreqpos = _count_remaining_positionals(true);
             // we have met the minimum now optionally check up to the maximum
             while((collected < max_num || op->get_allow_extra_args()) && !args.empty() &&
@@ -7412,7 +7435,7 @@ class App {
             throw OptionNotFound("could not locate the given Option");
         }
     }
-}; // namespace CLI
+};  // namespace CLI
 
 /// Extension of App to better manage groups of options
 class Option_group : public App {
@@ -7596,12 +7619,23 @@ inline std::string help(const App *app, const Error &e) {
     return header;
 }
 
-} // namespace FailureMessage
+}  // namespace FailureMessage
 
 namespace detail {
 /// This class is simply to allow tests access to App's protected functions
 struct AppFriend {
+#ifdef CLI11_CPP14
 
+    /// Wrap _parse_short, perfectly forward arguments and return
+    template <typename... Args> static decltype(auto) parse_arg(App *app, Args &&... args) {
+        return app->_parse_arg(std::forward<Args>(args)...);
+    }
+
+    /// Wrap _parse_subcommand, perfectly forward arguments and return
+    template <typename... Args> static decltype(auto) parse_subcommand(App *app, Args &&... args) {
+        return app->_parse_subcommand(std::forward<Args>(args)...);
+    }
+#else
     /// Wrap _parse_short, perfectly forward arguments and return
     template <typename... Args>
     static auto parse_arg(App *app, Args &&... args) ->
@@ -7615,14 +7649,15 @@ struct AppFriend {
         typename std::result_of<decltype (&App::_parse_subcommand)(App, Args...)>::type {
         return app->_parse_subcommand(std::forward<Args>(args)...);
     }
+#endif
     /// Wrap the fallthrough parent function to make sure that is working correctly
     static App *get_fallthrough_parent(App *app) { return app->_get_fallthrough_parent(); }
 };
-} // namespace detail
+}  // namespace detail
 
-} // namespace CLI
+}  // namespace CLI
 
-// From CLI/Config.hpp:
+// From Config.hpp:
 
 namespace CLI {
 
@@ -7767,7 +7802,7 @@ inline void checkParentSegments(std::vector<ConfigItem> &output, const std::stri
     output.back().parents = std::move(parents);
     output.back().name = "++";
 }
-} // namespace detail
+}  // namespace detail
 
 inline std::vector<ConfigItem> ConfigBase::from_config(std::istream &input) const {
     std::string line;
@@ -7950,9 +7985,9 @@ ConfigBase::to_config(const App *app, bool default_also, bool write_description,
     return out.str();
 }
 
-} // namespace CLI
+}  // namespace CLI
 
-// From CLI/Formatter.hpp:
+// From Formatter.hpp:
 
 namespace CLI {
 
@@ -7985,11 +8020,11 @@ inline std::string Formatter::make_groups(const App *app, AppFormatMode mode) co
     // Options
     for(const std::string &group : groups) {
         std::vector<const Option *> opts = app->get_options([app, mode, &group](const Option *opt) {
-            return opt->get_group() == group                    // Must be in the right group
-                   && opt->nonpositional()                      // Must not be a positional
-                   && (mode != AppFormatMode::Sub               // If mode is Sub, then
-                       || (app->get_help_ptr() != opt           // Ignore help pointer
-                           && app->get_help_all_ptr() != opt)); // Ignore help all pointer
+            return opt->get_group() == group                     // Must be in the right group
+                   && opt->nonpositional()                       // Must not be a positional
+                   && (mode != AppFormatMode::Sub                // If mode is Sub, then
+                       || (app->get_help_ptr() != opt            // Ignore help pointer
+                           && app->get_help_all_ptr() != opt));  // Ignore help all pointer
         });
         if(!group.empty() && !opts.empty()) {
             out << make_group(group, false, opts);
@@ -8161,7 +8196,7 @@ inline std::string Formatter::make_expanded(const App *sub) const {
 
     // Drop blank spaces
     std::string tmp = detail::find_and_replace(out.str(), "\n\n", "\n");
-    tmp = tmp.substr(0, tmp.size() - 1); // Remove the final '\n'
+    tmp = tmp.substr(0, tmp.size() - 1);  // Remove the final '\n'
 
     // Indent all but the first line (the name)
     return detail::find_and_replace(tmp, "\n", "\n  ") + "\n";
@@ -8219,5 +8254,5 @@ inline std::string Formatter::make_option_usage(const Option *opt) const {
     return opt->get_required() ? out.str() : "[" + out.str() + "]";
 }
 
-} // namespace CLI
+}  // namespace CLI
 
diff --git a/tests/smoketest.cpp b/tests/smoketest.cpp
index f9437bb8..52f93bb0 100644
--- a/tests/smoketest.cpp
+++ b/tests/smoketest.cpp
@@ -9,6 +9,8 @@
 #include "input/inputdatalocator.h"
 #include "input/parsers/abbadingoparser.h"
 
+using Catch::Matchers::Equals;
+
 //TODO: refactor: These should probably be taken out of main.cpp
 evaluation_function* get_evaluation();
 void print_current_automaton(state_merger*, const string&, const string&);
@@ -101,4 +103,72 @@ TEST_CASE( "Smoke test: abbadingo input data with empty traces", "[smoke]" ) {
     id.read(&parser);
 
     REQUIRE(id.get_num_sequences() == 20000);
+}
+
+// This tests verifies that the dot file output works as expected
+// It will need updating whenever the dot output changes
+// TODO: Figure out a way to check if the dot output is valid without running graphviz
+TEST_CASE( "Smoke test: dot output", "[smoke]" ) {
+    HEURISTIC_NAME = "evidence_driven";
+    DATA_NAME = "edsm_data";
+
+    evaluation_function *eval = get_evaluation();
+    REQUIRE(eval != nullptr);
+
+    std::string input = "12 4\n"
+                        "1 3 a b c\n"
+                        "1 3 a b d\n"
+                        "0 2 a b\n"
+                        "0 2 a a\n"
+                        "0 2 b b\n"
+                        "0 1 c\n"
+                        "0 2 c c\n"
+                        "0 1 d\n"
+                        "0 2 d d\n"
+                        "0 1 a\n"
+                        "0 2 b c\n"
+                        "0 2 b d\n";
+    std::istringstream input_stream(input);
+
+    inputdata id;
+    inputdata_locator::provide(&id);
+    auto parser = abbadingoparser(input_stream);
+    id.read(&parser);
+
+    apta* the_apta = new apta();
+    auto* merger = new state_merger(&id, eval, the_apta);
+    the_apta->set_context(merger);
+    eval->set_context(merger);
+
+    eval->initialize_before_adding_traces();
+    id.add_traces_to_apta(the_apta);
+    eval->initialize_after_adding_traces(merger);
+
+    greedy_run(merger);
+
+    std::stringstream dot_stream;
+    merger->print_dot(dot_stream);
+    std::string actual_output = dot_stream.str();
+
+    std::string expected_output = "// produced with flexfringe // \n"
+                                  "digraph DFA {\n"
+                                  "\t-1 [label=\"root\" shape=box];\n"
+                                  "\t\tI -> -1;\n"
+                                  "\t-1 [ label=\"-1 #25 fin: 0:8 , \n"
+                                  " path: 1:2 , 0:15 , \" , style=filled, fillcolor=\"firebrick1\", width=1.44882, height=1.44882, penwidth=3.2581];\n"
+                                  "\t\t-1 -> 1 [label=\"a \" , penwidth=3.2581 ];\n"
+                                  "\t\t-1 -> -1 [label=\"b \" , penwidth=3.2581 ];\n"
+                                  "\t\t-1 -> -1 [label=\"c \" , penwidth=3.2581 ];\n"
+                                  "\t\t-1 -> -1 [label=\"d \" , penwidth=3.2581 ];\n"
+                                  "\t1 [ label=\"1 #8 fin: 0:2 , \n"
+                                  " path: 1:4 , 0:2 , \" , style=filled, fillcolor=\"firebrick1\", width=1.16228, height=1.16228, penwidth=2.19722];\n"
+                                  "\t\t1 -> -1 [label=\"a \" , penwidth=2.19722 ];\n"
+                                  "\t\t1 -> 1 [label=\"b \" , penwidth=2.19722 ];\n"
+                                  "\t\t1 -> 3 [label=\"c \" , penwidth=2.19722 ];\n"
+                                  "\t\t1 -> 3 [label=\"d \" , penwidth=2.19722 ];\n"
+                                  "\t3 [ label=\"3 #2 fin: 1:2 , \n"
+                                  " path: \" , style=filled, fillcolor=\"firebrick1\", width=0.741276, height=0.741276, penwidth=1.09861];\n"
+                                  "}\n";
+
+    REQUIRE_THAT(actual_output, Equals(expected_output));
 }
\ No newline at end of file
diff --git a/tests/testabbadingoparser.cpp b/tests/testabbadingoparser.cpp
index 45648f71..1d9d94b0 100644
--- a/tests/testabbadingoparser.cpp
+++ b/tests/testabbadingoparser.cpp
@@ -13,6 +13,7 @@
 #include <lexy/action/match.hpp>
 #include "input/parsers/grammar/abbadingoheader.h"
 #include "input/parsers/grammar/abbadingosymbol.h"
+#include "input/inputdatalocator.h"
 
 TEST_CASE("abbadingo header parser: number", "[parsing]") {
     auto input = lexy::zstring_input("123");
@@ -363,3 +364,18 @@ TEST_CASE("abbadingo_parser: smoke test with symbol attributes", "[parsing]") {
     REQUIRE(!fourth_sattr_info.at(0).is_target());
 
 }
+
+TEST_CASE("abbadingo_parser: add single trace", "[parsing]") {
+    std::string input = "0 3 a b c";
+    std::istringstream inputstream(input);
+
+    auto parser = abbadingoparser::single_trace(inputstream);
+    auto input_data = inputdata();
+    inputdata_locator::provide(&input_data);
+    input_data.read(&parser);
+
+    std::vector<trace*> traces(input_data.begin(), input_data.end());
+
+    REQUIRE(traces.size() == 1);
+    REQUIRE(traces.at(0)->to_string() == "0 3 a b c");
+}
\ No newline at end of file