diff --git a/include/verilated_saif_c.cpp b/include/verilated_saif_c.cpp
index 25ed11a27..0cfd1499e 100644
--- a/include/verilated_saif_c.cpp
+++ b/include/verilated_saif_c.cpp
@@ -83,8 +83,7 @@ void ActivityVar::emitWData(uint64_t time, const WData* newvalp, uint32_t bits)
     updateLastTime(time);
 }
 
-ActivityBit& ActivityVar::getBit(std::size_t index)
-{
+ActivityBit& ActivityVar::getBit(std::size_t index) {
     assert(index < m_width);
     return m_bits[index];
 }
@@ -95,7 +94,8 @@ ActivityBit& ActivityVar::getBit(std::size_t index)
 // VerilatedSaifFile
 
 bool VerilatedSaifFile::open(const std::string& name) VL_MT_UNSAFE {
-    m_fd = ::open(name.c_str(), O_CREAT | O_WRONLY | O_TRUNC | O_LARGEFILE | O_NONBLOCK | O_CLOEXEC, 0666);
+    m_fd = ::open(name.c_str(),
+                  O_CREAT | O_WRONLY | O_TRUNC | O_LARGEFILE | O_NONBLOCK | O_CLOEXEC, 0666);
     return m_fd >= 0;
 }
 
@@ -249,12 +249,10 @@ void VerilatedSaif::finalizeSaifFileContents() {
     printStr(")\n");
 
     incrementIndent();
-    for (int32_t topScopeIndex : m_topScopes) {
-        recursivelyPrintScopes(topScopeIndex);
-    }
+    for (int32_t topScopeIndex : m_topScopes) { recursivelyPrintScopes(topScopeIndex); }
     decrementIndent();
-    
-    printStr(")\n"); // SAIFILE
+
+    printStr(")\n");  // SAIFILE
 }
 
 void VerilatedSaif::recursivelyPrintScopes(uint32_t scopeIndex) {
@@ -293,9 +291,7 @@ void VerilatedSaif::printScopeActivities(const ActivityScope& scope) {
         anyNetValid = printActivityStats(code, name, anyNetValid);
     }
 
-    if (anyNetValid) {
-        closeNetScope();
-    }
+    if (anyNetValid) { closeNetScope(); }
 }
 
 void VerilatedSaif::openNetScope() {
@@ -310,7 +306,8 @@ void VerilatedSaif::closeNetScope() {
     printStr(")\n");
 }
 
-bool VerilatedSaif::printActivityStats(uint32_t activityCode, const char* activityName, bool anyNetValid){
+bool VerilatedSaif::printActivityStats(uint32_t activityCode, const char* activityName,
+                                       bool anyNetValid) {
     ActivityVar& activity = m_activity.at(activityCode);
     for (size_t i = 0; i < activity.getWidth(); i++) {
         ActivityBit& bit = activity.getBit(i);
@@ -351,8 +348,7 @@ bool VerilatedSaif::printActivityStats(uint32_t activityCode, const char* activi
     return anyNetValid;
 }
 
-void VerilatedSaif::clearCurrentlyCollectedData()
-{
+void VerilatedSaif::clearCurrentlyCollectedData() {
     m_currentScope = -1;
     m_scopes.clear();
     m_topScopes.clear();
@@ -371,15 +367,9 @@ void VerilatedSaif::flush() VL_MT_SAFE_EXCLUDES(m_mutex) {
     Super::flushBase();
 }
 
-void VerilatedSaif::incrementIndent()
-{
-    m_indent += 1;
-}
+void VerilatedSaif::incrementIndent() { m_indent += 1; }
 
-void VerilatedSaif::decrementIndent()
-{
-    m_indent -= 1;
-}
+void VerilatedSaif::decrementIndent() { m_indent -= 1; }
 
 void VerilatedSaif::printIndent() {
     for (int i = 0; i < m_indent; ++i) printStr(" ");
@@ -389,11 +379,10 @@ void VerilatedSaif::pushPrefix(const std::string& name, VerilatedTracePrefixType
     assert(!m_prefixStack.empty());
 
     std::string pname = name;
-    if (pname.empty()) {
-        pname = "$rootio";
-    }
+    if (pname.empty()) { pname = "$rootio"; }
 
-    if (type != VerilatedTracePrefixType::ARRAY_UNPACKED && type != VerilatedTracePrefixType::ARRAY_PACKED) {
+    if (type != VerilatedTracePrefixType::ARRAY_UNPACKED
+        && type != VerilatedTracePrefixType::ARRAY_PACKED) {
         int32_t newScopeIndex = m_scopes.size();
         if (m_currentScope >= 0) {
             m_scopes.at(m_currentScope).addChildScopeIndex(newScopeIndex);
@@ -405,36 +394,36 @@ void VerilatedSaif::pushPrefix(const std::string& name, VerilatedTracePrefixType
     }
 
     std::string newPrefix = m_prefixStack.back().first + pname;
-    if (type != VerilatedTracePrefixType::ARRAY_UNPACKED && type != VerilatedTracePrefixType::ARRAY_PACKED) {
+    if (type != VerilatedTracePrefixType::ARRAY_UNPACKED
+        && type != VerilatedTracePrefixType::ARRAY_PACKED) {
         newPrefix += ' ';
     }
-    
+
     m_prefixStack.emplace_back(newPrefix, type);
 }
 
 void VerilatedSaif::popPrefix() {
     assert(m_prefixStack.size() > 1);
 
-    if (m_prefixStack.back().second != VerilatedTracePrefixType::ARRAY_UNPACKED && m_prefixStack.back().second != VerilatedTracePrefixType::ARRAY_PACKED) {
+    if (m_prefixStack.back().second != VerilatedTracePrefixType::ARRAY_UNPACKED
+        && m_prefixStack.back().second != VerilatedTracePrefixType::ARRAY_PACKED) {
         m_currentScope = m_scopes.at(m_currentScope).getParentScopeIndex();
     }
 
     m_prefixStack.pop_back();
 }
 
-
 void VerilatedSaif::declare(uint32_t code, const char* name, const char* wirep, bool array,
                             int arraynum, bool bussed, int msb, int lsb) {
     const int bits = ((msb > lsb) ? (msb - lsb) : (lsb - msb)) + 1;
 
     std::string hierarchicalName = m_prefixStack.back().first + name;
 
-    if (!Super::declCode(code, hierarchicalName, bits)) {
-        return;
-    }
+    if (!Super::declCode(code, hierarchicalName, bits)) { return; }
 
     const size_t block_size = 1024;
-    if (m_activityArena.empty() || m_activityArena.back().size() + bits > m_activityArena.back().capacity()) {
+    if (m_activityArena.empty()
+        || m_activityArena.back().size() + bits > m_activityArena.back().capacity()) {
         m_activityArena.emplace_back();
         m_activityArena.back().reserve(block_size);
     }
@@ -451,48 +440,39 @@ void VerilatedSaif::declare(uint32_t code, const char* name, const char* wirep,
     assert(m_currentScope >= 0);
     m_scopes.at(m_currentScope).addActivityVar(code, std::move(finalName));
 
-    m_activity.emplace(code, ActivityVar{
-        static_cast<uint32_t>(lsb),
-        static_cast<uint32_t>(bits),
-        m_activityArena.back().data() + bitsIdx
-    });
+    m_activity.emplace(code, ActivityVar{static_cast<uint32_t>(lsb), static_cast<uint32_t>(bits),
+                                         m_activityArena.back().data() + bitsIdx});
 }
 
-void VerilatedSaif::declEvent(
-        uint32_t code, uint32_t fidx, const char* name, int dtypenum, 
-        VerilatedTraceSigDirection, VerilatedTraceSigKind, VerilatedTraceSigType,
-        bool array, int arraynum) {
+void VerilatedSaif::declEvent(uint32_t code, uint32_t fidx, const char* name, int dtypenum,
+                              VerilatedTraceSigDirection, VerilatedTraceSigKind,
+                              VerilatedTraceSigType, bool array, int arraynum) {
     declare(code, name, "event", array, arraynum, false, 0, 0);
 }
 
-void VerilatedSaif::declBit(
-        uint32_t code, uint32_t fidx, const char* name, int dtypenum,
-        VerilatedTraceSigDirection, VerilatedTraceSigKind, VerilatedTraceSigType,
-        bool array, int arraynum) {
+void VerilatedSaif::declBit(uint32_t code, uint32_t fidx, const char* name, int dtypenum,
+                            VerilatedTraceSigDirection, VerilatedTraceSigKind,
+                            VerilatedTraceSigType, bool array, int arraynum) {
     declare(code, name, "wire", array, arraynum, false, 0, 0);
 }
-void VerilatedSaif::declBus(
-        uint32_t code, uint32_t fidx, const char* name, int dtypenum,
-        VerilatedTraceSigDirection, VerilatedTraceSigKind, VerilatedTraceSigType,
-        bool array, int arraynum, int msb, int lsb) {
+void VerilatedSaif::declBus(uint32_t code, uint32_t fidx, const char* name, int dtypenum,
+                            VerilatedTraceSigDirection, VerilatedTraceSigKind,
+                            VerilatedTraceSigType, bool array, int arraynum, int msb, int lsb) {
     declare(code, name, "wire", array, arraynum, true, msb, lsb);
 }
-void VerilatedSaif::declQuad(
-        uint32_t code, uint32_t fidx, const char* name, int dtypenum,
-        VerilatedTraceSigDirection, VerilatedTraceSigKind, VerilatedTraceSigType,
-        bool array, int arraynum, int msb, int lsb) {
+void VerilatedSaif::declQuad(uint32_t code, uint32_t fidx, const char* name, int dtypenum,
+                             VerilatedTraceSigDirection, VerilatedTraceSigKind,
+                             VerilatedTraceSigType, bool array, int arraynum, int msb, int lsb) {
     declare(code, name, "wire", array, arraynum, true, msb, lsb);
 }
-void VerilatedSaif::declArray(
-        uint32_t code, uint32_t fidx, const char* name, int dtypenum,
-        VerilatedTraceSigDirection, VerilatedTraceSigKind, VerilatedTraceSigType,
-        bool array, int arraynum, int msb, int lsb) {
+void VerilatedSaif::declArray(uint32_t code, uint32_t fidx, const char* name, int dtypenum,
+                              VerilatedTraceSigDirection, VerilatedTraceSigKind,
+                              VerilatedTraceSigType, bool array, int arraynum, int msb, int lsb) {
     declare(code, name, "wire", array, arraynum, true, msb, lsb);
 }
-void VerilatedSaif::declDouble(
-        uint32_t code, uint32_t fidx, const char* name, int dtypenum,
-        VerilatedTraceSigDirection, VerilatedTraceSigKind, VerilatedTraceSigType,
-        bool array, int arraynum) {
+void VerilatedSaif::declDouble(uint32_t code, uint32_t fidx, const char* name, int dtypenum,
+                               VerilatedTraceSigDirection, VerilatedTraceSigKind,
+                               VerilatedTraceSigType, bool array, int arraynum) {
     declare(code, name, "real", array, arraynum, false, 63, 0);
 }
 
diff --git a/include/verilated_saif_c.h b/include/verilated_saif_c.h
index dfd855644..5ff65e74b 100644
--- a/include/verilated_saif_c.h
+++ b/include/verilated_saif_c.h
@@ -25,8 +25,8 @@
 #include "verilated_trace.h"
 
 #include <string>
-#include <vector>
 #include <unordered_map>
+#include <vector>
 
 class VerilatedSaifBuffer;
 class VerilatedSaifFile;
@@ -64,7 +64,9 @@ class ActivityVar {
 public:
     // CONSTRUCTORS
     ActivityVar(uint32_t lsb, uint32_t width, ActivityBit* bits)
-        : m_lsb{lsb}, m_width{width}, m_bits{bits} {}
+        : m_lsb{lsb}
+        , m_width{width}
+        , m_bits{bits} {}
 
     ActivityVar(ActivityVar&&) = default;
     ActivityVar& operator=(ActivityVar&&) = default;
@@ -73,8 +75,7 @@ public:
     VL_ATTR_ALWINLINE void emitBit(uint64_t time, CData newval);
 
     template <typename DataType>
-    VL_ATTR_ALWINLINE
-    void emitData(uint64_t time, DataType newval, uint32_t bits) {
+    VL_ATTR_ALWINLINE void emitData(uint64_t time, DataType newval, uint32_t bits) {
         static_assert(std::is_integral<DataType>::value);
 
         uint64_t dt = time - m_lastTime;
@@ -110,20 +111,30 @@ class ActivityScope {
 public:
     // CONSTRUCTORS
     ActivityScope(std::string name, int32_t parentScopeIndex = -1)
-        : m_scopeName{std::move(name)}, m_parentScopeIndex{parentScopeIndex} {}
+        : m_scopeName{std::move(name)}
+        , m_parentScopeIndex{parentScopeIndex} {}
 
     ActivityScope(ActivityScope&&) = default;
     ActivityScope& operator=(ActivityScope&&) = default;
 
     // METHODS
-    VL_ATTR_ALWINLINE void addChildScopeIndex(int32_t index) { m_childScopesIndices.emplace_back(index); }
-    VL_ATTR_ALWINLINE void addActivityVar(uint32_t code, std::string name) { m_childActivities.emplace_back(code, std::move(name)); }
+    VL_ATTR_ALWINLINE void addChildScopeIndex(int32_t index) {
+        m_childScopesIndices.emplace_back(index);
+    }
+    VL_ATTR_ALWINLINE void addActivityVar(uint32_t code, std::string name) {
+        m_childActivities.emplace_back(code, std::move(name));
+    }
     VL_ATTR_ALWINLINE bool hasParent() const { return m_parentScopeIndex >= 0; }
 
     // ACCESSORS
     VL_ATTR_ALWINLINE const std::string& getName() const { return m_scopeName; }
-    VL_ATTR_ALWINLINE const std::vector<int32_t>& getChildScopesIndices() const { return m_childScopesIndices; }
-    VL_ATTR_ALWINLINE const std::vector<std::pair<uint32_t, std::string>>& getChildActivities() const { return m_childActivities; }
+    VL_ATTR_ALWINLINE const std::vector<int32_t>& getChildScopesIndices() const {
+        return m_childScopesIndices;
+    }
+    VL_ATTR_ALWINLINE const std::vector<std::pair<uint32_t, std::string>>&
+    getChildActivities() const {
+        return m_childActivities;
+    }
     VL_ATTR_ALWINLINE int32_t getParentScopeIndex() const { return m_parentScopeIndex; }
 
 private:
diff --git a/test_regress/driver.py b/test_regress/driver.py
index 2d8664969..96b39bd5c 100755
--- a/test_regress/driver.py
+++ b/test_regress/driver.py
@@ -66,6 +66,7 @@ class staticproperty(property):
     def __get__(self, owner_self, owner_cls):
         return self.fget()
 
+
 #######################################################################
 #######################################################################
 # SAIF parser utilities
@@ -92,8 +93,10 @@ class SAIFSignalBit:
 
         self.last_val = new_val
 
+
 class SAIFSignal:
-    def __init__(self, signal_name, signal_width = 0):
+
+    def __init__(self, signal_name, signal_width=0):
         self.name = signal_name
         self.width = signal_width
         self.last_time = 0
@@ -102,14 +105,18 @@ class SAIFSignal:
         for _ in range(self.width):
             self.bits.append(SAIFSignalBit())
 
+
 class SAIFInstance:
+
     def __init__(self, scope_name):
         self.scope_name = scope_name
         self.parent_instance = None
         self.nets = {}
         self.child_instances = {}
 
+
 class SAIFParser:
+
     def __init__(self):
         self.top_instances = {}
         self.current_instance = None
@@ -2502,7 +2509,9 @@ class VlTest:
 
     def compare_saif_instances(self, first: SAIFInstance, second: SAIFInstance):
         if len(first.nets) != len(second.nets):
-            self.error(f"Number of nets doesn't match in {first.scope_name}: {len(first.nets)} != {len(second.nets)}")
+            self.error(
+                f"Number of nets doesn't match in {first.scope_name}: {len(first.nets)} != {len(second.nets)}"
+            )
 
         for signal_name, saif_signal in first.nets.items():
             if signal_name not in second.nets:
@@ -2517,14 +2526,16 @@ class VlTest:
                 signal_bit = saif_signal.bits[bit_index]
                 other_signal_bit = other_signal.bits[bit_index]
 
-                if (signal_bit.high_time != other_signal_bit.high_time or
-                    signal_bit.low_time != other_signal_bit.low_time or
-                    signal_bit.transitions != other_signal_bit.transitions):
+                if (signal_bit.high_time != other_signal_bit.high_time
+                        or signal_bit.low_time != other_signal_bit.low_time
+                        or signal_bit.transitions != other_signal_bit.transitions):
                     self.error("Incompatible signal bit parameters in "
                                f"{signal_name}[{bit_index}]\n")
-                    
+
         if len(first.child_instances) != len(second.child_instances):
-            self.error(f"Number of child instances doesn't match in {first.scope_name}: {len(first.child_instances)} != {len(second.child_instances)}")
+            self.error(
+                f"Number of child instances doesn't match in {first.scope_name}: {len(first.child_instances)} != {len(second.child_instances)}"
+            )
 
         for instance_name, instance in first.child_instances.items():
             if instance_name not in second.child_instances:
@@ -2545,7 +2556,9 @@ class VlTest:
             self.error(f"Timescale doesn't match: {first.timescale} != {second.timescale}")
 
         if len(first.top_instances) != len(second.top_instances):
-            self.error(f"Number of top instances doesn't match: {len(first.top_instances)} != {len(second.top_instances)}")
+            self.error(
+                f"Number of top instances doesn't match: {len(first.top_instances)} != {len(second.top_instances)}"
+            )
 
         for top_instance_name, top_instance in first.top_instances.items():
             if top_instance_name not in second.top_instances:
diff --git a/test_regress/t/t_trace_dumpvars_dyn.cpp b/test_regress/t/t_trace_dumpvars_dyn.cpp
index b9f14a17f..650772044 100644
--- a/test_regress/t/t_trace_dumpvars_dyn.cpp
+++ b/test_regress/t/t_trace_dumpvars_dyn.cpp
@@ -39,9 +39,11 @@ int main(int argc, char** argv) {
 
     std::unique_ptr<TRACE_CLASS> tfp{new TRACE_CLASS};
 
-#if defined(T_TRACE_DUMPVARS_DYN_VCD_0) || defined(T_TRACE_DUMPVARS_DYN_FST_0) || defined(T_TRACE_DUMPVARS_DYN_SAIF_0)
+#if defined(T_TRACE_DUMPVARS_DYN_VCD_0) || defined(T_TRACE_DUMPVARS_DYN_FST_0) \
+    || defined(T_TRACE_DUMPVARS_DYN_SAIF_0)
     tfp->dumpvars(0, "");
-#elif defined(T_TRACE_DUMPVARS_DYN_VCD_1) || defined(T_TRACE_DUMPVARS_DYN_FST_1) || defined(T_TRACE_DUMPVARS_DYN_SAIF_1)
+#elif defined(T_TRACE_DUMPVARS_DYN_VCD_1) || defined(T_TRACE_DUMPVARS_DYN_FST_1) \
+    || defined(T_TRACE_DUMPVARS_DYN_SAIF_1)
     tfp->dumpvars(99, "t");  // This should not match "top."
     tfp->dumpvars(1, "top.t.cyc");  // A signal
     tfp->dumpvars(1, "top.t.sub1a");  // Scope
diff --git a/test_regress/t/t_trace_saif_sc_unsup.py b/test_regress/t/t_trace_saif_sc_unsup.py
index dc1c163e4..0d8a09a9f 100755
--- a/test_regress/t/t_trace_saif_sc_unsup.py
+++ b/test_regress/t/t_trace_saif_sc_unsup.py
@@ -16,6 +16,8 @@ test.top_filename = "t/t_trace_fst_sc.v"
 if not test.have_sc:
     test.skip("No SystemC installed")
 
-test.lint(fails=test.vlt_all, verilator_flags2=["--sc --trace-saif --lint-only"], expect_filename=test.golden_filename)
+test.lint(fails=test.vlt_all,
+          verilator_flags2=["--sc --trace-saif --lint-only"],
+          expect_filename=test.golden_filename)
 
-test.passes()
\ No newline at end of file
+test.passes()