diff --git a/include/verilated_saif_c.cpp b/include/verilated_saif_c.cpp
index c00d846c1..2c7eb8045 100644
--- a/include/verilated_saif_c.cpp
+++ b/include/verilated_saif_c.cpp
@@ -62,17 +62,17 @@
 //=============================================================================
 //=============================================================================
 //=============================================================================
-// ActivityVar
+// VerilatedSaifActivityVar
 
 VL_ATTR_ALWINLINE
-void ActivityVar::emitBit(uint64_t time, CData newval) {
+void VerilatedSaifActivityVar::emitBit(uint64_t time, CData newval) {
     assert(m_lastTime <= time);
     m_bits[0].aggregateVal(time - m_lastTime, newval);
     updateLastTime(time);
 }
 
 VL_ATTR_ALWINLINE
-void ActivityVar::emitWData(uint64_t time, const WData* newvalp, uint32_t bits) {
+void VerilatedSaifActivityVar::emitWData(uint64_t time, const WData* newvalp, uint32_t bits) {
     assert(m_lastTime <= time);
     uint64_t dt = time - m_lastTime;
     for (std::size_t i = 0; i < std::min(m_width, bits); ++i) {
@@ -83,7 +83,7 @@ void ActivityVar::emitWData(uint64_t time, const WData* newvalp, uint32_t bits)
     updateLastTime(time);
 }
 
-ActivityBit& ActivityVar::getBit(std::size_t index) {
+VerilatedSaifActivityBit& VerilatedSaifActivityVar::getBit(std::size_t index) {
     assert(index < m_width);
     return m_bits[index];
 }
@@ -256,7 +256,7 @@ void VerilatedSaif::finalizeSaifFileContents() {
 }
 
 void VerilatedSaif::recursivelyPrintScopes(uint32_t scopeIndex) {
-    const ActivityScope& scope = m_scopes.at(scopeIndex);
+    const VerilatedSaifActivityScope& scope = m_scopes.at(scopeIndex);
 
     openInstanceScope(scope.getName());
 
@@ -283,7 +283,7 @@ void VerilatedSaif::closeInstanceScope() {
     printStr(")\n");
 }
 
-void VerilatedSaif::printScopeActivities(const ActivityScope& scope) {
+void VerilatedSaif::printScopeActivities(const VerilatedSaifActivityScope& scope) {
     bool anyNetValid{false};
     for (auto& childSignal : scope.getChildActivities()) {
         uint32_t code = childSignal.first;
@@ -308,9 +308,9 @@ void VerilatedSaif::closeNetScope() {
 
 bool VerilatedSaif::printActivityStats(uint32_t activityCode, const char* activityName,
                                        bool anyNetValid) {
-    ActivityVar& activity = m_activity.at(activityCode);
+    VerilatedSaifActivityVar& activity = m_activity.at(activityCode);
     for (size_t i = 0; i < activity.getWidth(); i++) {
-        ActivityBit& bit = activity.getBit(i);
+        VerilatedSaifActivityBit& bit = activity.getBit(i);
 
         if (bit.getToggleCount() <= 0) {
             // Skip bits with no toggles
@@ -444,7 +444,7 @@ void VerilatedSaif::declare(uint32_t code, const char* name, const char* wirep,
     m_scopes.at(m_currentScope).addActivityVar(code, std::move(finalName));
 
     m_activity.emplace(
-        code, ActivityVar{static_cast<uint32_t>(bits), m_activityArena.back().data() + bitsIdx});
+        code, VerilatedSaifActivityVar{static_cast<uint32_t>(bits), m_activityArena.back().data() + bitsIdx});
 }
 
 void VerilatedSaif::declEvent(uint32_t code, uint32_t fidx, const char* name, int dtypenum,
@@ -504,42 +504,42 @@ void VerilatedSaifBuffer::emitEvent(uint32_t code) {
 VL_ATTR_ALWINLINE
 void VerilatedSaifBuffer::emitBit(uint32_t code, CData newval) {
     assert(m_owner.m_activity.count(code) && "Activity must be declared earlier");
-    ActivityVar& activity = m_owner.m_activity.at(code);
+    VerilatedSaifActivityVar& activity = m_owner.m_activity.at(code);
     activity.emitBit(m_owner.getCurrentTime(), newval);
 }
 
 VL_ATTR_ALWINLINE
 void VerilatedSaifBuffer::emitCData(uint32_t code, CData newval, int bits) {
     assert(m_owner.m_activity.count(code) && "Activity must be declared earlier");
-    ActivityVar& activity = m_owner.m_activity.at(code);
+    VerilatedSaifActivityVar& activity = m_owner.m_activity.at(code);
     activity.emitData<CData>(m_owner.getCurrentTime(), newval, bits);
 }
 
 VL_ATTR_ALWINLINE
 void VerilatedSaifBuffer::emitSData(uint32_t code, SData newval, int bits) {
     assert(m_owner.m_activity.count(code) && "Activity must be declared earlier");
-    ActivityVar& activity = m_owner.m_activity.at(code);
+    VerilatedSaifActivityVar& activity = m_owner.m_activity.at(code);
     activity.emitData<SData>(m_owner.getCurrentTime(), newval, bits);
 }
 
 VL_ATTR_ALWINLINE
 void VerilatedSaifBuffer::emitIData(uint32_t code, IData newval, int bits) {
     assert(m_owner.m_activity.count(code) && "Activity must be declared earlier");
-    ActivityVar& activity = m_owner.m_activity.at(code);
+    VerilatedSaifActivityVar& activity = m_owner.m_activity.at(code);
     activity.emitData<IData>(m_owner.getCurrentTime(), newval, bits);
 }
 
 VL_ATTR_ALWINLINE
 void VerilatedSaifBuffer::emitQData(uint32_t code, QData newval, int bits) {
     assert(m_owner.m_activity.count(code) && "Activity must be declared earlier");
-    ActivityVar& activity = m_owner.m_activity.at(code);
+    VerilatedSaifActivityVar& activity = m_owner.m_activity.at(code);
     activity.emitData<QData>(m_owner.getCurrentTime(), newval, bits);
 }
 
 VL_ATTR_ALWINLINE
 void VerilatedSaifBuffer::emitWData(uint32_t code, const WData* newvalp, int bits) {
     assert(m_owner.m_activity.count(code) && "Activity must be declared earlier");
-    ActivityVar& activity = m_owner.m_activity.at(code);
+    VerilatedSaifActivityVar& activity = m_owner.m_activity.at(code);
     activity.emitWData(m_owner.getCurrentTime(), newvalp, bits);
 }
 
diff --git a/include/verilated_saif_c.h b/include/verilated_saif_c.h
index 4521149d8..d56f230db 100644
--- a/include/verilated_saif_c.h
+++ b/include/verilated_saif_c.h
@@ -32,9 +32,9 @@ class VerilatedSaifBuffer;
 class VerilatedSaifFile;
 
 //=============================================================================
-// ActivityBit
+// VerilatedSaifActivityBit
 
-class ActivityBit final {
+class VerilatedSaifActivityBit final {
 public:
     // METHODS
     VL_ATTR_ALWINLINE
@@ -57,17 +57,17 @@ private:
 };
 
 //=============================================================================
-// ActivityVar
+// VerilatedSaifActivityVar
 
-class ActivityVar final {
+class VerilatedSaifActivityVar final {
 public:
     // CONSTRUCTORS
-    ActivityVar(uint32_t width, ActivityBit* bits)
+    VerilatedSaifActivityVar(uint32_t width, VerilatedSaifActivityBit* bits)
         : m_bits{bits}
         , m_width{width} {}
 
-    ActivityVar(ActivityVar&&) = default;
-    ActivityVar& operator=(ActivityVar&&) = default;
+    VerilatedSaifActivityVar(VerilatedSaifActivityVar&&) = default;
+    VerilatedSaifActivityVar& operator=(VerilatedSaifActivityVar&&) = default;
 
     // METHODS
     VL_ATTR_ALWINLINE void emitBit(uint64_t time, CData newval);
@@ -89,31 +89,31 @@ public:
 
     // ACCESSORS
     VL_ATTR_ALWINLINE uint32_t getWidth() const { return m_width; }
-    VL_ATTR_ALWINLINE ActivityBit& getBit(std::size_t index);
+    VL_ATTR_ALWINLINE VerilatedSaifActivityBit& getBit(std::size_t index);
     VL_ATTR_ALWINLINE uint64_t getLastUpdateTime() const { return m_lastTime; }
 
 private:
     // CONSTRUCTORS
-    VL_UNCOPYABLE(ActivityVar);
+    VL_UNCOPYABLE(VerilatedSaifActivityVar);
 
     // MEMBERS
     uint64_t m_lastTime{0};
-    ActivityBit* m_bits;
+    VerilatedSaifActivityBit* m_bits;
     uint32_t m_width;
 };
 
 //=============================================================================
-// ActivityScope
+// VerilatedSaifActivityScope
 
-class ActivityScope final {
+class VerilatedSaifActivityScope final {
 public:
     // CONSTRUCTORS
-    ActivityScope(std::string name, int32_t parentScopeIndex = -1)
+    VerilatedSaifActivityScope(std::string name, int32_t parentScopeIndex = -1)
         : m_scopeName{std::move(name)}
         , m_parentScopeIndex{parentScopeIndex} {}
 
-    ActivityScope(ActivityScope&&) = default;
-    ActivityScope& operator=(ActivityScope&&) = default;
+    VerilatedSaifActivityScope(VerilatedSaifActivityScope&&) = default;
+    VerilatedSaifActivityScope& operator=(VerilatedSaifActivityScope&&) = default;
 
     // METHODS
     VL_ATTR_ALWINLINE void addChildScopeIndex(int32_t index) {
@@ -137,7 +137,7 @@ public:
 
 private:
     // CONSTRUCTORS
-    VL_UNCOPYABLE(ActivityScope);
+    VL_UNCOPYABLE(VerilatedSaifActivityScope);
 
     // MEMBERS
     std::string m_scopeName{};
@@ -172,7 +172,7 @@ private:
     void recursivelyPrintScopes(uint32_t scopeIndex);
     void openInstanceScope(const std::string& instanceName);
     void closeInstanceScope();
-    void printScopeActivities(const ActivityScope& scope);
+    void printScopeActivities(const VerilatedSaifActivityScope& scope);
     void openNetScope();
     void closeNetScope();
     bool printActivityStats(uint32_t activityCode, const char* activityName, bool anyNetValid);
@@ -189,11 +189,11 @@ private:
     void clearCurrentlyCollectedData();
 
     int32_t m_currentScope{-1};
-    std::vector<ActivityScope> m_scopes{};
+    std::vector<VerilatedSaifActivityScope> m_scopes{};
     std::vector<int32_t> m_topScopes{};
 
-    std::unordered_map<uint32_t, ActivityVar> m_activity;
-    std::vector<std::vector<ActivityBit>> m_activityArena;
+    std::unordered_map<uint32_t, VerilatedSaifActivityVar> m_activity;
+    std::vector<std::vector<VerilatedSaifActivityBit>> m_activityArena;
 
     VL_ATTR_ALWINLINE uint64_t getCurrentTime() const { return m_totalTime - m_currentTimeOrigin; }