Commentary - update version date

Merge from master for release.
2026-10-07 02:23:19 +02:00 · 2024-02-25 07:20:30 -05:00 · 2024-02-24 07:48:43 -05:00 · 2024-01-01 03:45:16 -05:00 · 2023-10-31 19:51:59 -04:00 · 2023-09-16 21:44:39 -04:00
1097 changed files with 41473 additions and 62347 deletions
@@ -1,4 +1,4 @@
-Checks:          '*,-hicpp*,-android-cloexec-fopen,-cert-dcl50-cpp,-cert-env33-c,-cert-err34-c,-cert-err58-cpp,-clang-analyzer-core.UndefinedBinaryOperatorResult,-clang-analyzer-security*,-cppcoreguidelines-avoid-magic-numbers,-cppcoreguidelines-no-malloc,-cppcoreguidelines-owning-memory,-cppcoreguidelines-pro-bounds-array-to-pointer-decay,-cppcoreguidelines-pro-bounds-array-to-pointer-decay,-cppcoreguidelines-pro-bounds-constant-array-index,-cppcoreguidelines-pro-bounds-pointer-arithmetic,-cppcoreguidelines-pro-type-const-cast,-cppcoreguidelines-pro-type-reinterpret-cast,-cppcoreguidelines-pro-type-static-cast-downcast,-cppcoreguidelines-pro-type-union-access,-cppcoreguidelines-pro-type-vararg,-cppcoreguidelines-special-member-functions,-fuchsia-*,-google-default-arguments,-google-readability-todo,-google-runtime-references,-llvm-header-guard,-llvm-include-order,-misc-string-integer-assignment,-misc-string-literal-with-embedded-nul,-modernize-use-auto,-modernize-use-trailing-return-type,-readability-braces-around-statements,-readability-container-size-empty,-readability-delete-null-pointer,-readability-else-after-return,-readability-implicit-bool-conversion,-readability-named-parameter,-readability-static-accessed-through-instance,-llvmlibc-*,-altera-*'
+Checks:          '*,-hicpp*,-android-cloexec-fopen,-cert-dcl50-cpp,-cert-env33-c,-cert-err34-c,-cert-err58-cpp,-clang-analyzer-core.UndefinedBinaryOperatorResult,-clang-analyzer-security*,-cppcoreguidelines-avoid-magic-numbers,-cppcoreguidelines-no-malloc,-cppcoreguidelines-owning-memory,-cppcoreguidelines-pro-bounds-array-to-pointer-decay,-cppcoreguidelines-pro-bounds-array-to-pointer-decay,-cppcoreguidelines-pro-bounds-constant-array-index,-cppcoreguidelines-pro-bounds-pointer-arithmetic,-cppcoreguidelines-pro-type-const-cast,-cppcoreguidelines-pro-type-reinterpret-cast,-cppcoreguidelines-pro-type-static-cast-downcast,-cppcoreguidelines-pro-type-union-access,-cppcoreguidelines-pro-type-vararg,-cppcoreguidelines-special-member-functions,-fuchsia-*,-google-default-arguments,-google-readability-todo,-google-runtime-references,-llvm-header-guard,-llvm-include-order,-misc-string-integer-assignment,-misc-string-literal-with-embedded-nul,-modernize-use-auto,-modernize-use-trailing-return-type,-readability-braces-around-statements,-readability-container-size-empty,-readability-delete-null-pointer,-readability-else-after-return,-readability-implicit-bool-conversion,-readability-named-parameter,-readability-static-accessed-through-instance'
 WarningsAsErrors: ''
 HeaderFilterRegex: ''
 FormatStyle:     none
@@ -18,5 +18,3 @@ What 'verilator --version' are you using?  Did you try it with the git master ve
 What OS and distribution are you using?

 May we assist you in trying to fix this in Verilator yourself?
-
-(Please avoid attaching screenshots that show text - you can convert images to text using e.g. https://ocr.space)
@@ -11,8 +11,6 @@ Thanks for taking the time to report this.

 What would you like added/supported?

-What 'verilator --version' are you using?  Did you try it with the git master version?
-
 Can you attach an example that runs on other simulators?  (Must be openly licensed, ideally in test_regress format.)

 May we assist you in trying to fix this in Verilator yourself?
@@ -8,5 +8,3 @@ assignees: ''
 ---

 How may we help - what is your question?
-
-(If reporting a bug or requesting a feature please use one of the other issue templates.)
@@ -17,8 +17,6 @@ env:
  CCACHE_COMPRESS: 1
  CCACHE_DIR: ${{ github.workspace }}/.ccache
  CCACHE_LIMIT_MULTIPLE: 0.95
-  INSTALL_DIR: ${{ github.workspace }}/install
-  RELOC_DIR: ${{ github.workspace }}/relloc

 defaults:
  run:
@@ -96,32 +94,22 @@ jobs:
        compiler:
          - { cc: clang, cxx: clang++ }
          - { cc: gcc,   cxx: g++     }
-        reloc: [0]
-        suite: [dist-vlt-0, dist-vlt-1, dist-vlt-2, dist-vlt-3, vltmt-0, vltmt-1]
+        suite: [dist-vlt-0, dist-vlt-1, dist-vlt-2, vltmt-0, vltmt-1]
        include:
          # Test with GCC 10 on ubuntu-20.04
          - {os: ubuntu-20.04, compiler: { cc: gcc-10, cxx: g++-10 }, suite: dist-vlt-0}
          - {os: ubuntu-20.04, compiler: { cc: gcc-10, cxx: g++-10 }, suite: dist-vlt-1}
          - {os: ubuntu-20.04, compiler: { cc: gcc-10, cxx: g++-10 }, suite: dist-vlt-2}
-          - {os: ubuntu-20.04, compiler: { cc: gcc-10, cxx: g++-10 }, suite: dist-vlt-3}
          - {os: ubuntu-20.04, compiler: { cc: gcc-10, cxx: g++-10 }, suite: vltmt-0}
          - {os: ubuntu-20.04, compiler: { cc: gcc-10, cxx: g++-10 }, suite: vltmt-1}
-          # Test relocated installation - on most common platform only
-          - {os: ubuntu-22.04, compiler: { cc: gcc, cxx: g++ }, reloc: 1, suite: dist-vlt-0}
-          - {os: ubuntu-22.04, compiler: { cc: gcc, cxx: g++ }, reloc: 1, suite: dist-vlt-1}
-          - {os: ubuntu-22.04, compiler: { cc: gcc, cxx: g++ }, reloc: 1, suite: dist-vlt-2}
-          - {os: ubuntu-22.04, compiler: { cc: gcc, cxx: g++ }, reloc: 1, suite: dist-vlt-3}
-          - {os: ubuntu-22.04, compiler: { cc: gcc, cxx: g++ }, reloc: 1, suite: vltmt-0}
-          - {os: ubuntu-22.04, compiler: { cc: gcc, cxx: g++ }, reloc: 1, suite: vltmt-1}
    runs-on: ${{ matrix.os }}
-    name: Test | ${{ matrix.os }} | ${{ matrix.compiler.cc }} | ${{ matrix.reloc && 'reloc | ' || '' }} ${{ matrix.suite }}
+    name: Test | ${{ matrix.os }} | ${{ matrix.compiler.cc }} | ${{ matrix.suite }}
    env:
      CI_BUILD_STAGE_NAME: test
      CI_RUNS_ON: ${{ matrix.os }}
-      CI_RELOC: ${{ matrix.reloc }}
      CC: ${{ matrix.compiler.cc }}
      CXX: ${{ matrix.compiler.cxx }}
-      CACHE_BASE_KEY: test-${{ matrix.os }}-${{ matrix.compiler.cc }}-${{ matrix.reloc }}-${{ matrix.suite }}
+      CACHE_BASE_KEY: test-${{ matrix.os }}-${{ matrix.compiler.cc }}-${{ matrix.suite }}
      CCACHE_MAXSIZE: 100M # Per build per suite (* 5 * 5 = 2500M in total)
      VERILATOR_ARCHIVE: verilator-${{ github.sha }}-${{ matrix.os }}-${{ matrix.compiler.cc }}.tar.gz
    steps:
@@ -139,7 +127,7 @@ jobs:
    - name: Cache $CCACHE_DIR
      uses: actions/cache@v4
      env:
-        CACHE_KEY: ${{ env.CACHE_BASE_KEY }}-ccache2
+        CACHE_KEY: ${{ env.CACHE_BASE_KEY }}-ccache
      with:
        path: ${{ env.CCACHE_DIR }}
        key: ${{ env.CACHE_KEY }}-${{ github.sha }}
@@ -96,10 +96,3 @@ jobs:
      env:
        TESTS: coverage-${{ matrix.test }}${{ matrix.num }}
      run: ./ci/ci-script.bash
-
-    - name: Upload coverage data to Codecov
-      env:
-        CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
-      run: |
-        find . -name '*.gcno' -exec rm {} \;
-        ./ci/codecov -v upload-process -Z --sha ${{ github.sha }} -f nodist/obj_dir/coverage/app_total.info
@@ -44,8 +44,3 @@ verilator-config-version.cmake
 /.idea/
 /cmake-build-*/
 /test_regress/snapshot/
-xmverilog.*
-xrun.history
-
-# Normal CMake build directory
-/build
@@ -1,27 +0,0 @@
-# See https://citation-file-format.github.io/
-cff-version: 1.2.0
-title: Verilator
-message: >-
-  If you use this software, please cite it using the
-  metadata from this file.
-type: software
-authors:
-  - given-names: Wilson
-    family-names: Snyder
-    email: [email protected]
-    affiliation: Veripool
-  - given-names: Paul
-    family-names: Wasson
-  - given-names: Duane
-    family-names: Galbi
-  - name: 'et al'
-repository-code: 'https://github.com/verilator/verilator'
-url: 'https://verilator.org'
-abstract: >-
-  The Verilator package converts Verilog and SystemVerilog hardware
-  description language (HDL) designs into a fast C++ or SystemC model
-  that, after compiling, can be executed.  Verilator is not a
-  traditional simulator but a compiler.
-license:
-  - LGPL-3.0-only
-  - Artistic-2.0
@@ -15,7 +15,7 @@
 cmake_minimum_required(VERSION 3.15)
 cmake_policy(SET CMP0091 NEW) # Use MSVC_RUNTIME_LIBRARY to select the runtime
 project(Verilator
-    VERSION 5.028
+    VERSION 5.022
    HOMEPAGE_URL https://verilator.org
    LANGUAGES CXX
 )
@@ -24,13 +24,12 @@ option(DEBUG_AND_RELEASE_AND_COVERAGE
    "Builds both the debug and release binaries, overriding CMAKE_BUILD_TYPE. Not supported under MSBuild.")

 find_package(Python3 COMPONENTS Interpreter)
-set(PYTHON3 ${Python3_EXECUTABLE})
+set(PYTHON3 Python3::Interpreter)
 set(CMAKE_INSTALL_DATADIR ${CMAKE_INSTALL_PREFIX})
 include(GNUInstallDirs)
 include(CMakePackageConfigHelpers)
 include(CheckStructHasMember)
 include(ExternalProject)
-include(FindThreads)

 if (NOT WIN32)
    message(WARNING "CMake support on Linux/OSX is experimental.")
@@ -96,14 +95,10 @@ endif()

 set(PACKAGE_NAME ${PROJECT_NAME})
 set(PACKAGE_VERSION ${PROJECT_VERSION})
-set(CXX ${CMAKE_CXX_COMPILER})
-set(AR ${CMAKE_AR})

 configure_file(include/verilated_config.h.in include/verilated_config.h @ONLY)
-configure_file(include/verilated.mk.in include/verilated.mk @ONLY)

 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/include/verilated_config.h DESTINATION ${CMAKE_INSTALL_PREFIX}/include)
-install(FILES ${CMAKE_CURRENT_BINARY_DIR}/include/verilated.mk DESTINATION ${CMAKE_INSTALL_PREFIX}/include)

 configure_package_config_file(verilator-config.cmake.in verilator-config.cmake
    INSTALL_DESTINATION ${CMAKE_INSTALL_PREFIX}
@@ -123,7 +118,6 @@ foreach (program
    verilator_ccache_report
    verilator_difftree
    verilator_profcfunc
-    verilator_includer
 )
    install(PROGRAMS bin/${program} TYPE BIN)
 endforeach()
@@ -136,6 +130,7 @@ install(DIRECTORY examples TYPE DATA FILES_MATCHING

 install(DIRECTORY include TYPE DATA FILES_MATCHING
    PATTERN "include/verilated_config.h"
+    PATTERN "include/verilated.mk"
    PATTERN "include/*.[chv]"
    PATTERN "include/*.cpp"
    PATTERN "include/*.sv"
@@ -8,211 +8,6 @@ The changes in each Verilator version are described below.  The
 contributors that suggested a given feature are shown in []. Thanks!


-Verilator 5.028 2024-08-21
-==========================
-
-**Minor:**
-
-* Support state-dependent constraints (#5217). [Arkadiusz Kozdra, Antmicro Ltd.]
-* Support cross-module clocking variable access (#5184). [Arkadiusz Kozdra, Antmicro Ltd.]
-* Support inline constraints for class randomization methods (#5234). [Krzysztof Boroński]
-* Support clocking blocks in virtual interfaces (#5235). [Arkadiusz Kozdra, Antmicro Ltd.]
-* Support `$assertcontrol` assertion_type (#5236). [Bartłomiej Chmiel, Antmicro Ltd.]
-* Support conditional constraints (#5245). [Arkadiusz Kozdra, Antmicro Ltd.]
-* Support`--compiler-include` headers in user-supplied cpp files  (#5271). [Bartłomiej Chmiel, Antmicro Ltd.]
-* Support `rand_mode` (#5273). [Krzysztof Bieganski, Antmicro Ltd.]
-* Support `this.randomize with` (#5282). [Arkadiusz Kozdra, Antmicro Ltd.]
-* Support foreach constraints (#5302). [Arkadiusz Kozdra, Antmicro Ltd.]
-* Support `parameter type` in hierarchical blocks (#5309) (#5333). [Bartłomiej Chmiel, Antmicro Ltd.]
-* Support assertcontrol directive type  (#5310). [Bartłomiej Chmiel, Antmicro Ltd.]
-* Support inline random variable control (#5317). [Krzysztof Bieganski, Antmicro Ltd.]
-* Support streaming operator on arrays and wide data (#5326). [Arkadiusz Kozdra, Antmicro Ltd.]
-* Support streams to/from arrays of wide data (#5334). [Arkadiusz Kozdra, Antmicro Ltd.]
-* Support `constraint_mode` (#5338). [Krzysztof Bieganski, Antmicro Ltd.]
-* Support constraining AstSel (#5344). [Arkadiusz Kozdra, Antmicro Ltd.]
-* Support default value on module input (#5358) (#5373). [Drew Ranck]
-* Add `--compiler-include` for additional C++ includes (#5139) (#5202). [Bartłomiej Chmiel, Antmicro Ltd.]
-* Add `--emit-accessors` (#5182) (#5227). [Ryan Ziegler]
-* Add suggestions on misspelled PLI functions.
-* Add warning on dist in constraints (#5264). [Arkadiusz Kozdra, Antmicro Ltd.]
-* Add more `rand_mode` unsupported errors (#5329). [Krzysztof Bieganski, Antmicro Ltd.]
-* Add parsing but otherwise ignore std::randomize (#5354). [Arkadiusz Kozdra, Antmicro Ltd.]
-* Add Verilated cc define when `--timing` used (#5383). [Kaleb Barrett]
-* Improve emitted code to use a reference for VlSelf (#5254). [Yangyu Chen]
-* Fix monitor block sensitivity items (#4400) (#5294). [Udaya Raj Subedi]
-* Fix fusing macro arguments to not ignore whitespace (#5061). [Tudor Timi]
-* Fix optimized-out sensitivity trees with `--timing` (#5080) (#5349). [Krzysztof Bieganski, Antmicro Ltd.]
-* Fix classes/modules of case-similar names (#5109). [Arkadiusz Kozdra]
-* Fix mis-removing $value$plusargs calls (#5127) (#5137). [Seth Pellegrino]
-* Fix incorrect result of width mismatch (#5186) (#5189). [Yutetsu TAKATSUKASA]
-* Fix compiler coroutine check (#5190) (#5300). [Ricardo Barbedo]
-* Fix shortened module names when searching for files (#5196) (#5246). [Tim Hutt]
-* Fix `--x-assign` to be independent from `+verilator+rand+reset` (#5214). [Andrew Nolte]
-* Fix splitting if statements with impure conditions (#5219). [Bartłomiej Chmiel, Antmicro Ltd.]
-* Fix unknown conversion on queues (#5220). [Alex Solomatnikov]
-* Fix top-level unpacked structure resets (#5221).
-* Fix concurrency for mailbox and semaphores (#5222). [Liam Braun]
-* Fix forks capturing non-input ports in tasks (#5237) (#5343). [Krzysztof Bieganski, Antmicro Ltd.]
-* Fix toggle coverage aggregation on same line (#5248). [Krzysztof Obłonczek]
-* Fix error on empty generate with -O0 (#5250).
-* Fix unconstrained randomization of unpacked structs (#5252). [Krzysztof Bieganski, Antmicro Ltd.]
-* Fix inlining of variables driven from forced vars (#5259). [Geza Lore]
-* Fix tracing with `--main-top-name -` (#5261). [Ethan Sifferman]
-* Fix randomization when used with inheritance (#5268). [Krzysztof Bieganski, Antmicro Ltd.]
-* Fix inline constraints creating class random generator (#5280). [Krzysztof Bieganski, Antmicro Ltd.]
-* Fix WIDTHEXPAND on left shift of intuitive amount (#5284). [Greg Taylor]
-* Fix elaborating foreach loops (#5285). [Arkadiusz Kozdra, Antmicro Ltd.]
-* Fix initializing static array in dynamic arrays and queues (#5287). [Baruch Sterin]
-* Fix static variable initializers in procedures (#5296). [Bartłomiej Chmiel, Antmicro Ltd.]
-* Fix randomizing current object with `rand` class instance member (#5292). [Krzysztof Bieganski, Antmicro Ltd.]
-* Fix handling of rand fields not referenced in constraints (#5305). [Ryszard Rozak, Antmicro Ltd.]
-* Fix Python3 path discovery in make flows to avoid mixing system and user python interpreters (#5307) [Markus Krause]
-* Fix make flows to pass PYTHON3 (like PERL) (#5307) (#5308). [Markus Krause]
-* Fix assert on wide expression (#5319) (#5324). [Varun Koyyalagunta]
-* Fix output clock variable overwriting signal (#5320)  (#5347). [Krzysztof Bieganski, Antmicro Ltd.]
-* Fix stringify in nested preprocessor macros (#5323). [Krzysztof Bieganski, Antmicro Ltd.]
-* Fix $sformat with array arguments (#5330). [Abe Jordan]
-* Fix -Wunused-but-set-variable clang warning (#5331). [Bartłomiej Chmiel, Antmicro Ltd.]
-* Fix purity of functions with AstJumpBlock or AstStmtExpr (#5332). [Ryszard Rozak, Antmicro Ltd.]
-* Fix compilation error on unreachable disable fork / wait fork (#5339). [Arkadiusz Kozdra, Antmicro Ltd.]
-* Fix missing type coercion in 'inside {array}' (#5340). [Arkadiusz Kozdra, Antmicro Ltd.]
-* Fix +: and -: unpacked array slicing when array has nonzero low index (#5345) (#5387). [James Bailey]
-* Fix tracing_{on,off} in the presence of non-inlined modules (#5346). [Geza Lore]
-* Fix NBAs in suspendables (#5348). [Krzysztof Bieganski, Antmicro Ltd.]
-* Fix lint_off on Errors (#5351) (#5363). [Ethan Sifferman]
-* Fix cache config file resolution performance (#5369). [Geza Lore]
-* Fix capturing fields from superclass in `randomize() with` (#5389). [Krzysztof Bieganski, Antmicro Ltd.]
-* Fix virtual interface null checks (#5391). [Krzysztof Bieganski, Antmicro Ltd.]
-* Fix ==? and !=? with X values.
-* Fix CPU time being zero.
-* Fix inline function ref port persistence.
-
-
-Verilator 5.026 2024-06-15
-==========================
-
-**Major:**
-
-* Support constrained randomization with external solvers (#4947). [Arkadiusz Kozdra, Antmicro Ltd.]
-
-**Minor:**
-
-* Support `$psprintf` system function (#4314) (#5169). [Arkadiusz Kozdra, Antmicro Ltd.]
-* Support 2D dynamic array initialization (#4700) (#5122). [Valentin Atepalikhin]
-* Support __en/__out signals on top level inout ports (#4812) (#4856). [Paul Wright]
-* Support empty queue as dynarray default value (#5055). [Arkadiusz Kozdra, Antmicro Ltd.]
-* Support vpiInertialDelay (#5087). [Todd Strader]
-* Support NBAs to arrays inside loops (#5092). [Geza Lore]
-* Support parsing and otherwise ignoring inline constraints (#5126). [Arkadiusz Kozdra, Antmicro Ltd.]
-* Support `inout` clocking items (#5160). [Arkadiusz Kozdra, Antmicro Ltd.]
-* Support StructSel in unpacked array assignments (#5176). [Geza Lore]
-* Add error on zero width select (#5028).
-* Add CITATION.cff (#5057) (#5058). [Gijs Burghoorn]
-* Add VPI eval needed tracking (#5065). [Todd Strader]
-* Add `--localize-max-size` option and optimization (#5072).
-* Add parameterless assert control system tasks (#5010). [Bartłomiej Chmiel]
-* Add traceCapable indication to model header (#5053). [Vito Gamberini]
-* Add increasing of stack size when possible (#5071) (#5104). [Yinan Xu]
-* Add assertion on reusing VerilatedContext (#5167).
-* Add `--pins-sc-uint-bool` to force SystemC uint type (#5192). [Bartłomiej Chmiel, Antmicro Ltd.]
-* Improve DFG regularization in cyclic graphs (#5142). [Geza Lore]
-* Improve VerilatedVpiPutHolder storage requirements (#5144). [Kaleb Barrett]
-* Fix coroutines without awaits to have a co_return (#4208) (#5175). [Arkadiusz Kozdra, Antmicro Ltd.]
-* Fix missing flex include path variable (#4970) (#4971). [Christopher Taylor]
-* Fix missing parameters with comma to be errors (#4979) (#5012). [Paul Swirhun]
-* Fix 'experimental/coroutine' file not found on MacOS (#5030) (#5031) (#5151). [Paul Bowen-Huggett]
-* Fix bound queue printing (#5032). [Aleksander Kiryk, Antmicro Ltd.]
-* Fix consecutive zero-delays (#5038). [Krzysztof Bieganski, Antmicro Ltd.]
-* Fix attempted to destroy locked thread pool error (#5040). [Bartłomiej Chmiel, Antmicro Ltd.]
-* Fix `$system` with string argument (#5042).
-* Fix width extension on delays (#5043).
-* Fix `$typename` on array.min and others (#5049). [Gökçe Aydos]
-* Fix `make $(info)` which cannot be silenced (#5059). [Gökçe Aydos]
-* Fix CMake builds to export VERILATOR_ROOT (#5063). [Michael Bikovitsky]
-* Fix false ASSIGNIN on functions with explicit port map (#5069).
-* Fix 4-state value support for $readmem (#5070) (#5078). [Ethan Sifferman]
-* Fix DFG assertion with SystemC (#5076). [Geza Lore]
-* Fix `$typename` string to be more standard (#5082) (#5083). [Andrew Nolte]
-* Fix missed optimization in V3Delayed (#5089). [Geza Lore]
-* Fix macro expansion in strings per 1800-2023 (#5094). [Geza Lore]
-* Fix width extension of unpacked array select (#5095). [Varun Koyyalagunta]
-* Fix MacOS missing <type_traits> header (#5096) (#5097). [Vito Gamberini]
-* Fix assertion failure in V3Gate (#5101). [Yutetsu TAKATSUKASA]
-* Fix aliases for forced port signals (#5105). [Geza Lore]
-* Fix tracing interface functions (#5108). [Alex Solomatnikov]
-* Fix method calls parsing in constraints (#5110). [Arkadiusz Kozdra, Antmicro Ltd.]
-* Fix vpiInertialDelay for memories (#5113). [Todd Strader]
-* Fix hierarchical compilation with nested -F (#5114) (#5124). [Alex Solomatnikov]
-* Fix references to ports in forks (#5123). [Krzysztof Bieganski, Antmicro Ltd.]
-* Fix output C++ type error on change detect of I/O arrays (#5125) (#5131). [Pawel Jewstafjew]
-* Fix x-valued parameters with `--x-assign unique` (#5129). [Ethan Sifferman]
-* Fix overflow of string on VPI reads (#5145) (#5146). [Kaleb Barrett]
-* Fix VerilatedVpiPutHolder class (#5156). [Kaleb Barrett]
-* Fix extending out-of-range select (#5159) (#5164). [Geza Lore]
-* Fix radix in width warnings (#5166). [Geza Lore]
-* Fix SystemC BITS_PER_DIGIT in VL_ASSIGN_SBW (#5170). [Bartłomiej Chmiel, Antmicro Ltd.]
-* Fix non-constant replication in concats (#5171). [Arkadiusz Kozdra, Antmicro Ltd.]
-* Fix table optimization when applied on real data type (#5172) (#5173). [Arthur Rosa]
-* Fix signed types emitted in hierarchical Verilation (#5178). [Bartłomiej Chmiel, Antmicro Ltd.]
-* Fix DPI import of null C-string (#5179).
-* Fix CMake installation missing verilated.mk (#5187) (#5188). [Philip Axer]
-* Fix linking with pthreads on CMake (#5194). [Tim Hutt]
-* Fix clang-17 coroutines configuration with -std=gnu++20 (#5200). [Gus Smith]
-
-
-Verilator 5.024 2024-04-05
-==========================
-
-**Major:**
-
-* Add printing summary reports, use `--quiet` or `+verilator+quiet` to suppress (#4909).
-* Support 1800-2023 keywords, and parsing with UNDEFINED warnings.
-* Support 1800-2023 preprocessor ifdef expressions.
-
-**Minor:**
-
-* Change 1800-2023 to be default language version.
-* Add DFG 'regularize' pass, and improve variable removal (#4937). [Geza Lore]
-* Add error when pass net to function argument (#4132) (#4966). [Fuad Ismail]
-* Add `UNUSEDLOOP` when unused loop is removed (#4926). [Bartłomiej Chmiel, Antmicro Ltd.]
-* Add custom version for verilator --version packaging (#4954). [Nolan Poe]
-* Add error on missing pure virtual functions (#4961).
-* Add error on calling static function without object (#4962).
-* Add JSON AST dumps (#5020). [Szymon Gizler]
-* Support 1800-2023 DPI headers, svGetTime/svgGetTimeUnit/svGetTimePrecision methods.
-* Support 1800-2023 class and function :initial, :extends, :final virtual overrides (#5025).
-* Support public packed struct / union (#860) (#4878). [Kefa Chen]
-* Support stream operation on unpacked array (#4714) (#5006). [Fuad Ismail]
-* Support implicitly-typed variable definitions in for-loop initializers (#4945) (#4986). [Kevin Nygaard]
-* Support inside range with implicit type conversion (#5026). [Arkadiusz Kozdra, Antmicro Ltd.]
-* Improve installation to be relocatable (#4927). [Geza Lore]
-* Improve internal ordering code (#4957) (#4990) (#4994) et al. [Geza Lore]
-* Fix generate blocks in vpi_iterate (#3609) (#4913). [Andrew Nolte]
-* Fix __Vlip undefined error in --freloop (#4824). [Justin Yao Du]
-* Fix missing VPI scopes (#4918). [Andrew Nolte]
-* Fix invalid cast on string structure creation (#4921).
-* Fix try-lock spuriously fails (#4931) (#4938). [Kamil Rakoczy]
-* Fix V3Unknown unpacked struct x-assign (#4934). [Yan Xu]
-* Fix DFG removing forceable signals (#4942). [Geza Lore]
-* Fix null characters in shortened identifiers (#4946). [Abdul Hameed]
-* Fix assignment of null into struct member (#4952).
-* Fix VPI missing scopes 2 (#4965). [Andrew Nolte]
-* Fix object assignment from conditionals (#4968).
-* Fix GCC14 warnings on template specialization syntax (#4974) (#4975). [Nolan Poe]
-* Fix unpacked structure upper bit cleaning (#4978).
-* Fix tests on MacOS (#4984) (#4985). [Kevin Nygaard]
-* Fix `--prof-exec` predicted time values (#4988). [Geza Lore]
-* Fix class type as an associative array parameter (#4997).
-* Fix inout ports of unpacked struct type (#5000). [Ryszard Rozak, Antmicro Ltd.]
-* Fix `unique {}` constraints missing semicolon (#5001).
-* Fix preprocessor to respect strings in joins (#5007).
-* Fix tracing class parameters (#5014).
-* Fix memory leaks (#5016). [Geza Lore]
-* Fix $readmem with missing newline (#5019). [Josse Van Delm]
-* Fix internal error on missing pattern key (#5023).
-* Fix tracing replicated hierarchical models (#5027).
-
-
 Verilator 5.022 2024-02-24
 ==========================

@@ -332,7 +127,6 @@ Verilator 5.020 2024-01-01
 * Fix dynamic NBA conditions (#4773). [Krzysztof Bieganski, Antmicro Ltd.]
 * Fix `V3Fork` stage to run only if `--timing` is set (#4778). [Krzysztof Bieganski, Antmicro Ltd.]
 * Fix max multiply width and add runtime assertions if too small. (#4781)
-* Fix select value too wide (#5148) (#5153). [Dercury]


 Verilator 5.018 2023-10-30
@@ -705,7 +499,7 @@ Verilator 5.006 2023-01-22
 **Minor:**

 * Support clocking blocks (#3674). [Krzysztof Bieganski, Antmicro Ltd]
-* Support unpacked structs (#3802). [Aleksander Kiryk, Antmicro Ltd]
+* Support packed structs (#3802). [Aleksander Kiryk, Antmicro Ltd]
 * Support Windows-native builds using cmake (#3814). [Kritik Bhimani]
 * Support p format for UnpackArray (#3877). [Aleksander Kiryk, Antmicro Ltd]
 * Support property calls without parenthesis (#3879) (#3893). [Ryszard Rozak, Antmicro Ltd]
@@ -1596,7 +1390,6 @@ Verilator 4.026 2020-01-11
 * Fix expand optimization slowing --lint-only. Closes #2091. [Thomas Watts]
 * Fix %{number}s with strings. #2093. [agrobman]
 * Fix shebang breaking some shells. Closes #2067. [zdave]
-* Fix errors on using string in incorrect format (#5240). [John Demme]


 Verilator 4.024 2019-12-08
@@ -91,7 +91,6 @@ datarootdir = @datarootdir@
 CFG_WITH_CCWARN = @CFG_WITH_CCWARN@
 CFG_WITH_DEFENV = @CFG_WITH_DEFENV@
 CFG_WITH_LONGTESTS = @CFG_WITH_LONGTESTS@
-CFG_WITH_SOLVER = @CFG_WITH_SOLVER@
 PACKAGE_VERSION = @PACKAGE_VERSION@

 #### End of system configuration section. ####
@@ -204,21 +203,11 @@ verilator.html:
 verilator.pdf: Makefile
 	$(MAKE) -C docs verilator.pdf

-# Public executables intended to be invoked directly by the user
-# Don't put wildcards in these variables, it might cause an uninstall of other stuff
-VL_INST_PUBLIC_SCRIPT_FILES = verilator \
-                              verilator_coverage \
-                              verilator_gantt \
-                              verilator_profcfunc \
-
-VL_INST_PUBLIC_BIN_FILES = verilator_bin$(EXEEXT) \
-                           verilator_bin_dbg$(EXEEXT) \
-                           verilator_coverage_bin_dbg$(EXEEXT) \
-
-# Private executabels intended to be invoked by internals
-# Don't put wildcards in these variables, it might cause an uninstall of other stuff
-VL_INST_PRIVATE_SCRIPT_FILES = verilator_ccache_report \
-                               verilator_includer \
+# See uninstall also - don't put wildcards in this variable, it might uninstall other stuff
+VL_INST_BIN_FILES = verilator verilator_bin$(EXEEXT) verilator_bin_dbg$(EXEEXT) verilator_coverage_bin_dbg$(EXEEXT) \
+	verilator_ccache_report verilator_coverage verilator_difftree verilator_gantt verilator_includer verilator_profcfunc
+# Some scripts go into both the search path and pkgdatadir,
+# so they can be found by the user, and under $VERILATOR_ROOT.

 VL_INST_INC_BLDDIR_FILES = \
 	include/verilated_config.h \
@@ -237,34 +226,19 @@ VL_INST_DATA_SRCDIR_FILES = \
 	examples/*/Makefile* \
 	examples/*/vl_* \

-mkbindirs:
-	$(MKINSTALLDIRS) $(DESTDIR)$(pkgdatadir)/bin
+installbin:
 	$(MKINSTALLDIRS) $(DESTDIR)$(bindir)
-
-installbin: | mkbindirs
-	cd $(srcdir)/bin; \
-	for p in $(VL_INST_PUBLIC_SCRIPT_FILES) ; do \
-	  $(INSTALL_PROGRAM) $$p $(DESTDIR)$(pkgdatadir)/bin/$$p; \
-	done
-	cd bin; \
-	for p in $(VL_INST_PUBLIC_BIN_FILES) ; do \
-	  $(INSTALL_PROGRAM) $$p $(DESTDIR)$(pkgdatadir)/bin/$$p; \
-	done
-	cd $(srcdir)/bin; \
-	for p in $(VL_INST_PRIVATE_SCRIPT_FILES) ; do \
-	  $(INSTALL_PROGRAM) $$p $(DESTDIR)$(pkgdatadir)/bin/$$p; \
-	done
-
-installredirect: installbin | mkbindirs
-	cp ${srcdir}/bin/redirect ${srcdir}/bin/redirect.tmp
-	perl -p -i -e 'use File::Spec;' \
-	           -e' $$path = File::Spec->abs2rel("$(realpath $(DESTDIR)$(pkgdatadir)/bin)", "$(realpath $(DESTDIR)$(bindir))");' \
-	           -e 's/RELPATH.*/"$$path";/g' -- "${srcdir}/bin/redirect.tmp"
-	cd $(srcdir)/bin; \
-	for p in $(VL_INST_PUBLIC_SCRIPT_FILES) $(VL_INST_PUBLIC_BIN_FILES) ; do \
-	  $(INSTALL_PROGRAM) redirect.tmp $(DESTDIR)$(bindir)/$$p; \
-	done
-	rm ${srcdir}/bin/redirect.tmp
+	( cd ${srcdir}/bin ; $(INSTALL_PROGRAM) verilator $(DESTDIR)$(bindir)/verilator )
+	( cd ${srcdir}/bin ; $(INSTALL_PROGRAM) verilator_coverage $(DESTDIR)$(bindir)/verilator_coverage )
+	( cd ${srcdir}/bin ; $(INSTALL_PROGRAM) verilator_gantt $(DESTDIR)$(bindir)/verilator_gantt )
+	( cd ${srcdir}/bin ; $(INSTALL_PROGRAM) verilator_profcfunc $(DESTDIR)$(bindir)/verilator_profcfunc )
+	( cd bin ; $(INSTALL_PROGRAM) verilator_bin$(EXEEXT) $(DESTDIR)$(bindir)/verilator_bin$(EXEEXT) )
+	( cd bin ; $(INSTALL_PROGRAM) verilator_bin_dbg$(EXEEXT) $(DESTDIR)$(bindir)/verilator_bin_dbg$(EXEEXT) )
+	( cd bin ; $(INSTALL_PROGRAM) verilator_coverage_bin_dbg$(EXEEXT) $(DESTDIR)$(bindir)/verilator_coverage_bin_dbg$(EXEEXT) )
+	$(MKINSTALLDIRS) $(DESTDIR)$(pkgdatadir)/bin
+	( cd ${srcdir}/bin ; $(INSTALL_PROGRAM) verilator_includer $(DESTDIR)$(pkgdatadir)/bin/verilator_includer )
+	( cd ${srcdir}/bin ; $(INSTALL_PROGRAM) verilator_ccache_report $(DESTDIR)$(pkgdatadir)/bin/verilator_ccache_report )
+	( cd ${srcdir}/bin ; $(INSTALL_PROGRAM) verilator_difftree $(DESTDIR)$(pkgdatadir)/bin/verilator_difftree )

 # Man files can either be part of the original kit, or built in current directory
 # So important we use $^ so VPATH is searched
@@ -307,11 +281,8 @@ installdata:

 # We don't trust rm -rf, so rmdir instead as it will fail if user put in other files
 uninstall:
-	-cd $(DESTDIR)$(bindir) && rm -f $(VL_INST_PUBLIC_SCRIPT_FILES)
-	-cd $(DESTDIR)$(bindir) && rm -f $(VL_INST_PUBLIC_BIN_FILES)
-	-cd $(DESTDIR)$(pkgdatadir)/bin && rm -f $(VL_INST_PUBLIC_SCRIPT_FILES)
-	-cd $(DESTDIR)$(pkgdatadir)/bin && rm -f $(VL_INST_PUBLIC_BIN_FILES)
-	-cd $(DESTDIR)$(pkgdatadir)/bin && rm -f $(VL_INST_PRIVATE_SCRIPT_FILES)
+	-cd $(DESTDIR)$(bindir) && rm -f $(VL_INST_BIN_FILES)
+	-cd $(DESTDIR)$(pkgdatadir)/bin && rm -f $(VL_INST_BIN_FILES)
 	-cd $(DESTDIR)$(mandir)/man1 && rm -f $(VL_INST_MAN_FILES)
 	-cd $(DESTDIR)$(pkgdatadir) && rm -f $(VL_INST_INC_BLDDIR_FILES)
 	-cd $(DESTDIR)$(pkgdatadir) && rm -f $(VL_INST_INC_SRCDIR_FILES)
@@ -340,7 +311,7 @@ uninstall:
 	-rmdir $(DESTDIR)$(pkgconfigdir)

 install: all_nomsg install-all
-install-all: installbin installredirect installman installdata install-msg
+install-all: installbin installman installdata install-msg

 install-here: installman info

@@ -439,7 +410,6 @@ PY_PROGRAMS = \
 	src/cppcheck_filtered \
 	src/flexfix \
 	src/vlcovgen \
-	src/.gdbinit.py \
 	test_regress/t/*.pf \
 	nodist/clang_check_attributes \
 	nodist/code_coverage \
@@ -447,7 +417,6 @@ PY_PROGRAMS = \
 	nodist/fuzzer/actual_fail \
 	nodist/fuzzer/generate_dictionary \
 	nodist/install_test \
-	nodist/log_changes \

 PY_FILES = \
 	$(PY_PROGRAMS) \
@@ -1,23 +1,21 @@
 .. Github doesn't render images unless absolute URL
 .. Do not know of a conditional tag, "only: github" nor "github display" works

-|badge1| |badge2| |badge3| |badge4| |badge5| |badge6| |badge7| |badge8|
-
-.. |badge1| image:: https://img.shields.io/badge/Website-Verilator.org-181717.svg
+.. image:: https://img.shields.io/badge/Website-Verilator.org-181717.svg
    :target: https://verilator.org
-.. |badge2| image:: https://img.shields.io/badge/License-LGPL%20v3-blue.svg
+.. image:: https://img.shields.io/badge/License-LGPL%20v3-blue.svg
    :target: https://www.gnu.org/licenses/lgpl-3.0
-.. |badge3| image:: https://img.shields.io/badge/License-Artistic%202.0-0298c3.svg
+.. image:: https://img.shields.io/badge/License-Artistic%202.0-0298c3.svg
    :target: https://opensource.org/licenses/Artistic-2.0
-.. |badge4| image:: https://repology.org/badge/tiny-repos/verilator.svg?header=distro%20packages
+.. image:: https://repology.org/badge/tiny-repos/verilator.svg?header=distro%20packages
    :target: https://repology.org/project/verilator/versions
-.. |badge5| image:: https://img.shields.io/docker/pulls/verilator/verilator
+.. image:: https://img.shields.io/docker/pulls/verilator/verilator
    :target: https://hub.docker.com/r/verilator/verilator
-.. |badge6| image:: https://api.codacy.com/project/badge/Grade/fa78caa433c84a4ab9049c43e9debc6f
+.. image:: https://api.codacy.com/project/badge/Grade/fa78caa433c84a4ab9049c43e9debc6f
    :target: https://www.codacy.com/gh/verilator/verilator
-.. |badge7| image:: https://codecov.io/gh/verilator/verilator/branch/master/graph/badge.svg
+.. image:: https://codecov.io/gh/verilator/verilator/branch/master/graph/badge.svg
    :target: https://codecov.io/gh/verilator/verilator
-.. |badge8| image:: https://github.com/verilator/verilator/workflows/build/badge.svg
+.. image:: https://github.com/verilator/verilator/workflows/build/badge.svg
    :target: https://github.com/verilator/verilator/actions?query=workflow%3Abuild


@@ -87,11 +85,12 @@ thread is about 100 times faster than interpreted Verilog simulators such
 as `Icarus Verilog`_. Another 2-10x speedup might be gained from
 multithreading (yielding 200-1000x total over interpreted simulators).

-Verilator has typically similar or better performance versus closed-source
-Verilog simulators (e.g., Aldec Riviera-Pro, Cadence Incisive/NC-Verilog,
-Mentor ModelSim/Questa, Synopsys VCS, VTOC, and Pragmatic CVer/CVC). But,
-Verilator is open-sourced, so you can spend on computes rather than
-licenses. Thus, Verilator gives you the best simulation cycles/dollar.
+Verilator has typically similar or better performance versus
+closed-source Verilog simulators (e.g., Carbon Design Systems Carbonator,
+Modelsim/Questa, Cadence Incisive/NC-Verilog, Synopsys VCS, VTOC, and
+Pragmatic CVer/CVC). But, Verilator is open-sourced, so you can spend on
+computes rather than licenses. Thus, Verilator gives you the best
+simulation cycles/dollar.


 Installation & Documentation
@@ -1,22 +0,0 @@
-#!/usr/bin/env perl
-######################################################################
-#
-# Copyright 2003-2024 by Wilson Snyder. This program is free software; you
-# can redistribute it and/or modify it under the terms of either the GNU
-# Lesser General Public License Version 3 or the Perl Artistic License
-# Version 2.0.
-# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
-#
-######################################################################
-
-require 5.006_001;
-use warnings;
-use FindBin qw($RealBin $RealScript);
-use strict;
-
-my $relpath = RELPATH;  # Substituted during Verilator 'make install'
-
-unshift @ARGV, $RealScript;
-
-exec { "$RealBin/$relpath/$RealScript" } @ARGV;
-die "%Error: Exec failed,";
@@ -15,7 +15,6 @@ use Getopt::Long;
 use FindBin qw($RealBin $RealScript);
 use IO::File;
 use Pod::Usage;
-use Cwd qw(realpath);

 use strict;
 use vars qw($Debug @Opt_Verilator_Sw);
@@ -58,7 +57,6 @@ if (! GetOptions(
          # Switches
          "gdb!"             => \$opt_gdb,
          "gdbbt!"           => \$opt_gdbbt,
-          "quiet!"           => \$opt_quiet_exit,  # As -quiet implies -quiet-exit
          "quiet-exit!"      => \$opt_quiet_exit,
          "rr!"              => \$opt_rr,
          "unlimited-stack!" => \$opt_unlimited_stack,
@@ -69,18 +67,6 @@ if (! GetOptions(
    pod2usage(-exitstatus => 2, -verbose => 0);
 }

-my $verilator_root = realpath("$RealBin/..");
-if (defined $ENV{VERILATOR_ROOT}) {
-    if ((!-d $ENV{VERILATOR_ROOT}) || $verilator_root ne realpath($ENV{VERILATOR_ROOT})) {
-        warn "%Error: verilator: VERILATOR_ROOT is set to inconsistent path. Suggest leaving it unset.\n";
-        warn "%Error: VERILATOR_ROOT=$ENV{VERILATOR_ROOT}\n";
-        exit 1;
-    }
-} else {
-    print "export VERILATOR_ROOT='$verilator_root'\n" if $Debug;
-    $ENV{VERILATOR_ROOT} = $verilator_root;
-}
-
 if ($opt_gdbbt && !gdb_works()) {
    warn "-Info: --gdbbt ignored: gdb doesn't seem to be working\n" if $Debug;
    $opt_gdbbt = 0;
@@ -165,13 +151,30 @@ sub debug {
 # Builds

 sub verilator_bin {
+    my $bin = "";
+    # Use VERILATOR_ROOT if defined, else assume verilator_bin is in the search path
    my $basename = ($ENV{VERILATOR_BIN}
                    || ($Debug ? "verilator_bin_dbg" : "verilator_bin"));
-    if (-x "$RealBin/$basename" || -x "$RealBin/$basename.exe") {
-        return "$RealBin/$basename";
+    if (defined($ENV{VERILATOR_ROOT})) {
+        my $dir = $ENV{VERILATOR_ROOT};
+        if (-x "$dir/bin/$basename"
+            || -x "$dir/bin/$basename.exe") {  # From a "make install" into VERILATOR_ROOT
+            $bin = "$dir/bin/$basename";
+        } else {
+            $bin = "$dir/$basename";  # From pointing to kit directory
+        }
    } else {
-        return $basename;  # Find in PATH
+        if (-x "$RealBin/$basename"
+            || -x "$RealBin/$basename.exe") {
+            $bin = "$RealBin/$basename";  # From path/to/verilator with verilator_bin installed
+        } else {
+            $bin = $basename;  # Find in PATH
+        }
+        # Note we don't look under bin/$basename which would be right if running
+        # in the kit dir. Running that would likely break, since
+        # VERILATOR_ROOT wouldn't be set and Verilator won't find internal files.
    }
+    return $bin;
 }

 #######################################################################
@@ -309,7 +312,6 @@ detailed descriptions of these arguments.
     +1800-2009ext+<ext>        Use SystemVerilog 2009 with file extension <ext>
     +1800-2012ext+<ext>        Use SystemVerilog 2012 with file extension <ext>
     +1800-2017ext+<ext>        Use SystemVerilog 2017 with file extension <ext>
-     +1800-2023ext+<ext>        Use SystemVerilog 2023 with file extension <ext>
    --assert                    Enable all assertions
    --assert-case               Enable unique/unique0/priority case related checks
    --autoflush                 Flush streams after all $displays
@@ -324,7 +326,6 @@ detailed descriptions of these arguments.
    --clk <signal-name>         Mark specified signal as clock
    --no-clk <signal-name>      Prevent marking specified signal as clock
    --compiler <compiler-name>  Tune for specified C++ compiler
-    --compiler-include          Include additional header in the precompiled one
    --converge-limit <loops>    Tune convergence settle time
    --coverage                  Enable all coverage
    --coverage-line             Enable line coverage
@@ -349,15 +350,12 @@ detailed descriptions of these arguments.
    --dump-tree                 Enable dumping Ast .tree files
    --dump-tree-addrids         Use short identifiers instead of addresses
    --dump-tree-dot             Enable dumping Ast .tree.dot debug files
-    --dump-tree-json            Enable dumping Ast .tree.json files and .tree.meta.json file
    --dump-<srcfile>            Enable dumping everything in source file
    --dumpi-dfg <level>         Enable dumping DfgGraphs to .dot files at level
    --dumpi-graph <level>       Enable dumping V3Graphs to .dot files at level
    --dumpi-tree <level>        Enable dumping Ast .tree files at level
-    --dumpi-tree-json <level>   Enable dumping Ast .tree.json files at level
    --dumpi-<srcfile> <level>   Enable dumping everything in source file at level
     -E                         Preprocess, but do not compile
-    --emit-accessors            Emit getter and setter methods for model top class
    --error-limit <value>       Abort after this number of errors
    --exe                       Link to create executable
    --expand-limit <value>      Set expand optimization limit
@@ -375,9 +373,8 @@ detailed descriptions of these arguments.
    --generate-key              Create random key for --protect-key
    --getenv <var>              Get environment variable with defaults
    --get-supported <feature>   Get if feature is supported
-    --help                      Show this help
+    --help                      Display this help
    --hierarchical              Enable hierarchical Verilation
-    --hierarchical-params-file <name> Internal option that specifies parameters file for hier blocks
     -I<dir>                    Directory to search for includes
    --if-depth <value>          Tune IFDEPTH warning
     +incdir+<dir>              Directory to search for includes
@@ -390,7 +387,6 @@ detailed descriptions of these arguments.
    --lib-create <name>         Create a DPI library
     +libext+<ext>+[ext]...     Extensions for finding modules
    --lint-only                 Lint, but do not make output
-    --localize-max-size <value>  Tune localize optimization variable size
    --make <build-tool>         Generate scripts for specified build tool
     -MAKEFLAGS <flags>         Arguments to pass to make during --build
    --main                      Generate C++ main() file
@@ -410,10 +406,8 @@ detailed descriptions of these arguments.
    --output-split-ctrace <statements>   Split tracing functions
     -P                         Disable line numbers and blanks with -E
    --pins-bv <bits>            Specify types for top-level ports
-    --pins-inout-enables        Specify that __en and __out signals be created for inouts
    --pins-sc-biguint           Specify types for top-level ports
    --pins-sc-uint              Specify types for top-level ports
-    --pins-sc-uint-bool         Specify types for top-level ports
    --pins-uint8                Specify types for top-level ports
    --no-pins64                 Don't use uint64_t's for 33-64 bit sigs
    --pipe-filter <command>     Filter all input through a script
@@ -432,9 +426,7 @@ detailed descriptions of these arguments.
    --public-params             Mark all parameters as public_flat
    --public-flat-rw            Mark all variables, etc as public_flat_rw
     -pvalue+<name>=<value>     Overwrite toplevel parameter
-    --quiet                     Minimize additional printing
    --quiet-exit                Don't print the command on failure
-    --quiet-stats               Don't print statistics
    --relative-includes         Resolve includes relative to current file
    --reloop-limit              Minimum iterations for forming loops
    --report-unoptflat          Extra diagnostics for UNOPTFLAT
@@ -449,7 +441,7 @@ detailed descriptions of these arguments.
    --no-stop-fail              Do not call $stop when assertion fails
    --structs-packed            Convert all unpacked structures to packed structures
     -sv                        Enable SystemVerilog parsing
-     +systemverilogext+<ext>    Synonym for +1800-2023ext+<ext>
+     +systemverilogext+<ext>    Synonym for +1800-2017ext+<ext>
    --threads <threads>         Enable multithreading
    --threads-dpi <mode>        Enable multithreaded DPI
    --threads-max-mtasks <mtasks>  Tune maximum mtask partitioning
@@ -463,8 +455,8 @@ detailed descriptions of these arguments.
    --trace-coverage            Enable tracing of coverage
    --trace-depth <levels>      Depth of tracing
    --trace-fst                 Enable FST waveform creation
-    --trace-max-array <depth>   Maximum array depth for tracing
-    --trace-max-width <width>   Maximum bit width for tracing
+    --trace-max-array <depth>   Maximum bit width for tracing
+    --trace-max-width <width>   Maximum array depth for tracing
    --trace-params              Enable tracing of parameters
    --trace-structs             Enable tracing structure names
    --trace-threads <threads>   Enable FST waveform creation on separate threads
@@ -482,7 +474,7 @@ detailed descriptions of these arguments.
    --no-verilate               Skip Verilation and just compile previously Verilated code
     +verilog1995ext+<ext>      Synonym for +1364-1995ext+<ext>
     +verilog2001ext+<ext>      Synonym for +1364-2001ext+<ext>
-    --version                   Show program version and exits
+    --version                   Displays program version and exits
    --vpi                       Enable VPI compiles
    --waiver-output <filename>  Create a waiver file based on the linter warnings
     -Wall                      Enable all style warnings
@@ -516,21 +508,20 @@ description of these arguments.

 =for VL_SPHINX_EXTRACT "_build/gen/args_verilated.rst"

-     +verilator+debug                      Enable debugging
-     +verilator+debugi+<value>             Enable debugging at a level
+     +verilator+debug                  Enable debugging
+     +verilator+debugi+<value>         Enable debugging at a level
     +verilator+coverage+file+<filename>   Set coverage output filename
-     +verilator+error+limit+<value>        Set error limit
-     +verilator+help                       Show help
-     +verilator+noassert                   Disable assert checking
+     +verilator+error+limit+<value>    Set error limit
+     +verilator+help                   Display help
+     +verilator+noassert               Disable assert checking
     +verilator+prof+exec+file+<filename>  Set execution profile filename
     +verilator+prof+exec+start+<value>    Set execution profile starting point
     +verilator+prof+exec+window+<value>   Set execution profile duration
     +verilator+prof+vlt+file+<filename>   Set PGO profile filename
-     +verilator+quiet                      Minimize additional printing
-     +verilator+rand+reset+<value>         Set random reset technique
-     +verilator+seed+<value>               Set random seed
-     +verilator+V                          Show verbose version and config
-     +verilator+version                    Show version and exit
+     +verilator+rand+reset+<value>     Set random reset technique
+     +verilator+seed+<value>           Set random seed
+     +verilator+V                      Verbose version and config
+     +verilator+version                Show version and exit


 =head1 DISTRIBUTION
@@ -154,9 +154,9 @@ verilator_coverage - Verilator coverage analyzer

    verilator_coverage --annotate <obj>

-    verilator_coverage  -write merged.dat <datafiles>...
+    verilator_coverage  -write merged.dat -read <datafiles>...

-    verilator_coverage  -write-info merged.info <datafiles>...
+    verilator_coverage  -write-info merged.info -read <datafiles>...

 Verilator_coverage processes Verilated model-generated coverage reports.

@@ -92,12 +92,13 @@ elif [ "$CI_BUILD_STAGE_NAME" = "test" ]; then
    sudo apt-get update ||
    sudo apt-get update
    # libfl-dev needed for internal coverage's test runs
-    sudo apt-get install gdb gtkwave lcov libfl-dev ccache jq z3 ||
-    sudo apt-get install gdb gtkwave lcov libfl-dev ccache jq z3
+    sudo apt-get install gdb gtkwave lcov libfl-dev ccache ||
+    sudo apt-get install gdb gtkwave lcov libfl-dev ccache
    # Required for test_regress/t/t_dist_attributes.pl
    if [ "$CI_RUNS_ON" = "ubuntu-22.04" ]; then
-      sudo apt-get install python3-clang mold ||
-      sudo apt-get install python3-clang mold
+      sudo apt-get install libclang-dev mold ||
+      sudo apt-get install libclang-dev mold
+      pip3 install clang==14.0
    fi
    if [ "$CI_RUNS_ON" = "ubuntu-20.04" ] || [ "$CI_RUNS_ON" = "ubuntu-22.04" ]; then
      sudo apt-get install libsystemc-dev ||
@@ -106,10 +107,10 @@ elif [ "$CI_BUILD_STAGE_NAME" = "test" ]; then
  elif [ "$CI_OS_NAME" = "osx" ]; then
    brew update
    # brew cask install gtkwave # fst2vcd hangs at launch, so don't bother
-    brew install ccache perl jq z3
+    brew install ccache perl
  elif [ "$CI_OS_NAME" = "freebsd" ]; then
    # fst2vcd fails with "Could not open '<input file>', exiting."
-    sudo pkg install -y ccache gmake perl5 python3 jq z3
+    sudo pkg install -y ccache gmake perl5 python3
  else
    fatal "Unknown os: '$CI_OS_NAME'"
  fi
@@ -119,8 +120,6 @@ elif [ "$CI_BUILD_STAGE_NAME" = "test" ]; then
  fi
  yes yes | sudo cpan -M $CI_CPAN_REPO -fi Parallel::Forker
  install-vcddiff
-  # Workaround -fsanitize=address crash
-  sudo sysctl -w vm.mmap_rnd_bits=28
 else
  ##############################################################################
  # Unknown build stage
@@ -40,7 +40,7 @@ if [ "$CI_BUILD_STAGE_NAME" = "build" ]; then

  if [ "$COVERAGE" != 1 ]; then
    autoconf
-    ./configure --enable-longtests --enable-ccwarn --prefix="$INSTALL_DIR"
+    ./configure --enable-longtests --enable-ccwarn
    ccache -z
    "$MAKE" -j "$NPROC" -k
    # 22.04: ccache -s -v
@@ -87,40 +87,23 @@ elif [ "$CI_BUILD_STAGE_NAME" = "test" ]; then
  # Run sanitize on Ubuntu 22.04 only
  [ "$CI_RUNS_ON" = 'ubuntu-22.04' ] && sanitize='--sanitize' || sanitize=''

-  TEST_REGRESS=test_regress
-  if [ "$CI_RELOC" == 1 ]; then
-     # Testing that the installation is relocatable.
-     "$MAKE" install
-     mkdir -p "$RELOC_DIR"
-     mv "$INSTALL_DIR" "$RELOC_DIR/relocated-install"
-     export VERILATOR_ROOT="$RELOC_DIR/relocated-install/share/verilator"
-     TEST_REGRESS="$RELOC_DIR/test_regress"
-     mv test_regress "$TEST_REGRESS"
-     # Feeling brave?
-     find . -delete
-     ls -la .
-  fi
-
  # Run the specified test
  ccache -z
  case $TESTS in
    dist-vlt-0)
-      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--dist --vlt $sanitize" DRIVER_HASHSET=--hashset=0/4
+      "$MAKE" -C test_regress SCENARIOS="--dist --vlt $sanitize" DRIVER_HASHSET=--hashset=0/3
      ;;
    dist-vlt-1)
-      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--dist --vlt $sanitize" DRIVER_HASHSET=--hashset=1/4
+      "$MAKE" -C test_regress SCENARIOS="--dist --vlt $sanitize" DRIVER_HASHSET=--hashset=1/3
      ;;
    dist-vlt-2)
-      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--dist --vlt $sanitize" DRIVER_HASHSET=--hashset=2/4
-      ;;
-    dist-vlt-3)
-      "$MAKE" -C "$TEST_REGRESS" SCENARIOS="--dist --vlt $sanitize" DRIVER_HASHSET=--hashset=3/4
+      "$MAKE" -C test_regress SCENARIOS="--dist --vlt $sanitize" DRIVER_HASHSET=--hashset=2/3
      ;;
    vltmt-0)
-      "$MAKE" -C "$TEST_REGRESS" SCENARIOS=--vltmt DRIVER_HASHSET=--hashset=0/2
+      "$MAKE" -C test_regress SCENARIOS=--vltmt DRIVER_HASHSET=--hashset=0/2
      ;;
    vltmt-1)
-      "$MAKE" -C "$TEST_REGRESS" SCENARIOS=--vltmt DRIVER_HASHSET=--hashset=1/2
+      "$MAKE" -C test_regress SCENARIOS=--vltmt DRIVER_HASHSET=--hashset=1/2
      ;;
    coverage-all)
      nodist/code_coverage --stages 1-
@@ -192,10 +175,13 @@ elif [ "$CI_BUILD_STAGE_NAME" = "test" ]; then
      fatal "Unknown test: $TESTS"
      ;;
  esac
-
  # 22.04: ccache -s -v
  ccache -s

+  # Upload coverage data
+  if [[ $TESTS == coverage-* ]]; then
+    bash <(cat ci/coverage-upload.sh) -f nodist/obj_dir/coverage/app_total.info
+  fi
 else
  ##############################################################################
  # Unknown build stage
@@ -1,15 +1,3 @@
-# DESCRIPTION: Verilator: CI Windows Power Shell - Compile Verilator
-#
-# Copyright 2024 by Wilson Snyder. This program is free software; you
-# can redistribute it and/or modify it under the terms of either the GNU
-# Lesser General Public License Version 3 or the Perl Artistic License
-# Version 2.0.
-#
-# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
-################################################################################
-
-Set-PSDebug -Trace 1
-
 if (-Not (Test-Path $PWD/../.ccache/win_bison.exe)) {
 	git clone --depth 1 https://github.com/lexxmark/winflexbison
 	cd winflexbison
@@ -20,7 +8,6 @@ if (-Not (Test-Path $PWD/../.ccache/win_bison.exe)) {
 	cmake --install . --prefix $PWD/../../../.ccache
 	cd ../..
 }
-
 mkdir build
 cd build
 cmake .. --install-prefix $PWD/../install
@@ -1,16 +1,3 @@
-# DESCRIPTION: Verilator: CI Windows Power Shell - Verilate a test
-#
-# Copyright 2024 by Wilson Snyder. This program is free software; you
-# can redistribute it and/or modify it under the terms of either the GNU
-# Lesser General Public License Version 3 or the Perl Artistic License
-# Version 2.0.
-#
-# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
-################################################################################
-
-
-Set-PSDebug -Trace 1
-
 cd install
 $Env:VERILATOR_ROOT=$PWD
 cd examples/cmake_tracing_c
@@ -18,9 +5,6 @@ mkdir build
 cd build
 cmake ..
 cmake --build . --config Release -j 3
-
-# TODO put this back in, see issue# 5163
-# Release/example.exe
-
+Release/example.exe
 cd ..
 Remove-Item -path build -recurse
@@ -43,7 +43,6 @@ RUN apt-get update \
                        perl \
                        python3 \
                        wget \
-                        z3 \
                        zlib1g \
                        zlib1g-dev \
    && apt-get clean \
@@ -11,11 +11,10 @@ easily as a docker image, e.g.:

   docker run -ti verilator/verilator:latest --version

-This will pull the container from `docker hub
-<https://hub.docker.com/r/verilator/verilator>`_, run the latest Verilator and print
+This will install the container, run the latest Verilator and print
 Verilator's version.

-Containers are automatically built and pushed to docker hub for all released versions, so you may
+Containers are automatically built for all released versions, so you may
 easily compare results across versions, e.g.:

 ::
@@ -5,12 +5,12 @@
 # General Public License Version 3 or the Perl Artistic License Version 2.0.
 # SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0

-# When releasing, also update header of Changes file, and CMakeLists.txt,
+# When releasing, also update header of Changes file, and CmakeLists.txt,
 # and commit using "devel release" or "Version bump" message
 # Then 'make maintainer-dist'
 #AC_INIT([Verilator],[#.### YYYY-MM-DD])
 #AC_INIT([Verilator],[#.### devel])
-AC_INIT([Verilator],[5.028 2024-08-21],
+AC_INIT([Verilator],[5.022 2024-02-24],
        [https://verilator.org],
        [verilator],[https://verilator.org])

@@ -134,28 +134,6 @@ AC_ARG_ENABLE([longtests],
 AC_SUBST(CFG_WITH_LONGTESTS)
 AC_MSG_RESULT($CFG_WITH_LONGTESTS)

-AC_CHECK_PROG(HAVE_Z3,z3,yes)
-AC_CHECK_PROG(HAVE_CVC5,cvc5,yes)
-AC_CHECK_PROG(HAVE_CVC4,cvc4,yes)
-
-# Special Substitutions - CFG_WITH_SOLVER
-AC_MSG_CHECKING(for SMT solver)
-AC_ARG_WITH([solver],
-              [AS_HELP_STRING([--with-solver='z3 --in'],
-                              [set default SMT solver for constrained randomization])],
-              [CFG_WITH_SOLVER="${withval}"],
-              [CFG_WITH_SOLVER=no
-               if test "x$HAVE_Z3" = "xyes"; then
-                CFG_WITH_SOLVER="z3 --in"
-               elif test "x$HAVE_CVC5" = "xyes"; then
-                CFG_WITH_SOLVER="cvc5 --incremental"
-               elif test "x$HAVE_CVC4" = "xyes"; then
-                CFG_WITH_SOLVER="cvc4 --lang=smt2 --incremental"
-               fi]
-              )
-AC_SUBST(CFG_WITH_SOLVER)
-AC_MSG_RESULT($CFG_WITH_SOLVER)
-
 # Compiler flags (ensure they are not empty to avoid configure defaults)
 CFLAGS="$CFLAGS "
 CPPFLAGS="$CPPFLAGS "
@@ -288,43 +266,6 @@ AC_DEFUN([_MY_CXX_CHECK_OPT],
    _MY_CXX_CHECK_IFELSE($2, $1="$$1 $2")
   ])

-AC_DEFUN([_MY_CXX_CHECK_CORO_SET],
-   [# _MY_CXX_CHECK_CORO_SET(variable,option)
-    # Check if compiler supports coroutines with specific option. If it does,
-    # set variable to option, only if not previously set.
-    # Define HAVE_COROUTINES if supported.
-    if test "$$1" = ""; then
-      if test "$2" != ""; then
-        _my_msg_opt=" with $2"
-      else
-        _my_msg_opt=""
-      fi
-      AC_MSG_CHECKING([whether coroutines are supported by $CXX$_my_msg_opt])
-      ACO_SAVE_CXXFLAGS="$CXXFLAGS"
-      CXXFLAGS="$CXXFLAGS $2"
-      AC_LINK_IFELSE(
-         [AC_LANG_PROGRAM([
-            #if defined(__clang__) && !defined(__cpp_impl_coroutine)
-            #define __cpp_impl_coroutine 1
-            #endif
-            #include <coroutine>
-          ],[[std::coroutine_handle<> h;]])],
-         [_my_result=yes],
-         [AC_LINK_IFELSE(
-             [AC_LANG_PROGRAM(
-                [#include <experimental/coroutine>],
-                [[std::experimental::coroutine_handle<> h;]])],
-             [_my_result=yes],
-             [_my_result=no])])
-      AC_MSG_RESULT($_my_result)
-      CXXFLAGS="$ACO_SAVE_CXXFLAGS"
-      if test "$_my_result" = "yes" ; then
-        $1="$2"
-        AC_DEFINE([HAVE_COROUTINES],[1],[Defined if coroutines are supported by $CXX])
-      fi
-    fi
-  ])
-
 AC_DEFUN([_MY_LDLIBS_CHECK_FLAG],
   [# _MY_LDLIBS_CHECK_FLAG(flag) -- Check if linker supports specific options
    # Set $_my_result appropriately
@@ -410,12 +351,32 @@ _MY_CXX_CHECK_OPT(CFG_CXXFLAGS_WEXTRA,-Wthread-safety)
 AC_SUBST(CFG_CXXFLAGS_WEXTRA)

 # Flags for coroutine support for dynamic scheduling
-_MY_CXX_CHECK_CORO_SET(CFG_CXXFLAGS_COROUTINES, "")
-_MY_CXX_CHECK_CORO_SET(CFG_CXXFLAGS_COROUTINES,-fcoroutines-ts)
-_MY_CXX_CHECK_CORO_SET(CFG_CXXFLAGS_COROUTINES,-fcoroutines)
-_MY_CXX_CHECK_CORO_SET(CFG_CXXFLAGS_COROUTINES,-fcoroutines-ts -Wno-deprecated-experimental-coroutine)
-_MY_CXX_CHECK_CORO_SET(CFG_CXXFLAGS_COROUTINES,-std=gnu++20)
+_MY_CXX_CHECK_SET(CFG_CXXFLAGS_COROUTINES,-fcoroutines-ts)
+_MY_CXX_CHECK_SET(CFG_CXXFLAGS_COROUTINES,-fcoroutines)
+_MY_CXX_CHECK_SET(CFG_CXXFLAGS_COROUTINES,-fcoroutines-ts -Wno-deprecated-experimental-coroutine)
 AC_SUBST(CFG_CXXFLAGS_COROUTINES)
+
+# HAVE_COROUTINES
+# Check if coroutines are supported at all
+AC_MSG_CHECKING([whether coroutines are supported by $CXX])
+ACO_SAVE_CXXFLAGS="$CXXFLAGS"
+CXXFLAGS="$CXXFLAGS $CFG_CXXFLAGS_COROUTINES"
+AC_LINK_IFELSE(
+    [AC_LANG_PROGRAM([
+#ifdef __clang__
+#define __cpp_impl_coroutine 1
+#endif
+#include <coroutine>
+    ],[[]])],
+    [_my_result=yes
+     AC_DEFINE([HAVE_COROUTINES],[1],[Defined if coroutines are supported by $CXX])],
+    [AC_LINK_IFELSE(
+        [AC_LANG_PROGRAM([#include <experimental/coroutine>],[[]])],
+        [_my_result=yes
+         AC_DEFINE([HAVE_COROUTINES],[1],[Defined if coroutines are supported by $CXX])],
+        [_my_result=no])])
+AC_MSG_RESULT($_my_result)
+CXXFLAGS="$ACO_SAVE_CXXFLAGS"
 AC_SUBST(HAVE_COROUTINES)

 # Flags for compiling Verilator internals including parser always
@@ -9,25 +9,20 @@ Adrien Le Masle
 Ahmed El-Mahmoudy
 Aleksander Kiryk
 Alex Chadwick
-Alex Solomatnikov
 Àlex Torregrosa
 Aliaksei Chapyzhenka
 Ameya Vikram Singh
-Andrea Calabrese
 Andreas Kuster
 Andrei Kostovski
 Andrew Miloradovsky
 Andrew Nolte
 Anthony Donlon
 Arkadiusz Kozdra
-Arthur Rosa
 Aylon Chaim Porat
 Bartłomiej Chmiel
 Cameron Kirk
 Chih-Mao Chen
-Chris Bachhuber
 Chris Randall
-Christopher Taylor
 Chuxuan Wang
 Chykon
 Conor McCullough
@@ -38,7 +33,6 @@ David Ledger
 David Metz
 David Stanford
 David Turner
-Dercury
 Don Williamson
 Drew Ranck
 Drew Taussig
@@ -52,12 +46,10 @@ february cozzocrea
 Felix Neumärker
 Felix Yan
 Frans Skarman
-Fuad Ismail
 G-A. Kamendje
 Garrett Smith
 Geza Lore
 Gianfranco Costamagna
-Gijs Burghoorn
 Glen Gibb
 Gökçe Aydos
 Graham Rushton
@@ -77,7 +69,6 @@ Iru Cai
 Ivan Vnučec
 Iztok Jeras
 Jake Merdich
-James Bailey
 James Hanlon
 James Hutchinson
 James Pallister
@@ -112,19 +103,14 @@ Justin Thiel
 Kaleb Barrett
 Kamil Rakoczy
 Kanad Kanhere
-Kefa Chen
 Keith Colbert
 Kevin Kiningham
-Kevin Nygaard
 Kritik Bhimani
 Krzysztof Bieganski
 Krzysztof Boronski
 Krzysztof Boroński
-Krzysztof Obłonczek
 Kuba Ober
 Larry Doolittle
-Liam Braun
-Luca Colagrande
 Ludwig Rogiers
 Lukasz Dalek
 Maarten De Braekeleer
@@ -138,7 +124,6 @@ Marshal Qiao
 Martin Schmidt
 Martin Stadler
 Matthew Ballance
-Michael Bikovitsky
 Michael Killough
 Michaël Lefebvre
 Michal Czyz
@@ -150,19 +135,15 @@ Mostafa Gamal
 Nandu Raj
 Nathan Kohagen
 Nathan Myers
-Nolan Poe
 Oleh Maksymenko
 Patrick Stewart
-Paul Bowen-Huggett
 Paul Swirhun
 Paul Wright
-Pawel Jewstafjew
 Pawel Sagan
 Pengcheng Xu
 Peter Debacker
 Peter Horvath
 Peter Monsson
-Philip Axer
 Philipp Wagner
 Pierre-Henri Horrein
 Pieter Kapsenberg
@@ -172,18 +153,15 @@ Quentin Corradi
 Rafal Kapuscik
 Rasfunk
 Raynard Qiao
-Ricardo Barbedo
 Richard Myers
 Risto Pejašinović
 Robert Balas
 Rupert Swarbrick
-Ryan Ziegler
 Ryszard Rozak
 Samuel Riedel
 Sean Cross
 Sebastien Van Cauwenberghe
 Sergi Granell
-Seth Pellegrino
 Srinivasan Venkataramanan
 Stefan Wallentowitz
 Stephen Henry
@@ -203,8 +181,6 @@ Tudor Timi
 Tymoteusz Blazejczyk
 Udi Finkelstein
 Unai Martinez-Corral
-Udaya Raj Subedi
-Valentin Atepalikhin
 Varun Koyyalagunta
 Vassilis Papaefstathiou
 Veripool API Bot
@@ -213,8 +189,6 @@ Vito Gamberini
 William D. Jones
 Wilson Snyder
 Xi Zhang
-Yan Xu
-Yangyu Chen
 Yinan Xu
 Yoda Lee
 Yossi Nivin
@@ -226,4 +200,3 @@ Zhanglei Wang
 Zhou Shen
 Zixi Li
 أحمد المحمودي
-404allen404
@@ -1,6 +1,6 @@
 .. comment: generated by t_lint_multidriven_bad
 .. code-block::

-   %Warning-MULTIDRIVEN: example.v:1:22 Signal has multiple driving blocks with different clocking: 't.mem'
+   %Warning-MULTIDRIVEN: example.v:1:22 Signal has multiple driving blocks with different clocking: 'out2'
                         example.v:1:7 ... Location of first driving block
                         example.v:1:7 ... Location of other driving block
@@ -1,11 +0,0 @@
-.. comment: generated by t_lint_pinmissing_bad
-.. code-block:: sv
-   :linenos:
-   :emphasize-lines: 2
-
-   module t;
-      sub sub();  // <--- Warning
-   endmodule
-   module sub
-     (output port);
-   endmodule
@@ -1,4 +0,0 @@
-.. comment: generated by t_lint_pinmissing_bad
-.. code-block::
-
-   %Warning-PINMISSING: example.v:1:8 Cell has missing pin: 'port'
@@ -1,11 +0,0 @@
-.. comment: generated by t_lint_pkgnodecl_bad
-.. code-block:: sv
-   :linenos:
-   :emphasize-lines: 2
-
-   module t;
-      initial Pkg::hello();  //<--- Warning
-   endmodule
-   package Pkg;
-      function void hello(); endfunction
-   endpackage
@@ -1,4 +0,0 @@
-.. comment: generated by t_lint_pkgnodecl_bad
-.. code-block::
-
-   %Error-PKGNODECL: example.v:1:12 Package/class 'Pkg' not found, and needs to be predeclared (IEEE 1800-2023 26.3)
@@ -407,16 +407,6 @@ only a couple of instructions.
 For signal callbacks to work the main loop of the program must call
 :code:`VerilatedVpi::callValueCbs()`.

-Verilator also tracks when the model state has been modified via the VPI with
-an :code:`evalNeeded` flag.  This flag can be checked with :code:`VerilatedVpi::evalNeeded()`
-and it can be cleared with :code:`VerilatedVpi::clearEvalNeeded()`.  Used together
-it is possible to skip :code:`eval()` calls if no model state has been changed
-since the last :code:`eval()`.
-
-Any data written via :code:`vpi_put_value` with :code:`vpiInertialDelay` will
-be deferred for later.  These delayed values can be flushed to the model with
-:code:`VerilatedVpi::doInertialPuts()`.
-

 .. _VPI Example:

@@ -118,12 +118,6 @@ associated programs.

   See :ref:`Installation` for more details.

-.. option:: VERILATOR_SOLVER
-
-   If set, the command to run as a constrained randomization backend, such
-   as :command:`cvc4 --lang=smt2 --incremental`.  If not specified, it will use
-   the one supplied or found during configure, or :command:`z3 --in` if empty.
-
 .. option:: VERILATOR_VALGRIND

   If set, the command to run when using the :vlopt:`--valgrind` option, such as
@@ -92,11 +92,6 @@ Summary:
   profile-guided optimization data runtime filename to dump to.  Defaults
   to :file:`profile.vlt`.

-.. option:: +verilator+quiet
-
-   Disable printing the simulation summary report, see :ref:`Simulation
-   Summary Report`.
-
 .. option:: +verilator+rand+reset+<value>

   When a model was Verilated using
@@ -51,8 +51,6 @@ Summary:

 .. option:: +1800-2017ext+<ext>

-.. option:: +1800-2023ext+<ext>
-
   Specifies the language standard to be used with a specific filename
   extension, <ext>.

@@ -201,10 +199,9 @@ Summary:

 .. option:: --compiler <compiler-name>

-   Enables workarounds for the specified C++ compiler (list below).  This
-   does not change any performance tuning options, but it may in the
-   future.  This also does not change default compiler flags; these are
-   determined when Verilator was configured.
+   Enables workarounds for the specified C++ compiler (list below).
+   This does not change any performance tuning options, but it may
+   in the future.

   clang
     Tune for clang.  This may reduce execution speed as it enables several
@@ -222,13 +219,6 @@ Summary:
     expressions into sub-expressions to avoid error C1009, and breaking
     deep blocks into functions to avoid error C1061.

-.. option:: --compiler-include <header-path>
-
-   Specifies additional headers to be included in the final PCH header.
-   It is required to add them to this header, due to compilers'
-   limitation that allow only one precompiled header per compilation.
-   Use this instead of ::vlopt:`-CFLAGS` with `-include <header-path>`.
-
 .. option:: --converge-limit <loops>

   Rarely needed.  Specifies the maximum number of runtime iterations
@@ -358,7 +348,7 @@ Summary:
   Select the language used by default when first processing each
   Verilog file.  The language value must be "VAMS", "1364-1995",
   "1364-2001", "1364-2001-noconfig", "1364-2005", "1800-2005",
-   "1800-2009", "1800-2012", "1800-2017", "1800-2023", or "1800+VAMS".
+   "1800-2009", "1800-2012", "1800-2017", or "1800+VAMS".

   Any language associated with a particular file extension (see the
   various +<lang>*\ ext+ options) will be used in preference to the
@@ -371,7 +361,7 @@ Summary:
   ``+<lang>ext+`` options should be used.

   If no language is specified, either by this option or ``+<lang>ext+``
-   options, then the latest SystemVerilog language (IEEE 1800-2023) is
+   options, then the latest SystemVerilog language (IEEE 1800-2017) is
   used.

 .. option:: +define+<var>=<value>
@@ -420,12 +410,6 @@ Summary:
   :vlopt:`--debug --no-dump-tree <--dump-tree>` may be useful if the dump
   files are large and not desired.

-.. option:: --dump-tree-json
-
-   Rarely needed.  Enable dumping Ast .json.tree debug files with dumping level 3,
-   which dumps the standard critical stages.  For details on the format, see
-   the Verilator Internals manual.
-
 .. option:: --dump-tree-dot

   Rarely needed.  Enable dumping Ast .tree.dot debug files in Graphviz
@@ -461,11 +445,6 @@ Summary:
   Rarely needed - for developer use.  Set internal Ast dumping level
   globally to the specified value.

-.. option:: --dumpi-tree-json <level>
-
-   Rarely needed - for developer use.  Set internal Ast JSON dumping level
-   globally to the specified value.
-
 .. option:: --dumpi-<srcfile> <level>

   Rarely needed - for developer use. Set the dumping level in the
@@ -483,12 +462,6 @@ Summary:
   See also :vlopt:`--dump-defines`, :vlopt:`-P`, and
   :vlopt:`--pp-comments` options.

-.. option:: --emit-accessors
-
-   Emit getter and setter methods for each top-level signal in the
-   model top class. Signals are still available as public members,
-   but with the `__Vm_sig_` prefix.
-
 .. option:: --error-limit <value>

   After this number of errors are encountered during Verilator run, exit.
@@ -723,13 +696,6 @@ Summary:
   :option:`/*verilator&32;hier_block*/` metacomment is ignored.  See
   :ref:`Hierarchical Verilation`.

-.. option:: --hierarchical-params-file <filename>
-
-   Internal flag inserted used during :vlopt:`--hierarchical`; specifies
-   name of hierarchical parameters file for deparametrized modules with
-   :option:`/*verilator&32;hier_block*/` metacomment. See
-   :ref:`Hierarchical Verilation`.
-
 .. option:: -I<dir>

   See :vlopt:`-y`.
@@ -837,11 +803,6 @@ Summary:
   If the design is not to be completely Verilated, see also the
   :vlopt:`--bbox-sys` and :vlopt:`--bbox-unsup` options.

-.. option:: --localize-max-size <value>
-
-   Rarely needed.  Set the maximum variable size in bytes for it to be
-   subject to localizing-to-stack optimization.  Defaults to 1024.
-
 .. option:: --make <build-tool>

   Generates a script for the specified build tool.
@@ -1010,13 +971,6 @@ Summary:
   :option:`/*verilator&32;sc_bv*/` metacomment to select specific ports to
   be sc_bv.

-.. option:: --pins-inout-enables
-
-   Specifies that the __en and __out outputs will always be created for
-   inouts in the top-level module. The __en variable has a one in a bit
-   position to indicate the corresponding bit of the __out variable has
-   a value being driven from within the Verilated model.
-
 .. option:: --pins-sc-uint

   Specifies SystemC inputs/outputs greater than 2 bits wide should use
@@ -1024,10 +978,6 @@ Summary:
   :vlopt:`--pins-sc-biguint` combination, it results in sc_uint being used
   between 2 and 64 and sc_biguint being used between 65 and 512.

-.. option:: --pins-sc-uint-bool
-
-   Specifies SystemC inputs/outputs one bit wide should use sc_uint<1>.
-
 .. option:: --pins-sc-biguint

   Specifies SystemC inputs/outputs greater than 65 bits wide should use
@@ -1210,20 +1160,11 @@ Summary:
   Overwrites the given parameter(s) of the top-level module. See
   :vlopt:`-G <-G<name>>` for a detailed description.

-.. option:: --quiet
-
-   Alias for :vlopt:`--quiet-exit` :vlopt:`--quiet-stats`.
-
 .. option:: --quiet-exit

   When exiting due to an error, do not display the "Exiting due to Errors"
   nor "Command Failed" messages.

-.. option:: --quiet-stats
-
-   Disable printing the Verilation statistics report, see :ref:`Verilation
-   Summary Report`.
-
 .. option:: --relative-includes

   When a file references an include file, resolve the filename relative to
@@ -1357,12 +1298,12 @@ Summary:
 .. option:: -sv

   Specifies SystemVerilog language features should be enabled; equivalent
-   to :vlopt:`--language 1800-2023 <--language>`.  This option is selected
+   to :vlopt:`--language 1800-2017 <--language>`.  This option is selected
   by default; it exists for compatibility with other simulators.

 .. option:: +systemverilogext+<ext>

-   A synonym for :vlopt:`+1800-2023ext+\<ext\>`.
+   A synonym for :vlopt:`+1800-2017ext+\<ext\>`.

 .. option:: --threads <threads>

@@ -1768,9 +1709,9 @@ Summary:

   .. note::

-      This option applies only to values explicitly written as X in modules
-      (not classes, nor parameters) in the Verilog source code. Initial
-      values of clocks are set to 0 unless `--x-initial-edge` is
+      This option applies only to values explicitly written as X
+      in modules (not classes) in the Verilog source code. Initial values
+      of clocks are set to 0 unless `--x-initial-edge` is
      specified. Initial values of all other state holding variables are
      controlled with `--x-initial`.

@@ -1845,8 +1786,7 @@ Summary:
   format is still evolving; there will be some changes in future versions.

   This option disables some more aggressive transformations and dumps only
-   the final state of the AST. For more granular and unaltered dumps, meant
-   mainly for debugging see :vlopt:`--dump-tree-json`.
+   the final state of the AST.

 .. option:: --json-only-meta-output <filename>

@@ -2003,13 +1943,6 @@ The grammar of configuration commands is as follows:
   that the setting is ignored unless the :vlopt:`--hierarchical` option is
   specified.  See :ref:`Hierarchical Verilation`.

-.. option:: hier_params -module "<modulename>"
-
-   Specifies that the module contains parameters a :vlopt:`--hierarchical` block. This option
-   is used internally to specify parameters for deparametrized hier block instances.
-   This option should not be used directly.
-   See :ref:`Hierarchical Verilation`.
-
 .. option:: inline -module "<modulename>"

   Specifies the module may be inlined into any modules that use this
@@ -37,9 +37,9 @@ verilator_coverage Example Usage

    verilator_coverage --annotate <obj>

-    verilator_coverage  -write merged.dat <datafiles>...
+    verilator_coverage  -write merged.dat -read <datafiles>...

-    verilator_coverage  -write-info merged.info <datafiles>...
+    verilator_coverage  -write-info merged.info -read <datafiles>...


 verilator_coverage Arguments
@@ -36,7 +36,8 @@ or "`ifdef`"'s may break other tools.
 .. option:: """ [string] """

   A triple-quoted block specifies a string that may include newlines and
-   single quotes.  This extension was standardized in IEEE 1800-2023.
+   single quotes.  This extension is experimental and may be removed
+   without deprecation.

 .. option:: $c([string], ...);

@@ -576,10 +577,6 @@ or "`ifdef`"'s may break other tools.

 .. option:: /*verilator&32;trace_init_task*/

-   Removed.
-
-   In versions before 5.024:
-
   Attached to a DPI import to indicate that function should be called when
   initializing tracing. This attribute is indented only to be used
   internally in code that Verilator generates when :vlopt:`--lib-create`
@@ -622,4 +619,4 @@ or "`ifdef`"'s may break other tools.
   symbols.  Also, the data represents the C++ stack; the SystemVerilog
   functions/tasks involved may be renamed and/or inlined before becoming
   the C++ functions that may be visible in the stack trace.  This
-   extension was standardized in IEEE 1800-2023.
+   extension is experimental and may be removed without deprecation.
@@ -128,13 +128,10 @@ How do I generate waveforms (traces) in C++?

 See also the next question for tracing in SystemC mode.

-A. Pass the :vlopt:`--trace` option to Verilator.  Then you may use ``$dumpfile`` and
-   ``$dumpvars`` to enable traces, the same as with any Verilog simulator,
-   although Verilator ignores the arguments to ``$dumpvars``. See
-   ``examples/make_tracing_c`` in the distribution.
-
-   If writing the top-level C code, call ``Verilated::traceEverOn(true)``;
-   this is done for you if using :vlopt:`--binary`.
+A. Pass the :vlopt:`--trace` option to Verilator, and in your top-level C
+   code, call ``Verilated::traceEverOn(true)``.  Then you may use
+   ``$dumpfile`` and ``$dumpvars`` to enable traces, the same as with any
+   Verilog simulator. See ``examples/make_tracing_c`` in the distribution.

 B. Or, for finer-grained control, or C++ files with multiple Verilated
   modules, you may also create the trace purely from C++.  Create a
@@ -259,11 +256,9 @@ How do I view waveforms (aka dumps or traces)?
 """"""""""""""""""""""""""""""""""""""""""""""

 Verilator creates standard VCD (Value Change Dump) and FST files.  VCD
-files are viewable with the open-source
-`GTKWave <http://gtkwave.sourceforge.net/>`_,
-`Surfer <https://surfer-project.org/>`_, Dinotrace (legacy), or any of the
-many closed-source viewer offerings; FST is supported only by GTKWave and
-Surfer.
+files are viewable with the open-source GTKWave (recommended), or Dinotrace
+(legacy) programs, or any of the many closed-source offerings; FST is
+supported only by GTKWave.


 How do I speed up writing large waveform (trace) files?
@@ -48,6 +48,12 @@ For --cc/--sc, it creates:
     - Make include file for compiling (from --make gmake)
   * - *{prefix}*\ _classes.mk
     - Make include file with class names (from --make gmake)
+   * - *{prefix}*\ _hier.mk
+     - Make file for hierarchy blocks (from --make gmake)
+   * - *{prefix}*\ __hierMkArgs.f
+     - Arguments for hierarchical Verilation (from --make gmake)
+   * - *{prefix}*\ __hierCMakeArgs.f
+     - Arguments for hierarchical Verilation (from --make cmake)
   * - *{prefix}*\ .h
     - Model header
   * - *{prefix}*\ .cpp
@@ -89,24 +95,16 @@ For --cc/--sc, it creates:
   * - *{prefix}{each_verilog_module}{__DepSet_hash__n}*\ .cpp
     - Additional lower C++ files (hashed to reduce build times)

-For --hierarchical mode, it creates:
+For --hierarchy mode, it creates:

 .. list-table::

   * - V\ *{hier_block}*\ /
-     - Directory to Verilate each hierarchical block (from --hierarchical)
+     - Directory to Verilate each hierarchy block (from --hierarchy)
   * - *{prefix}*\ __hierVer.d
-     - Make dependencies of the top module (from --hierarchical)
-   * - *{prefix}*\ _hier.mk
-     - Make file for hierarchical blocks (from --make gmake)
-   * - *{prefix}*\ __hierCMakeArgs.f
-     - Arguments for hierarchical Verilation (from --make cmake)
-   * - *{prefix}*\ __hierMkArgs.f
-     - Arguments for hierarchical Verilation (from --make gmake)
-   * - *{prefix}*\ __hierParameters.v
-     - Module parameters for hierarchical blocks
+     - Make dependencies of the top module (from --hierarchy)
   * - *{prefix}*\ __hier.dir
-     - Directory to store .dot, .vpp, .tree of top module (from --hierarchical)
+     - Directory to store .dot, .vpp, .tree of top module (from --hierarchy)

 In specific debug and other modes, it also creates:

@@ -126,9 +126,8 @@ Those developing Verilator itself may also want these (see internals.rst):
 ::

   sudo apt-get install clang clang-format-14 cmake gdb gprof graphviz lcov
-   sudo apt-get install python3-clang yapf3 bear jq
-   sudo pip3 install sphinx sphinx_rtd_theme sphinxcontrib-spelling breathe ruff
-   sudo pip3 install git+https://github.com/antmicro/astsee.git
+   sudo apt-get install libclang-dev yapf3 bear
+   sudo pip3 install clang sphinx sphinx_rtd_theme sphinxcontrib-spelling breathe ruff
   cpan install Pod::Perldoc
   cpan install Parallel::Forker

@@ -152,17 +151,6 @@ To make use of Verilator FST tracing you will want `GTKwave
 required at Verilator build time.


-Install Z3
-^^^^^^^^^^
-
-In order to use constrained randomization the `Z3 Theorem Prover
-<https://github.com/z3prover/z3#readme>`__ must be installed, however this is
-not required at Verilator build time. There are other compatible SMT solvers,
-like CVC5/CVC4, but they are not guaranteed to work. Since different solvers are
-faster for different scenarios, the solver to use at run-time can be specified
-by the environment variable :option:`VERILATOR_SOLVER`.
-
-
 .. _Obtain Sources:

 Obtain Sources
@@ -204,9 +192,8 @@ Eventual Installation Options
 Before configuring the build, you must decide how you're going to
 eventually install Verilator onto your system. Verilator will be compiling
 the current value of the environment variables :option:`VERILATOR_ROOT`,
-:option:`VERILATOR_SOLVER`, :option:`SYSTEMC_INCLUDE`, and
-:option:`SYSTEMC_LIBDIR` as defaults into the executable, so they must be
-correct before configuring.
+:option:`SYSTEMC_INCLUDE`, and :option:`SYSTEMC_LIBDIR` as defaults into
+the executable, so they must be correct before configuring.

 These are the installation options:

@@ -62,23 +62,12 @@ Verilator supports the 2017 "for" loop constructs and several cleanups IEEE
 made in 1800-2017.


-SystemVerilog 2023 (IEEE 1800-2023) Support
-------------------------------------------
-
-Verilator supports some of the 2023 improvements, including triple-quoted
-string blocks that may include newlines and single quotes.
-
-Verilator implements a full IEEE 1800-2023 compliant preprocessor,
-including triple-quoted strings, and \`ifdef expressions.
-
-
 Verilog AMS Support
 -------------------

 Verilator implements a very small subset of Verilog AMS (Verilog Analog and
 Mixed-Signal Extensions) with the subset corresponding to those VMS
-keywords with near-equivalents in Verilog IEEE 1364 or SystemVerilog
-IEEE 1800.
+keywords with near-equivalents in Verilog 2005 or SystemVerilog 2017.

 AMS parsing is enabled with :vlopt:`--language VAMS <--language>` or
 :vlopt:`--language 1800+VAMS <--language>`.
@@ -50,6 +50,6 @@ The best place to get started is to try the :ref:`Examples`.
 .. [#] SystemVerilog is defined by the `Institute of Electrical and
       Electronics Engineers (IEEE) Standard for SystemVerilog - Unified
       Hardware Design, Specification, and Verification Language`, Standard
-       1800, released in 2005, 2009, 2012, 2017, and 2023.  The Verilator
-       documentation uses the shorthand e.g., "IEEE 1800-2023", to refer to
-       the, e.g., 2023 version of this standard.
+       1800, released in 2005, 2009, 2012, and 2017.  The Verilator
+       documentation uses the shorthand e.g., "IEEE 1800-2017", to refer to
+       the, e.g., 2017 version of this standard.
@@ -12,60 +12,6 @@ Verilated model's executable.  For the runtime arguments to a simulated
 model, see :ref:`Simulation Runtime Arguments`.


-.. _Simulation Summary Report:
-
-Simulation Summary Report
-=========================
-
-When simulation finishes, it will print a report to stdout summarizing the
-simulation. This requires the model being Verilated with :vlopt:`--main`.
-The report may be disabled with :vlopt:`+verilator+quiet`.
-
-For example:
-
-.. code-block::
-
-   - S i m u l a t i o n   R e p o r t: Verilator ...
-   - Verilator: End at simtime 123 ns; walltime 1234.001 s; speed 123 ns/s
-   - Verilator: cpu 22.001 s on 4 threads; alloced 123 MB
-
-The information in this report is:
-
-.. describe:: "Verilator ..."
-
-   Program version.
-
-.. describe:: "End at simtime 123 ns"
-
-   Verilog $time at which the model finished or stopped.
-
-.. describe:: "walltime 1234.001 s"
-
-   Real elapsed wall time in seconds.
-
-.. describe:: "speed 123.1 ns/s"
-
-   Simulated time (if non-zero) divided by wall time. e.g. `123 ns/s` means
-   123 simulated nanoseconds took 1 second of wall time; for a model with
-   only a 1 GHz clock that would be equivalent to 123.1 cycles per
-   second. The units are automatically selected to give a number between 1
-   and 1000.  The wall time includes initialization, initial and final
-   process blocks, so indicates a slower speed than if the model had a
-   longer runtime.
-
-.. describe:: "cpu 22 s"
-
-   CPU time used total across all CPU threads in seconds.
-
-.. describe:: "4 threads"
-
-   Number of simultaneous threads used.
-
-.. describe:: "alloced 123 MB"
-
-   Total memory used during simulation in megabytes.
-
-
 .. _Benchmarking & Optimization:

 Benchmarking & Optimization
@@ -304,9 +304,9 @@ GNU Make
 ========

 Verilator defaults to creating GNU Make makefiles for the model.  Verilator
-will call make automatically when the :vlopt:`--build` option is used.
+will call make automatically when the :vlopt:'--build' option is used.

-If calling Verilator from a makefile, the :vlopt:`--MMD` option will create
+If calling Verilator from a makefile, the :vlopt:'-MMD' option will create
 a dependency file, allowing Make to only run Verilator if input Verilog
 files change.

@@ -498,78 +498,3 @@ The search paths can be configured by setting some variables:

   Sets the installation prefix of an installed SystemC library. (Same as
   SYSTEMC_ROOT).
-
-
-.. _Verilation Summary Report:
-
-Verilation Summary Report
-=========================
-
-When Verilator generates code, unless :vlopt:`--quiet-stats` is used, it
-will print a report to stdout summarizing the build. For example:
-
-.. code-block::
-
-    - V e r i l a t i o n   R e p o r t: Verilator ....
-    - Verilator: Built from 354 MB sources in 247 modules,
-        into 74 MB in 89 C++ files needing 0.192 MB
-    - Verilator: Walltime 26.580 s (elab=2.096, cvt=18.268,
-        bld=2.100); cpu 26.548 s on 1 threads; alloced 2894.672 MB
-
-The information in this report is:
-
-.. describe:: "Verilator ..."
-
-   Program version.
-
-.. describe:: "234 MB sources"
-
-   Characters of post-preprocessed text in all input
-   Verilog and Verilator Control files in megabytes.
-
-.. describe:: "247 modules"
-
-   Number of interfaces/modules/classes/packages in design before
-   elaboration.
-
-.. describe:: "into 74 MB"
-
-   Characters of output C++ code, including comments in megabytes.
-
-.. describe:: "89 C++ files"
-
-   Number of .cpp files created.
-
-.. describe:: "needing 192MB"
-
-   Verilation-time minimum-bound estimate of memory needed to run model in
-   megabytes. (Expect to need significantly more.)
-
-.. describe:: "Walltime 26.580 s"
-
-   Real elapsed wall time for Verilation and build.
-
-.. describe:: "elab=2.096"
-
-   Wall time to read in files and complete elaboration.
-
-.. describe:: "cvt=18.268"
-
-   Wall time for Verilator to process and write output.
-
-.. describe:: "bld=2.1"
-
-   Wall time to compile gcc/clang (if using :vlopt:`--build`).
-
-.. describe:: "cpu 22.548 s"
-
-   CPU time used, total across all CPU threads.
-
-.. describe:: "4 threads"
-
-   Number of simultaneous threads used.
-
-.. describe:: "alloced 123 MB"
-
-   Total memory used during build by Verilator executable (excludes
-   :vlopt:`--build` compiler's usage) in megabytes.
@@ -161,8 +161,8 @@ List Of Warnings
 .. option:: BADSTDPRAGMA

   An error that a pragma is badly formed, for pragmas defined by IEEE
-   1800-2023.  For example, an empty pragma line, or an incorrectly used
-   'pragma protect'.  Third-party pragmas not defined by IEEE 1800-2023 are
+   1800-2017.  For example, an empty pragma line, or an incorrectly used
+   'pragma protect'.  Third-party pragmas not defined by IEEE 1800-2017 are
   ignored.


@@ -210,35 +210,22 @@ List Of Warnings

 .. option:: BLKLOOPINIT

-   Indicates certain constructs where non-blocking assignments to unpacked
-   arrays (memories) are not supported inside loops. These typically appear in
-   initialization/reset code:
+   .. TODO better example
+
+   This indicates that the initialization of an array needs to use
+   non-delayed assignments.  This is done in the interest of speed; if
+   delayed assignments were used, the simulator would have to copy large
+   arrays every cycle.  (In smaller loops, loop unrolling allows the
+   delayed assignment to work, though it's a bit slower than a non-delayed
+   assignment.)  Here's an example

   .. code-block:: sv

         always @(posedge clk)
            if (~reset_l)
                for (i=0; i<`ARRAY_SIZE; i++)
-                    array[i] <= 0;  // Non-blocking assignment inside loop
-            else
-                array[address] <= data;
+                    array[i] = 0;  // Non-delayed for verilator

-   While this is supported in typical synthesizeable code (including the
-   example above), some complicated cases are not supported. Namely:
-
-   1. If the above loop is inside a suspendable process or fork statement.
-
-   2. If the variable is also the target of a '<=' non-blocking assignment
-   in a suspendable process or fork statement (in addition to a synthesizable
-   loop).
-
-   3. If the element type of the array is a compound type.
-
-   4. In versions before 5.026, any delayed assignment to an array.
-
-   It might slightly improve run-time performance if you change the
-   non-blocking assignment inside the loop into a blocking assignment
-   (that is: use '=' instead of '<='), if possible.

   This message is only seen on large or complicated loops because
   Verilator generally unrolls small loops.  You may want to try increasing
@@ -296,7 +283,7 @@ List Of Warnings
   Unique case statements that select on an enumerated variable, where all
   of the enumerated values are covered by case items, are considered
   complete even if the case statement does not cover illegal
-   non-enumerated values (IEEE 1800-2023 12.5.3).  To check that illegal
+   non-enumerated values (IEEE 1800-2017 12.5.3).  To check that illegal
   values are not hit, use :vlopt:`--assert`.

   Ignoring this warning will only suppress the lint check; it will
@@ -419,9 +406,9 @@ List Of Warnings

 .. option:: CONSTRAINTIGN

-   Warns that Verilator does not support certain forms of
-   :code:`constraint`, :code:`constraint_mode`, or :code:`rand_mode`, and
-   the construct was are ignored.
+   Warns that Verilator does not support :code:`constraint`,
+   :code:`constraint_mode`, or :code:`rand_mode`, and the construct was are
+   ignored.

   Ignoring this warning may make Verilator randomize() simulations differ
   from other simulators.
@@ -492,7 +479,7 @@ List Of Warnings

   .. code-block::

-         %Warning-DEFPARAM: example.v:5:15: defparam is deprecated (IEEE 1800-2023 C.4.1)
+         %Warning-DEFPARAM: example.v:5:15: defparam is deprecated (IEEE 1800-2017 C.4.1)
                                          : ... Suggest use instantiation with #(.MY_PARAM(...etc...))

   To repair use :code:`#(.PARAMETER(...))` syntax. Repaired Example:
@@ -720,7 +707,7 @@ List Of Warnings

   .. code-block::

-         %Warning-GENUNNAMED: example.v:2:9: Unnamed generate block (IEEE 1800-2023 27.6)
+         %Warning-GENUNNAMED: example.v:2:9: Unnamed generate block (IEEE 1800-2017 27.6)

   To fix this assign a label (often with the naming convention prefix of
   :code:`gen_` or :code:`g_`), for example:
@@ -776,7 +763,7 @@ List Of Warnings

   .. code-block::

-         %Warning-IGNOREDRETURN: example.v:5:9: Ignoring return value of non-void function (IEEE 1800-2023 13.4.1)
+         %Warning-IGNOREDRETURN: example.v:5:9: Ignoring return value of non-void function (IEEE 1800-2017 13.4.1)

   The portable way to suppress this warning (in SystemVerilog) is to use a
   void cast, for example:
@@ -1217,14 +1204,6 @@ List Of Warnings
   :vlopt:`--no-timing` option.


-.. option:: NONSTD
-
-   Warns when a non-standard language feature is used that has a standard
-   equivalent, which might behave differently in corner cases. For example
-   :code:`$psprintf` system function is replaced by its standard equivalent
-   :code:`$sformatf`.
-
-
 .. option:: NULLPORT

   Warns that a null port was detected in the module definition port
@@ -1264,7 +1243,7 @@ List Of Warnings

 .. option:: PINMISSING

-   .. TODO better example (frequent)
+   .. TODO better example

   Warns that a module has a pin that is not mentioned in an instance.  If
   a pin is not missing it should still be specified on the instance
@@ -1273,22 +1252,6 @@ List Of Warnings
   Ignoring this warning will only suppress the lint check; it will
   simulate correctly.

-   Faulty example:
-
-   .. include:: ../../docs/gen/ex_PKGNODECL_faulty.rst
-
-   Results in:
-
-   .. include:: ../../docs/gen/ex_PKGNODECL_msg.rst
-
-   Repaired example:
-
-   .. code-block:: sv
-      :emphasize-lines: 2
-
-         sub sub (
-                  .port());
-
   Other tools with similar warnings: Icarus Verilog's portbind, "warning:
   Instantiating module ... with dangling input port (...)". Slang's
   unconnected-port, "port '...' has no connection".
@@ -1320,7 +1283,7 @@ List Of Warnings
         generate
            if (A==0) begin
               b b_inst1 (.x(1'b0));  //<--- error nonexistent port
-               b #(.PX(1'b0)) b_inst2 ();  //<--- error nonexistent parameter
+               b #(.PX(1'b0)) b_inst2 (); //<--- error nonexistent parameter
            end
          endgenerate
       endmodule
@@ -1362,47 +1325,11 @@ List Of Warnings

 .. option:: PKGNODECL

-   An error that a package/class appears to have been referenced that has
-   not yet been declared.  According to IEEE 1800-2023 26.3, all packages
-   must be declared before being used.
+   .. TODO better example

-   Faulty example:
-
-   .. include:: ../../docs/gen/ex_PKGNODECL_faulty.rst
-
-   Results in:
-
-   .. include:: ../../docs/gen/ex_PKGNODECL_msg.rst
-
-   Often the package is declared in its own header file.  In this case add
-   an include of that package header file to the referencing file.  (And
-   make sure you have header guards in the package's header file to prevent
-   multiple declarations of the package.)
-
-
-.. option:: PREPROCZERO
-
-   Warns that a preprocessor \`ifdef/\`ifndef expression (added in IEEE
-   1800-2023) evaluates a define value which has a value of :code:`0`.
-   This will evaluate in the expression as :code:`1` because the define has
-   a definition, unlike in the C preprocessor, which evaluates using the
-   define's value (of :code:`1`).
-
-   Referring to a define with an empty value does not give this warning, as
-   in C, the preprocessor will give an error on a preprocessor expression
-   of a define that is empty.
-
-   .. code-block:: sv
-      :linenos:
-      :emphasize-lines: 2
-
-       `define ZERO 0
-       `ifdef (ZERO || ZERO)  //<--- warning PREPROCZERO
-        `error This_will_error_which_might_be_not_the_intent
-       `endif
-
-   The portable way to suppress this warning is to use a define value other
-   than zero, when it is to be used in a preprocessor expression.
+   An error that a package/class appears to have been referenced that has not
+   yet been declared.  According to IEEE 1800-2017 26.3, all packages must
+   be declared before being used.


 .. option:: PROCASSWIRE
@@ -1780,7 +1707,7 @@ List Of Warnings

   .. code-block::

-         %Warning-TIMESCALEMOD: example.v:1:8: Timescale missing on this module as other modules have it (IEEE 1800-2023 3.14.2.3)
+         %Warning-TIMESCALEMOD: example.v:1:8: Timescale missing on this module as other modules have it (IEEE 1800-2017 3.14.2.3)

   Recommend using :vlopt:`--timescale` argument, or in front of all
   modules use:
@@ -1924,8 +1851,7 @@ List Of Warnings

 .. option:: UNPACKED

-   Warns that unpacked structs and unions are not supported because
-   :vlopt:`--structs-packed` was used, or by up through version 5.004.
+   Warns that unpacked structs and unions are not supported.

   Ignoring this warning will make Verilator treat the structure as packed,
   which may make Verilator simulations differ from other simulators. This
@@ -1976,16 +1902,14 @@ List Of Warnings

   .. TODO better example

-   Warns that the specified genvar is never used/consumed. See similar
-   :option:`UNUSEDSIGNAL`.
+   Warns that the specified genvar is never used/consumed.


 .. option:: UNUSEDPARAM

   .. TODO better example

-   Warns that the specified parameter is never used/consumed. See similar
-   :option:`UNUSEDSIGNAL`.
+   Warns that the specified parameter is never used/consumed.


 .. option:: UNUSEDSIGNAL
@@ -2025,7 +1949,7 @@ List Of Warnings
 .. option:: USERERROR

   A SystemVerilog elaboration-time assertion error was executed.
-   IEEE 1800-2023 20.11 requires this error.
+   IEEE 1800-2017 20.11 requires this error.

   Faulty example:

@@ -2041,7 +1965,7 @@ List Of Warnings
 .. option:: USERFATAL

   A SystemVerilog elaboration-time assertion fatal was executed.
-   IEEE 1800-2023 20.11 requires this error.
+   IEEE 1800-2017 20.11 requires this error.

   Faulty example:

@@ -2057,7 +1981,7 @@ List Of Warnings
 .. option:: USERINFO

   A SystemVerilog elaboration-time assertion print was executed.  This is
-   not an error or warning, and IEEE 1800-2023 20.11 requires this
+   not an error or warning, and IEEE 1800-2017 20.11 requires this
   behavior.

   Example:
@@ -2072,7 +1996,7 @@ List Of Warnings
 .. option:: USERWARN

   A SystemVerilog elaboration-time assertion warning was executed.
-   IEEE 1800-2023 20.11 requires this warning.
+   IEEE 1800-2017 20.11 requires this warning.

   Faulty example:

@@ -2108,6 +2032,10 @@ List Of Warnings

 .. option:: WAITCONST

+   .. code-block:: sv
+
+         wait(1);  // Blocks forever
+
   Warns that a `wait` statement awaits a constant condition, which means it
   either blocks forever or never blocks.

@@ -2115,12 +2043,6 @@ List Of Warnings
   something that elaborates to zero), does not warn, as it is presumed the
   code is making the intent clear.

-   Faulty example:
-
-   .. code-block:: sv
-
-         wait(1);  // Blocks forever
-

 .. option:: WIDTH

@@ -2157,7 +2079,7 @@ List Of Warnings

   .. include:: ../../docs/gen/ex_WIDTHEXPAND_1_faulty.rst

-   Results in a :option:`WIDTHEXPAND` warning:
+   Results in a WIDTHEXPAND warning:

   .. include:: ../../docs/gen/ex_WIDTHEXPAND_1_msg.rst

@@ -2168,18 +2090,15 @@ List Of Warnings

 .. option:: WIDTHTRUNC

-   A more granular :option:`WIDTH` warning, for when a value is
-   truncated. See :option:`WIDTH`.
+   A more granular WIDTH warning, for when a value is truncated.

 .. option:: WIDTHEXPAND

-   A more granular :option:`WIDTH` warning, for when a value is zero
-   expanded. See :option:`WIDTH`.
+   A more granular WIDTH warning, for when a value is zero expanded.

 .. option:: WIDTHXZEXPAND

-   A more granular :option:`WIDTH` warning, for when a value is X/Z
-   expanded. See :option:`WIDTH`.
+   A more granular WIDTH warning, for when a value is X/Z expanded.

 .. option:: WIDTHCONCAT

@@ -2216,7 +2135,7 @@ List Of Warnings
 .. option:: ZEROREPL

   Warns that zero is used as the replication value in the replication
-   operator. This is specified as an error by IEEE 1800-2023 11.4.12.1.
+   operator. This is specified as an error by IEEE 1800-2017 11.4.12.1.

   Faulty example:

@@ -2228,7 +2147,7 @@ List Of Warnings
            #(parameter int MY_PARAM = 0);
           reg [7:0] data;
           always @* begin
-             data = {MY_PARAM{1'b1}};  //<--- Warning
+             data = {MY_PARAM{1'b1}}; //<--- WARNING
           end
         endmodule

@@ -2236,7 +2155,7 @@ List Of Warnings

   .. code-block::

-       %Error-ZEROREPL: test.v:5:22: Replication value of 0 is only legal under a concatenation (IEEE 1800-2023 11.4.12.1)
+       %Error-ZEROREPL: test.v:5:22: Replication value of 0 is only legal under a concatenation (IEEE 1800-2017 11.4.12.1)

   Note that in some cases, this warning may be false, when a condition
   upstream or downstream of the access means the zero replication will
@@ -2249,7 +2168,7 @@ List Of Warnings
      :emphasize-lines: 2

         module dut
-            #(parameter int MY_PARAM = 1);  //<--- REPAIRED
+            #(parameter int MY_PARAM = 1); //<--- REPAIRED
           reg [7:0] data;
           always @* begin
             data = {MY_PARAM{1'b1}};
@@ -224,7 +224,7 @@ Scheduling
 ----------

 Verilator implements the Active and NBA regions of the SystemVerilog scheduling
-model as described in IEEE 1800-2023 chapter 4, and in particular sections
+model as described in IEEE 1800-2017 chapter 4, and in particular sections
 4.5 and Figure 4.1. The static (Verilation time) scheduling of SystemVerilog
 processes is performed by code in the ``V3Sched`` namespace. The single
 entry point to the scheduling algorithm is ``V3Sched::schedule``. Some
@@ -312,7 +312,7 @@ Scheduling of clocked and combinational logic
 For performance, clocked and combinational logic needs to be ordered.
 Conceptually this minimizes the iterations through the evaluation loop
 presented in the reference algorithm in the SystemVerilog standard (IEEE
-1800-2023 section 4.5), by evaluating logic constructs in data-flow order.
+1800-2017 section 4.5), by evaluating logic constructs in data-flow order.
 Without going into a lot of detail here, accept that well thought out ordering
 is crucial to good simulation performance, and also enables further
 optimizations later on.
@@ -407,7 +407,7 @@ triggered due to a combinational signal change from the previous evaluation
 pass, and a combinational loop settling due to hybrid logic, if the clocked
 logic reads the not yet settled combinationally driven signal. Such a race
 is indeed possible, but our evaluation is consistent with the SystemVerilog
-scheduling semantics (IEEE 1800-2023 chapter 4), and therefore any program
+scheduling semantics (IEEE 1800-2017 chapter 4), and therefore any program
 that exhibits such a race has non-deterministic behavior according to the
 SystemVerilog semantics, so we accept this.

@@ -1031,91 +1031,6 @@ the evaluation process records a bitmask of variables that might have
 changed; if clear, checking those signals for changes may be skipped.


-Constrained randomization
-------------------------
-
-Because general constrained randomization is a co-NP-hard problem, not all
-cases are implemented in Verilator, and an external specialized SMT solver is
-used for any non-obvious ones.
-
-The ``randomize()`` method spawns an SMT solver in a sub-process. Then the
-solver gets a setup query, then the definition of variables, then all the
-constraints (SMT assertions) about the variables. Since the solver has no
-information about the class' PRNG state, if the problem is satisfiable,
-the solution space is further constrained by adding extra random constraints,
-and querying the values satisfying the problem statement.
-The constraint is currently constructed as fixing a simple xor of randomly
-chosen bits of the variables being randomized.
-
-The runtime classes used for handling the randomization are  defined in
-``verilated_random.h`` and ``verilated_random.cpp``.
-
-
-``VlSubprocess``
-~~~~~~~~~~~~~~~~
-
-Subprocess handle, responsible for keeping track of the resources like child
-PID, read and write file descriptors, and presenting them as a C++ iostream.
-
-
-``VlRandomizer``
-~~~~~~~~~~~~~~~~
-
-Randomizer class, responsible for keeping track of variables and constraints,
-and communicating with the solver subprocess.
-
-The solver gets the constraints in `SMT-LIB2
-<https://smtlib.cs.uiowa.edu/>`__ textual format in the following syntax:
-
-::
-
-    (set-info :smt-lib-version 2.0)
-    (set-option :produce-models true)
-    (set-logic QF_BV)
-
-    (declare-fun v () (_ BitVec 16))
-    (declare-fun w () (_ BitVec 64))
-    (declare-fun x () (_ BitVec 48))
-    (declare-fun z () (_ BitVec 24))
-    (declare-fun t () (_ BitVec 23))
-    (assert (or (= v #x0003) (= v #x0008)))
-    (assert (= w #x0000000000000009))
-    (assert (or (or (= x #x000000000001) (= x #x000000000002)) (or (= x #x000000000004) (= x #x000000000009))))
-    (assert (bvult ((_ zero_extend 8) z) #x00000015))
-    (assert (bvugt ((_ zero_extend 8) z) #x0000000d))
-
-    (check-sat)
-
-The solver responds with either ``sat`` or ``unsat``. Then the initial solution
-is queried with:
-
-::
-
-    (get-value (v w x z t ))
-
-The solver then responds with e.g.:
-
-::
-
-    ((v #x0008)
-     (w #x0000000000000005)
-     (x #x000000000002)
-     (z #x000010)
-     (t #b00000000000000000000000))
-
-And then a follow-up query (or a series thereof) is asked, and the solver gets
-reset, so that it can be reused by subsequent randomization attempts:
-
-::
-
-    (assert (= (bvxor (bvxor <...> (bvxor ((_ extract 21 21) z) ((_ extract 39 39) x)) ((_ extract 5 5) w)) <...> ((_ extract 10 10) w)) #b0))
-    (check-sat)
-    (get-value)
-    ...
-    (reset)
-
-
-
 Coding Conventions
 ==================

@@ -1786,7 +1701,7 @@ Similarly, the ``NETLIST`` has a list of modules referred to by its

 ``.tree.json``` is an alternative dump format to ``.tree`` that is meant for
 programmatic processing (e.g. with `astsee <https://github.com/antmicro/astsee>`_).
-To enable this dump format, use :vlopt:`--dump-tree-json` or :vlopt:`--json-only`.
+To enable this dump format, use :vlopt:`--json-only`.

 Structure:
 ::
@@ -1828,8 +1743,8 @@ Structure:

 .tree.meta.json Output
 ----------------
-.tree.meta.json contains metadata that is common across the whole AST tree
-(in case of --dump-tree-json, multiple trees share one meta file).
+
+.tree.meta.json contains metadata that is common across the whole AST tree.

 Besides de-duplication of data shared between multiple stages, .meta.json enables offloading
 unstable data (that can vary from machine-to-machine or run-to-run) from main .tree.json.
@@ -1839,11 +1754,11 @@ This offloading allows, for example, to use byte-to-byte comparisons of AST dump

  {"files": {
    /* Map id to filename, and other metadata */
-    "d": {"filename":"/home/ant/tmp/verilator/include/verilated_std.sv", "realpath":"/home/ant/tmp/verilator/include/verilated_std.sv", "language":"1800-2023"},
-    "a": {"filename":"<built-in>", "realpath":"<built-in>", "language":"1800-2023"},
-    "b": {"filename":"<command-line>", "realpath":"<command-line>", "language":"1800-2023"},
-    "c": {"filename":"input.vc", "realpath":"/home/ant/tmp/verilator/test_regress/input.vc", "language":"1800-2023"},
-    "e": {"filename":"t/t_EXAMPLE.v", "realpath":"/home/ant/tmp/verilator/test_regress/t/t_EXAMPLE.v", "language":"1800-2023"}
+    "d": {"filename":"/home/ant/tmp/verilator/include/verilated_std.sv", "realpath":"/home/ant/tmp/verilator/include/verilated_std.sv", "language":"1800-2017"},
+    "a": {"filename":"<built-in>", "realpath":"<built-in>", "language":"1800-2017"},
+    "b": {"filename":"<command-line>", "realpath":"<command-line>", "language":"1800-2017"},
+    "c": {"filename":"input.vc", "realpath":"/home/ant/tmp/verilator/test_regress/input.vc", "language":"1800-2017"},
+    "e": {"filename":"t/t_EXAMPLE.v", "realpath":"/home/ant/tmp/verilator/test_regress/t/t_EXAMPLE.v", "language":"1800-2017"}
   },"pointers": {
    /* Map id to real address */
    "(AG)": "0x562997289180",
@@ -1931,20 +1846,6 @@ To print a node:
   pnt nodep
   # or: call dumpTreeGdb(nodep)  # aliased to "pnt" in src/.gdbinit

-``src/.gdbinit`` and ``src/.gdbinit.py`` define handy utilities for working with
-JSON AST dumps. For example:
-
-* ``jstash nodep`` - Perform a JSON AST dump and save it into GDB value history (e.g. ``$1``)
-* ``jtree nodep`` - Perform a JSON AST dump and pretty print it using ``astsee_verilator``.
-* ``jtree $1`` - Pretty print a dump that was previously saved by ``jstash``.
-* ``jtree nodep -d '.file, .timeunit'`` - Perform a JSON AST dump, filter out some fields and pretty print it.
-* ``jtree 0x55555613dca0`` - Pretty print using address literal (rather than actual pointer).
-* ``jtree $1 nodep`` - Diff ``nodep`` against an older dump.
-
-A detailed description of ``jstash`` and ``jtree`` can be displayed using ``gdb``'s ``help`` command.
-
-These commands require `astsee <https://github.com/antmicro/astsee>`_ to be installed.
-
 When GDB halts, it is useful to understand that the backtrace will commonly
 show the iterator functions between each invocation of ``visit`` in the
 backtrace. You will typically see a frame sequence something like:
@@ -2006,21 +1907,21 @@ Verilator ideally would support all of IEEE, and has the goal to get close
 to full support. However the following IEEE sections and features are not
 anticipated to be ever implemented for the reasons indicated.

-IEEE 1800-2023 3.3 modules within modules
+IEEE 1800-2017 3.3 modules within modules
    Little/no tool support, and arguably not a good practice.
-IEEE 1800-2023 6.12 "shortreal"
+IEEE 1800-2017 6.12 "shortreal"
    Little/no tool support, and easily promoted to real.
-IEEE 1800-2023 11.11 Min, typ, max
+IEEE 1800-2017 11.11 Min, typ, max
    No SDF support, so will always use typical.
-IEEE 1800-2023 20.16 Stochastic analysis
+IEEE 1800-2017 20.16 Stochastic analysis
    Little industry use.
-IEEE 1800-2023 20.17 PLA modeling
+IEEE 1800-2017 20.17 PLA modeling
    Little industry use and outdated technology.
-IEEE 1800-2023 31 Timing checks
+IEEE 1800-2017 31 Timing checks
    No longer relevant with static timing analysis tools.
-IEEE 1800-2023 32 SDF annotation
+IEEE 1800-2017 32 SDF annotation
    No longer relevant with static timing analysis tools.
-IEEE 1800-2023 33 Config
+IEEE 1800-2017 33 Config
    Little industry use.


@@ -2061,10 +1962,6 @@ driver.pl Non-Scenario Arguments
  files with dumping level 3, which dumps the standard critical stages.
  For details on the format see `.tree Output`.

--fail-max <numtests>
-  Set the number of failing tests, after which the driver will stop running
-  additional tests.  Defaults to 20, 0 disables.
-
 --gdb
  Same as ``verilator --gdb``: Run Verilator under the debugger.

@@ -2210,10 +2107,6 @@ VERILATOR_ROOT
  Standard path to Verilator distribution root; see primary Verilator
  documentation.

-VERILATOR_SOLVER
-  SMT solver command for constrained randomization; see primary Verilator
-  documentation.
-
 VERILATOR_TESTS_SITE
  Used with ``--site``, a colon-separated list of directories with tests to
  be added to testlist.
@@ -40,7 +40,6 @@ Brej
 Briquet
 Brownlee
 Buckenmaier
-Burghoorn
 Bybell
 CLang
 CMake
@@ -72,7 +71,6 @@ Deadman
 Debacker
 Deepa
 Defparams
-Delm
 Denio
 Deprecations
 Deroo
@@ -132,7 +130,6 @@ Gernot
 Gerst
 Gielda
 Gigerl
-Gijs
 Gileadi
 Giri
 Gisselquist
@@ -149,7 +146,6 @@ Grulfen
 Gu
 Gunter
 Guo
-Hameed
 Hao
 Haojin
 Harboe
@@ -166,7 +162,6 @@ Homebrew
 Hornung
 Hossell
 Hsu
-Huggett
 Hutt
 Hyperthreading
 Ibrahim
@@ -189,7 +184,6 @@ Jiaxun
 Jiuyang
 Joannou
 Joly
-Josse
 Jullien
 Junji
 Junyi
@@ -379,7 +373,6 @@ Srini
 Srinivasan
 Stamness
 Stephane
-Sterin
 Stoddard
 Stroebel
 Strouble
@@ -445,7 +438,6 @@ Verilog
 Vighnesh
 Viktor
 Vilp
-Vlip
 Vm
 Vukobratovic
 Wai
@@ -462,7 +454,6 @@ Wojciech
 Wolfel
 Wouters
 Wpedantic
-Wunused
 Wwarn
 XSim
 Xcelium
@@ -470,7 +461,6 @@ Xiaoliang
 Xiaoyi
 Xuan
 Xuanqi
-Yao
 Yazdanbakhsh
 Yernagula
 Yi
@@ -499,7 +489,6 @@ architected
 args
 arrarys
 assertOn
-assertcontrol
 astgen
 async
 atClone
@@ -592,7 +581,6 @@ defname
 defparam
 demangling
 dep
-deparametrized
 der
 dereference
 desassign
@@ -651,7 +639,6 @@ envvar
 eof
 errae
 erroring
-esynr
 et
 eval
 evals
@@ -683,7 +670,6 @@ foreach
 fprintf
 fprofile
 fread
-freloop
 frewind
 fs
 fscanf
@@ -705,7 +691,6 @@ genvar
 genvars
 getenv
 getline
-getter
 ggdb
 glibc
 gmake
@@ -719,7 +704,6 @@ hh
 hier
 hierCMakeArgs
 hierMkArgs
-hierParameters
 hierVer
 hx
 hyperthreading
@@ -851,8 +835,6 @@ parallelized
 param
 parameterization
 parameterized
-parameterized
-parameterless
 params
 parens
 pawel
@@ -896,9 +878,7 @@ profcfunc
 profiler
 prototyptes
 ps
-psprintf
 pthread
-pthreads
 ptr
 pulldown
 pulldowns
@@ -981,20 +961,13 @@ submakes
 submodule
 submodules
 substring
-superclass
-suspendable
-suspendables
 sv
 svBitVal
 svBitVecVal
 svGet
-svGetTime
-svGetTimePrecision
 svLogicVal
 svdpi
-svgGetTimeUnit
 swrite
-synthesizeable
 sys
 systemc
 tenghtt
@@ -1013,7 +986,6 @@ toolchain
 topcell
 toplevel
 toupper
-traceCapable
 traceEverOn
 tran
 treei
@@ -1078,7 +1050,6 @@ vluint
 vpi
 vpiConstType
 vpiDefName
-vpiInertialDelay
 vpiInstance
 vpiLeftRange
 vpiModule
@@ -1112,4 +1083,3 @@ zdave
 Øyvind
 Алексеевич
 Исаак
-
@@ -30,7 +30,6 @@ endif()

 # Create a new executable target that will contain all your sources
 add_executable(example ../make_hello_c/sim_main.cpp)
-target_compile_features(example PUBLIC cxx_std_14)

 # Add the Verilated circuit to the target
 verilate(example
@@ -31,7 +31,7 @@ endif
 ifeq ($(shell which cmake),)
 TARGET := nocmake
 else
-CMAKE_VERSION := $(shell cmake --version | grep -o '[0-9][.0-9]\+')
+CMAKE_VERSION := $(shell cmake --version | grep -Po '(\d[\.\d]+)')
 CMAKE_MAJOR := $(shell echo $(CMAKE_VERSION) | cut -f1 -d.)
 CMAKE_MINOR := $(shell echo $(CMAKE_VERSION) | cut -f2 -d.)
 CMAKE_GT_3_8 := $(shell [ $(CMAKE_MAJOR) -gt 3 -o \( $(CMAKE_MAJOR) -eq 3 -a $(CMAKE_MINOR) -ge 8 \) ] && echo true)
@@ -37,7 +37,6 @@ find_package(SystemCLanguage QUIET)

 # Create a new executable target that will contain all your sources
 add_executable(example ../make_hello_sc/sc_main.cpp)
-target_compile_features(example PUBLIC cxx_std_14)

 set_property(
  TARGET example
@@ -31,7 +31,7 @@ endif
 ifeq ($(shell which cmake),)
 	TARGET := nocmake
 else
-CMAKE_VERSION := $(shell cmake --version | grep -o '[0-9][.0-9]\+')
+CMAKE_VERSION := $(shell cmake --version | grep -Po '(\d[\.\d]+)')
 CMAKE_MAJOR := $(shell echo $(CMAKE_VERSION) | cut -f1 -d.)
 CMAKE_MINOR := $(shell echo $(CMAKE_VERSION) | cut -f2 -d.)
 CMAKE_GT_3_8 := $(shell [ $(CMAKE_MAJOR) -gt 3 -o \( $(CMAKE_MAJOR) -eq 3 -a $(CMAKE_MINOR) -ge 8 \) ] && echo true)
@@ -30,12 +30,9 @@ endif()

 # Create the main executable target
 add_executable(example ../make_protect_lib/sim_main.cpp)
-target_compile_features(example PUBLIC cxx_std_14)

 # Create a secret library
 add_library(verilated_secret STATIC) # or SHARED for a shared library
-target_compile_features(verilated_secret PUBLIC cxx_std_14)
-
 target_link_libraries(example PRIVATE verilated_secret)
 # To create both libraries on CMake >= 3.12 replace the above 2 lines with the following:
 # add_library(verilated_secret OBJECT)
@@ -31,7 +31,7 @@ endif
 ifeq ($(shell which cmake),)
 TARGET := nocmake
 else
-CMAKE_VERSION := $(shell cmake --version | grep -o '[0-9][.0-9]\+')
+CMAKE_VERSION := $(shell cmake --version | grep -Po '(\d[\.\d]+)')
 CMAKE_MAJOR := $(shell echo $(CMAKE_VERSION) | cut -f1 -d.)
 CMAKE_MINOR := $(shell echo $(CMAKE_VERSION) | cut -f2 -d.)
 CMAKE_GT_3_8 := $(shell [ $(CMAKE_MAJOR) -gt 3 -o \( $(CMAKE_MAJOR) -eq 3 -a $(CMAKE_MINOR) -ge 8 \) ] && echo true)
@@ -30,7 +30,6 @@ endif()

 # Create a new executable target that will contain all your sources
 add_executable(example ../make_tracing_c/sim_main.cpp)
-target_compile_features(example PUBLIC cxx_std_14)

 # Add the Verilated circuit to the target
 verilate(example COVERAGE TRACE
@@ -31,7 +31,7 @@ endif
 ifeq ($(shell which cmake),)
 TARGET := nocmake
 else
-CMAKE_VERSION := $(shell cmake --version | grep -o '[0-9][.0-9]\+')
+CMAKE_VERSION := $(shell cmake --version | grep -Po '(\d[\.\d]+)')
 CMAKE_MAJOR := $(shell echo $(CMAKE_VERSION) | cut -f1 -d.)
 CMAKE_MINOR := $(shell echo $(CMAKE_VERSION) | cut -f2 -d.)
 CMAKE_GT_3_8 := $(shell [ $(CMAKE_MAJOR) -gt 3 -o \( $(CMAKE_MAJOR) -eq 3 -a $(CMAKE_MINOR) -ge 8 \) ] && echo true)
@@ -38,7 +38,6 @@ find_package(SystemCLanguage QUIET)

 # Create a new executable target that will contain all your sources
 add_executable(example ../make_tracing_sc/sc_main.cpp)
-target_compile_features(example PUBLIC cxx_std_14)

 set_property(
  TARGET example
@@ -31,7 +31,7 @@ endif
 ifeq ($(shell which cmake),)
 	TARGET := nocmake
 else
-CMAKE_VERSION := $(shell cmake --version | grep -o '[0-9][.0-9]\+')
+CMAKE_VERSION := $(shell cmake --version | grep -Po '(\d[\.\d]+)')
 CMAKE_MAJOR := $(shell echo $(CMAKE_VERSION) | cut -f1 -d.)
 CMAKE_MINOR := $(shell echo $(CMAKE_VERSION) | cut -f2 -d.)
 CMAKE_GT_3_8 := $(shell [ $(CMAKE_MAJOR) -gt 3 -o \( $(CMAKE_MAJOR) -eq 3 -a $(CMAKE_MINOR) -ge 8 \) ] && echo true)
@@ -17,8 +17,7 @@
 #endif

 int main(int argc, char** argv) {
-    (void)argc;
-    (void)argv;
+    if (false && argc && argv) {}

    // Construct context to hold simulation time, etc
    const std::unique_ptr<VerilatedContext> contextp{new VerilatedContext};
@@ -47,12 +46,12 @@ int main(int argc, char** argv) {

    // Simulate until $finish
    while (!contextp->gotFinish()) {
+        contextp->timeInc(1);
        top->clk = ~top->clk & 0x1;
        top->eval();
 #if VM_TRACE
        if (tfp) tfp->dump(contextp->time());
 #endif
-        contextp->timeInc(1);
    }

    // Final model cleanup
@@ -117,9 +117,6 @@ int main(int argc, char** argv) {
    contextp->coveragep()->write("logs/coverage.dat");
 #endif

-    // Final simulation summary
-    contextp->statsPrintSummary();
-
    // Return good completion status
    // Don't use exit() or destructor won't get called
    return 0;
@@ -130,7 +130,6 @@ void **JenkinsIns(void *base_i, const unsigned char *mem, uint32_t length, uint3
 #define FST_HDR_TIMEZERO_SIZE           (8)
 #define FST_GZIO_LEN                    (32768)
 #define FST_HDR_FOURPACK_DUO_SIZE       (4*1024*1024)
-#define FST_ZWRAPPER_HDR_SIZE           (1+8+8)

 #if defined(__APPLE__) && defined(__MACH__)
 #define FST_MACOSX
@@ -348,9 +347,8 @@ return(NULL);

 static void *fstMmap2(size_t __len, int __fd, fst_off_t __off)
 {
-DWORD64 len64 = __len;  /* Must be 64-bit for shift below */
 HANDLE handle = CreateFileMapping((HANDLE)_get_osfhandle(__fd), NULL,
-				  PAGE_READWRITE, (DWORD)(len64 >> 32),
+				  PAGE_READWRITE, (DWORD)(__len >> 32),
 				  (DWORD)__len, NULL);
 if (!handle) { return NULL; }

@@ -1648,11 +1646,7 @@ if(1)
                                {
                                if(vm4ip[2] != prev_alias)
                                        {
-					int32_t  t_i32 = ((int32_t)(prev_alias = vm4ip[2])); /* vm4ip is generic unsigned data */
-					int64_t  t_i64 = (int64_t)t_i32; /* convert to signed */
-					uint64_t t_u64 = (uint64_t)t_i64; /* sign extend through 64b */
-
-					fpos += fstWriterSVarint(f, (int64_t)((t_u64 << 1) | 1)); /* all in this block was: fpos += fstWriterSVarint(f, (((int64_t)((int32_t)(prev_alias = vm4ip[2]))) << 1) | 1); */
+                                        fpos += fstWriterSVarint(f, (((int64_t)((int32_t)(prev_alias = vm4ip[2]))) << 1) | 1);
                                        }
                                        else
                                        {
@@ -4634,14 +4628,9 @@ if(sectype == FST_BL_ZWRAPPER)
                }
 #endif

-        fstReaderFseeko(xc, xc->f, FST_ZWRAPPER_HDR_SIZE, SEEK_SET);
+        fstReaderFseeko(xc, xc->f, 1+8+8, SEEK_SET);
 #ifndef __MINGW32__
        fflush(xc->f);
-#else
-	/* Windows UCRT runtime library reads one byte ahead in the file
-	   even with buffering disabled and does not synchronise the
-	   file position after fseek. */
-	_lseek(fileno(xc->f), FST_ZWRAPPER_HDR_SIZE, SEEK_SET);
 #endif

        zfd = dup(fileno(xc->f));
@@ -6191,9 +6180,7 @@ struct fstReaderContext *xc = (struct fstReaderContext *)ctx;
 fst_off_t blkpos = 0, prev_blkpos;
 uint64_t beg_tim, end_tim, beg_tim2, end_tim2;
 int sectype;
-#ifdef FST_DEBUG
 unsigned int secnum = 0;
-#endif
 uint64_t seclen;
 uint64_t tsec_uclen = 0, tsec_clen = 0;
 uint64_t tsec_nitems;
@@ -6285,9 +6272,7 @@ for(;;)
                }

        blkpos += seclen;
-#ifdef FST_DEBUG
        secnum++;
-#endif
        }

 xc->rvat_beg_tim = beg_tim;
@@ -82,12 +82,6 @@

 #include "verilated_trace.h"

-#ifdef VM_SOLVER_DEFAULT
-#define VL_SOLVER_DEFAULT VM_SOLVER_DEFAULT
-#else
-#define VL_SOLVER_DEFAULT "z3 --in"
-#endif
-
 // Max characters in static char string for VL_VALUE_STRING
 constexpr unsigned VL_VALUE_STRING_MAX_WIDTH = 8192;

@@ -175,12 +169,9 @@ void vl_stop_maybe(const char* filename, int linenum, const char* hier, bool may
    Verilated::threadContextp()->errorCountInc();
    if (maybe
        && Verilated::threadContextp()->errorCount() < Verilated::threadContextp()->errorLimit()) {
-        // Do just once when cross error limit
-        if (Verilated::threadContextp()->errorCount() == 1) {
-            VL_PRINTF(  // Not VL_PRINTF_MT, already on main thread
-                "-Info: %s:%d: %s\n", filename, linenum,
-                "Verilog $stop, ignored due to +verilator+error+limit");
-        }
+        VL_PRINTF(  // Not VL_PRINTF_MT, already on main thread
+            "-Info: %s:%d: %s\n", filename, linenum,
+            "Verilog $stop, ignored due to +verilator+error+limit");
    } else {
        vl_stop(filename, linenum, hier);
    }
@@ -412,8 +403,6 @@ IData VL_RAND_RESET_I(int obits) VL_MT_SAFE {
    data &= VL_MASK_I(obits);
    return data;
 }
-IData VL_RAND_RESET_ASSIGN_I(int obits) VL_MT_SAFE { return VL_RANDOM_I() & VL_MASK_I(obits); }
-
 QData VL_RAND_RESET_Q(int obits) VL_MT_SAFE {
    if (Verilated::threadContextp()->randReset() == 0) return 0;
    QData data = ~0ULL;
@@ -423,19 +412,11 @@ QData VL_RAND_RESET_Q(int obits) VL_MT_SAFE {
    data &= VL_MASK_Q(obits);
    return data;
 }
-
-QData VL_RAND_RESET_ASSIGN_Q(int obits) VL_MT_SAFE { return VL_RANDOM_Q() & VL_MASK_Q(obits); }
-
 WDataOutP VL_RAND_RESET_W(int obits, WDataOutP outwp) VL_MT_SAFE {
    for (int i = 0; i < VL_WORDS_I(obits) - 1; ++i) outwp[i] = VL_RAND_RESET_I(32);
    outwp[VL_WORDS_I(obits) - 1] = VL_RAND_RESET_I(32) & VL_MASK_E(obits);
    return outwp;
 }
-WDataOutP VL_RAND_RESET_ASSIGN_W(int obits, WDataOutP outwp) VL_MT_SAFE {
-    for (int i = 0; i < VL_WORDS_I(obits) - 1; ++i) outwp[i] = VL_RAND_RESET_ASSIGN_I(32);
-    outwp[VL_WORDS_I(obits) - 1] = VL_RAND_RESET_ASSIGN_I(32) & VL_MASK_E(obits);
-    return outwp;
-}
 WDataOutP VL_ZERO_RESET_W(int obits, WDataOutP outwp) VL_MT_SAFE {
    // Not inlined to speed up compilation of slowpath code
    return VL_ZERO_W(obits, outwp);
@@ -621,7 +602,7 @@ WDataOutP VL_POWSS_WWW(int obits, int, int rbits, WDataOutP owp, const WDataInP
        const int words = VL_WORDS_I(obits);
        VL_ZERO_W(obits, owp);
        EData lor = 0;  // 0=all zeros, ~0=all ones, else mix
-        for (int i = 1; i < (words - 1); ++i) lor |= lwp[i];
+        for (int i = 1; i < (words - 1); ++i) { lor |= lwp[i]; }
        lor |= ((lwp[words - 1] == VL_MASK_E(rbits)) ? ~VL_EUL(0) : 0);
        if (lor == 0 && lwp[0] == 0) {  // "X" so return 0
            return owp;
@@ -833,7 +814,7 @@ void _vl_vsformat(std::string& output, const std::string& format, va_list ap) VL
    bool widthSet = false;
    bool left = false;
    size_t width = 0;
-    for (std::string::const_iterator pos = format.cbegin(); pos != format.cend(); ++pos) {
+    for (std::string::const_iterator pos = format.begin(); pos != format.end(); ++pos) {
        if (!inPct && pos[0] == '%') {
            pctit = pos;
            inPct = true;
@@ -902,7 +883,7 @@ void _vl_vsformat(std::string& output, const std::string& format, va_list ap) VL
            case '^': {  // Realtime
                const int lbits = va_arg(ap, int);
                const double d = va_arg(ap, double);
-                (void)lbits;  // UNUSED - always 64
+                if (lbits) {}  // UNUSED - always 64
                if (fmt == '^') {  // Realtime
                    if (!widthSet) width = Verilated::threadContextp()->impp()->timeFormatWidth();
                    const int timeunit = va_arg(ap, int);
@@ -1187,8 +1168,8 @@ static char* _vl_vsss_read_bin(FILE* fp, int& floc, const WDataInP fromp, const
 static void _vl_vsss_setbit(WDataOutP iowp, int obits, int lsb, int nbits, IData ld) VL_MT_SAFE {
    for (; nbits && lsb < obits; nbits--, lsb++, ld >>= 1) VL_ASSIGNBIT_WI(lsb, iowp, ld & 1);
 }
-void _vl_vsss_based(WDataOutP owp, int obits, int baseLog2, const char* strp, size_t posstart,
-                    size_t posend) VL_MT_SAFE {
+static void _vl_vsss_based(WDataOutP owp, int obits, int baseLog2, const char* strp,
+                           size_t posstart, size_t posend) VL_MT_SAFE {
    // Read in base "2^^baseLog2" digits from strp[posstart..posend-1] into owp of size obits.
    VL_ZERO_W(obits, owp);
    int lsb = 0;
@@ -1231,15 +1212,15 @@ IData _vl_vsscanf(FILE* fp,  // If a fscanf
    IData got = 0;
    bool inPct = false;
    bool inIgnore = false;
-    std::string::const_iterator pos = format.cbegin();
-    for (; pos != format.cend() && !_vl_vsss_eof(fp, floc); ++pos) {
+    std::string::const_iterator pos = format.begin();
+    for (; pos != format.end() && !_vl_vsss_eof(fp, floc); ++pos) {
        // VL_DBG_MSGF("_vlscan fmt='"<<pos[0]<<"' floc="<<floc<<" file='"<<_vl_vsss_peek(fp, floc,
        // fromp, fstr)<<"'\n");
        if (!inPct && pos[0] == '%') {
            inPct = true;
            inIgnore = false;
        } else if (!inPct && std::isspace(pos[0])) {  // Format spaces
-            while (std::isspace(pos[1])) ++pos;
+            while (std::isspace(pos[1])) pos++;
            _vl_vsss_skipspace(fp, floc, fromp, fstr);
        } else if (!inPct) {  // Expected Format
            _vl_vsss_skipspace(fp, floc, fromp, fstr);
@@ -1455,8 +1436,8 @@ void _vl_string_to_vint(int obits, void* destp, size_t srclen, const char* srcp)
    char* op = reinterpret_cast<char*>(destp);
    if (srclen > bytes) srclen = bytes;  // Don't overflow destination
    size_t i = 0;
-    for (i = 0; i < srclen; ++i) *op++ = srcp[srclen - 1 - i];
-    for (; i < bytes; ++i) *op++ = 0;
+    for (i = 0; i < srclen; ++i) { *op++ = srcp[srclen - 1 - i]; }
+    for (; i < bytes; ++i) { *op++ = 0; }
 }

 static IData getLine(std::string& str, IData fpi, size_t maxLen) VL_MT_SAFE {
@@ -1671,8 +1652,7 @@ IData VL_SSCANF_INNX(int, const std::string& ld, const std::string& format, int
                     ...) VL_MT_SAFE {
    va_list ap;
    va_start(ap, argc);
-    const IData got
-        = _vl_vsscanf(nullptr, static_cast<int>(ld.length() * 8), nullptr, ld, format, ap);
+    const IData got = _vl_vsscanf(nullptr, ld.length() * 8, nullptr, ld, format, ap);
    va_end(ap);
    return got;
 }
@@ -1765,10 +1745,7 @@ IData VL_SYSTEM_IQ(QData lhs) VL_MT_SAFE {
 IData VL_SYSTEM_IW(int lhswords, const WDataInP lhsp) VL_MT_SAFE {
    char filenamez[VL_VALUE_STRING_MAX_CHARS + 1];
    _vl_vint_to_string(lhswords * VL_EDATASIZE, filenamez, lhsp);
-    return VL_SYSTEM_IN(filenamez);
-}
-IData VL_SYSTEM_IN(const std::string& lhs) VL_MT_SAFE {
-    const int code = std::system(lhs.c_str());  // Yes, std::system() is threadsafe
+    const int code = std::system(filenamez);  // Yes, std::system() is threadsafe
    return code >> 8;  // Want exit status
 }

@@ -1964,7 +1941,7 @@ std::string VL_SUBSTR_N(const std::string& lhs, IData rhs, IData ths) VL_PURE {

 IData VL_ATOI_N(const std::string& str, int base) VL_PURE {
    std::string str_mod = str;
-    // IEEE 1800-2023 6.16.9 says '_' may exist.
+    // IEEE 1800-2017 6.16.9 says '_' may exist.
    str_mod.erase(std::remove(str_mod.begin(), str_mod.end(), '_'), str_mod.end());

    errno = 0;
@@ -2056,26 +2033,22 @@ bool VlReadMem::get(QData& addrr, std::string& valuer) {
    if (VL_UNLIKELY(!m_fp)) return false;
    valuer = "";
    // Prep for reading
-    bool inData = false;
-    bool ignoreToEol = false;
-    bool ignoreToComment = false;
-    bool readingAddress = false;
-    int lastCh = ' ';
+    bool indata = false;
+    bool ignore_to_eol = false;
+    bool ignore_to_cmt = false;
+    bool reading_addr = false;
+    int lastc = ' ';
    // Read the data
    // We process a character at a time, as then we don't need to deal
    // with changing buffer sizes dynamically, etc.
    while (true) {
        int c = std::fgetc(m_fp);
        if (VL_UNLIKELY(c == EOF)) break;
-        const bool chIs4StateBin
-            = c == '0' || c == '1' || c == 'x' || c == 'X' || c == 'z' || c == 'Z';
-        const bool chIs2StateHex = std::isxdigit(c);
-        const bool chIs4StateHex = std::isxdigit(c) || chIs4StateBin;
        // printf("%d: Got '%c' Addr%lx IN%d IgE%d IgC%d\n",
-        //        m_linenum, c, m_addr, inData, ignoreToEol, ignoreToComment);
+        //        m_linenum, c, m_addr, indata, ignore_to_eol, ignore_to_cmt);
        // See if previous data value has completed, and if so return
        if (c == '_') continue;  // Ignore _ e.g. inside a number
-        if (inData && !chIs4StateHex) {
+        if (indata && !std::isxdigit(c) && c != 'x' && c != 'X') {
            // printf("Got data @%lx = %s\n", m_addr, valuer.c_str());
            ungetc(c, m_fp);
            addrr = m_addr;
@@ -2085,55 +2058,58 @@ bool VlReadMem::get(QData& addrr, std::string& valuer) {
        // Parse line
        if (c == '\n') {
            ++m_linenum;
-            ignoreToEol = false;
-            readingAddress = false;
+            ignore_to_eol = false;
+            reading_addr = false;
        } else if (c == '\t' || c == ' ' || c == '\r' || c == '\f') {
-            readingAddress = false;
+            reading_addr = false;
        }
        // Skip // comments and detect /* comments
-        else if (ignoreToComment && lastCh == '*' && c == '/') {
-            ignoreToComment = false;
-            readingAddress = false;
-        } else if (!ignoreToEol && !ignoreToComment) {
-            if (lastCh == '/' && c == '*') {
-                ignoreToComment = true;
-            } else if (lastCh == '/' && c == '/') {
-                ignoreToEol = true;
+        else if (ignore_to_cmt && lastc == '*' && c == '/') {
+            ignore_to_cmt = false;
+            reading_addr = false;
+        } else if (!ignore_to_eol && !ignore_to_cmt) {
+            if (lastc == '/' && c == '*') {
+                ignore_to_cmt = true;
+            } else if (lastc == '/' && c == '/') {
+                ignore_to_eol = true;
            } else if (c == '/') {  // Part of /* or //
            } else if (c == '#') {
-                ignoreToEol = true;
+                ignore_to_eol = true;
            } else if (c == '@') {
-                readingAddress = true;
+                reading_addr = true;
                m_anyAddr = true;
                m_addr = 0;
-            } else if (readingAddress && chIs2StateHex) {
+            }
+            // Check for hex or binary digits as file format requests
+            else if (std::isxdigit(c) || (!reading_addr && (c == 'x' || c == 'X'))) {
                c = std::tolower(c);
-                const int addressValue = (c >= 'a') ? (c - 'a' + 10) : (c - '0');
-                m_addr = (m_addr << 4) + addressValue;
-            } else if (readingAddress && chIs4StateHex) {
-                VL_FATAL_MT(m_filename.c_str(), m_linenum, "",
-                            "$readmem address contains 4-state characters");
-            } else if (chIs4StateHex) {
-                inData = true;
-                valuer += static_cast<char>(c);
-                if (VL_UNLIKELY(!m_hex && !chIs4StateBin)) {
-                    VL_FATAL_MT(m_filename.c_str(), m_linenum, "",
-                                "$readmemb (binary) file contains hex characters");
+                const int value
+                    = (c >= 'a' ? (c == 'x' ? VL_RAND_RESET_I(4) : (c - 'a' + 10)) : (c - '0'));
+                if (reading_addr) {
+                    // Decode @ addresses
+                    m_addr = (m_addr << 4) + value;
+                } else {
+                    indata = true;
+                    valuer += static_cast<char>(c);
+                    // printf(" Value width=%d  @%x = %c\n", width, m_addr, c);
+                    if (VL_UNLIKELY(value > 1 && !m_hex)) {
+                        VL_FATAL_MT(m_filename.c_str(), m_linenum, "",
+                                    "$readmemb (binary) file contains hex characters");
+                    }
                }
            } else {
                VL_FATAL_MT(m_filename.c_str(), m_linenum, "", "$readmem file syntax error");
            }
        }
-        lastCh = c;
+        lastc = c;
    }

    if (VL_UNLIKELY(m_end != ~0ULL && m_addr <= m_end && !m_anyAddr)) {
        VL_WARN_MT(m_filename.c_str(), m_linenum, "",
-                   "$readmem file ended before specified final address (IEEE 1800-2023 21.4)");
+                   "$readmem file ended before specified final address (IEEE 1800-2017 21.4)");
    }

-    addrr = m_addr;
-    return inData;  // EOF
+    return false;  // EOF
 }
 void VlReadMem::setData(void* valuep, const std::string& rhs) {
    const QData shift = m_hex ? 4ULL : 1ULL;
@@ -2141,9 +2117,8 @@ void VlReadMem::setData(void* valuep, const std::string& rhs) {
    // Shift value in
    for (const auto& i : rhs) {
        const char c = std::tolower(i);
-        const int value = (c == 'x' || c == 'z') ? VL_RAND_RESET_I(m_hex ? 4 : 1)
-                          : (c >= 'a')           ? (c - 'a' + 10)
-                                                 : (c - '0');
+        const int value
+            = (c >= 'a' ? (c == 'x' ? VL_RAND_RESET_I(4) : (c - 'a' + 10)) : (c - '0'));
        if (m_bits <= 8) {
            CData* const datap = reinterpret_cast<CData*>(valuep);
            if (!innum) *datap = 0;
@@ -2283,7 +2258,6 @@ void VL_READMEM_N(bool hex,  // Hex format, else binary
        QData addr = 0;
        std::string value;
        if (rmem.get(addr /*ref*/, value /*ref*/)) {
-            // printf("readmem.get [%" PRIu64 "]=%s\n", addr, value.c_str());
            if (VL_UNLIKELY(addr < static_cast<QData>(array_lsb)
                            || addr >= static_cast<QData>(array_lsb + depth))) {
                VL_FATAL_MT(filename.c_str(), rmem.linenum(), "",
@@ -2438,22 +2412,6 @@ uint64_t vl_time_pow10(int n) {
    return pow10[n];
 }

-std::string vl_timescaled_double(double value, const char* format) VL_PURE {
-    const char* suffixp = "s";
-    // clang-format off
-    if      (value >= 1e0)   { suffixp = "s"; value *= 1e0; }
-    else if (value >= 1e-3)  { suffixp = "ms"; value *= 1e3; }
-    else if (value >= 1e-6)  { suffixp = "us"; value *= 1e6; }
-    else if (value >= 1e-9)  { suffixp = "ns"; value *= 1e9; }
-    else if (value >= 1e-12) { suffixp = "ps"; value *= 1e12; }
-    else if (value >= 1e-15) { suffixp = "fs"; value *= 1e15; }
-    else if (value >= 1e-18) { suffixp = "as"; value *= 1e18; }
-    // clang-format on
-    char valuestr[100];
-    VL_SNPRINTF(valuestr, 100, format, value, suffixp);
-    return std::string{valuestr};  // Gets converted to string, so no ref to stack
-}
-
 void VL_PRINTTIMESCALE(const char* namep, const char* timeunitp,
                       const VerilatedContext* contextp) VL_MT_SAFE {
    VL_PRINTF_MT("Time scale of %s is %s / %s\n", namep, timeunitp,
@@ -2477,12 +2435,10 @@ VerilatedContext::VerilatedContext()
    m_ns.m_coverageFilename = "coverage.dat";
    m_ns.m_profExecFilename = "profile_exec.dat";
    m_ns.m_profVltFilename = "profile.vlt";
-    m_ns.m_solverProgram = VlOs::getenvStr("VERILATOR_SOLVER", VL_SOLVER_DEFAULT);
    m_fdps.resize(31);
    std::fill(m_fdps.begin(), m_fdps.end(), static_cast<FILE*>(nullptr));
    m_fdFreeMct.resize(30);
-    IData id = 1;
-    for (std::size_t i = 0; i < m_fdFreeMct.size(); ++i, ++id) m_fdFreeMct[i] = id;
+    for (std::size_t i = 0, id = 1; i < m_fdFreeMct.size(); ++i, ++id) m_fdFreeMct[i] = id;
 }

 // Must declare here not in interface, as otherwise forward declarations not known
@@ -2504,47 +2460,9 @@ VerilatedContext::Serialized::Serialized() {
    m_timeprecision = picosecond;  // Initial value until overridden by _Vconfigure
 }

-bool VerilatedContext::assertOn() const VL_MT_SAFE { return m_s.m_assertOn; }
 void VerilatedContext::assertOn(bool flag) VL_MT_SAFE {
-    // Set all assert and directive types when true, clear otherwise.
-    m_s.m_assertOn = VL_MASK_I(ASSERT_ON_WIDTH) * flag;
-}
-bool VerilatedContext::assertOnGet(VerilatedAssertType_t type,
-                                   VerilatedAssertDirectiveType_t directive) const VL_MT_SAFE {
-    // Check if selected directive type bit in the assertOn is enabled for assertion type.
-    // Note: it is assumed that this is checked only for one type at the time.
-
-    // Flag unspecified assertion types as disabled.
-    if (type == 0) return false;
-
-    // Get index of 3-bit group guarding assertion type status.
-    // Since the assertOnGet is generated __always__ for a single assert type, we assume that only
-    // a single bit will be set. Thus, ceil log2 will work fine.
-    VL_DEBUG_IFDEF(assert((type & (type - 1)) == 0););
-    const IData typeMaskPosition = VL_CLOG2_I(type);
-
-    // Check if directive type bit is enabled in corresponding assertion type bits.
-    return m_s.m_assertOn & (directive << (typeMaskPosition * ASSERT_DIRECTIVE_TYPE_MASK_WIDTH));
-}
-void VerilatedContext::assertOnSet(VerilatedAssertType_t types,
-                                   VerilatedAssertDirectiveType_t directives) VL_MT_SAFE {
-    // For each assertion type, set directive bits.
-
-    // Iterate through all positions of assertion type bits. If bit for this assertion type is set,
-    // set directive type bits mask at this group index.
-    for (int i = 0; i < std::numeric_limits<VerilatedAssertType_t>::digits; ++i) {
-        if (VL_BITISSET_I(types, i))
-            m_s.m_assertOn |= directives << (i * ASSERT_DIRECTIVE_TYPE_MASK_WIDTH);
-    }
-}
-void VerilatedContext::assertOnClear(VerilatedAssertType_t types,
-                                     VerilatedAssertDirectiveType_t directives) VL_MT_SAFE {
-    // Iterate through all positions of assertion type bits. If bit for this assertion type is set,
-    // clear directive type bits mask at this group index.
-    for (int i = 0; i < std::numeric_limits<VerilatedAssertType_t>::digits; ++i) {
-        if (VL_BITISSET_I(types, i))
-            m_s.m_assertOn &= ~(directives << (i * ASSERT_DIRECTIVE_TYPE_MASK_WIDTH));
-    }
+    const VerilatedLockGuard lock{m_mutex};
+    m_s.m_assertOn = flag;
 }
 void VerilatedContext::calcUnusedSigs(bool flag) VL_MT_SAFE {
    const VerilatedLockGuard lock{m_mutex};
@@ -2626,18 +2544,6 @@ std::string VerilatedContext::profVltFilename() const VL_MT_SAFE {
    const VerilatedLockGuard lock{m_mutex};
    return m_ns.m_profVltFilename;
 }
-void VerilatedContext::solverProgram(const std::string& flag) VL_MT_SAFE {
-    const VerilatedLockGuard lock{m_mutex};
-    m_ns.m_solverProgram = flag;
-}
-std::string VerilatedContext::solverProgram() const VL_MT_SAFE {
-    const VerilatedLockGuard lock{m_mutex};
-    return m_ns.m_solverProgram;
-}
-void VerilatedContext::quiet(bool flag) VL_MT_SAFE {
-    const VerilatedLockGuard lock{m_mutex};
-    m_s.m_quiet = flag;
-}
 void VerilatedContext::randReset(int val) VL_MT_SAFE {
    const VerilatedLockGuard lock{m_mutex};
    m_s.m_randReset = val;
@@ -2705,24 +2611,8 @@ void VerilatedContext::internalsDump() const VL_MT_SAFE {
 }

 void VerilatedContext::addModel(VerilatedModel* modelp) {
-    if (!quiet()) {
-        // CPU time isn't read as starting point until model creation, so that quiet() is set
-        // Thus if quiet(), avoids slow OS read affecting some usages that make many models
-        const VerilatedLockGuard lock{m_mutex};
-        m_ns.m_cpuTimeStart.start();
-        m_ns.m_wallTimeStart.start();
-    }
-
-    // We look for time passing, as opposed to post-eval(), as embedded
-    // models might get added inside initial blocks.
-    if (VL_UNLIKELY(time()))
-        VL_FATAL_MT(
-            "", 0, "",
-            "Adding model when time is non-zero. ... Suggest check time(), or for restarting"
-            " model use a new VerilatedContext");
-
    threadPoolp();  // Ensure thread pool is created, so m_threads cannot change any more
-    m_threadsInModels += modelp->threads();
+
    if (VL_UNLIKELY(modelp->threads() > m_threads)) {
        std::ostringstream msg;
        msg << "VerilatedContext has " << m_threads << " threads but model '"
@@ -2755,7 +2645,6 @@ VerilatedContext::enableExecutionProfiler(VerilatedVirtualBase* (*construct)(Ver

 //======================================================================
 // VerilatedContextImp:: Methods - command line
-
 void VerilatedContextImp::commandArgsGuts(int argc, const char** argv)
    VL_MT_SAFE_EXCLUDES(m_argMutex) {
    const VerilatedLockGuard lock{m_argMutex};
@@ -2852,8 +2741,6 @@ void VerilatedContextImp::commandArgVl(const std::string& arg) {
            profExecFilename(str);
        } else if (commandArgVlString(arg, "+verilator+prof+vlt+file+", str)) {
            profVltFilename(str);
-        } else if (arg == "+verilator+quiet") {
-            quiet(true);
        } else if (commandArgVlUint64(arg, "+verilator+rand+reset+", u64, 0, 2)) {
            randReset(static_cast<int>(u64));
        } else if (commandArgVlUint64(arg, "+verilator+seed+", u64, 1,
@@ -2899,7 +2786,7 @@ bool VerilatedContextImp::commandArgVlUint64(const std::string& arg, const std::
            VL_FATAL_MT("COMMAND_LINE", 0, "", msg.c_str());
        };

-        if (std::any_of(str.cbegin(), str.cend(), [](int c) { return !std::isdigit(c); })) fail();
+        if (std::any_of(str.begin(), str.end(), [](int c) { return !std::isdigit(c); })) fail();
        char* end;
        valuer = std::strtoull(str.c_str(), &end, 10);
        if (errno == ERANGE) fail("Value out of range of uint64_t");
@@ -2931,36 +2818,6 @@ uint64_t VerilatedContextImp::randSeedDefault64() const VL_MT_SAFE {
    }
 }

-//======================================================================
-// VerilatedContext:: Statistics
-
-double VerilatedContext::statCpuTimeSinceStart() const VL_MT_SAFE_EXCLUDES(m_mutex) {
-    const VerilatedLockGuard lock{m_mutex};
-    return m_ns.m_cpuTimeStart.deltaTime();
-}
-double VerilatedContext::statWallTimeSinceStart() const VL_MT_SAFE_EXCLUDES(m_mutex) {
-    const VerilatedLockGuard lock{m_mutex};
-    return m_ns.m_wallTimeStart.deltaTime();
-}
-void VerilatedContext::statsPrintSummary() VL_MT_UNSAFE {
-    if (quiet()) return;
-    VL_PRINTF("- S i m u l a t i o n   R e p o r t: %s %s\n", Verilated::productName(),
-              Verilated::productVersion());
-    const std::string endwhy = gotError() ? "$stop" : gotFinish() ? "$finish" : "end";
-    const double simtimeInUnits = VL_TIME_Q() * vl_time_multiplier(timeunit())
-                                  * vl_time_multiplier(timeprecision() - timeunit());
-    const std::string simtime = vl_timescaled_double(simtimeInUnits);
-    const double walltime = statWallTimeSinceStart();
-    const double cputime = statCpuTimeSinceStart();
-    const std::string simtimePerf
-        = vl_timescaled_double((cputime != 0.0) ? (simtimeInUnits / cputime) : 0, "%0.3f %s");
-    VL_PRINTF("- Verilator: %s at %s; walltime %0.3f s; speed %s/s\n", endwhy.c_str(),
-              simtime.c_str(), walltime, simtimePerf.c_str());
-    const double modelMB = VlOs::memUsageBytes() / 1024.0 / 1024.0;
-    VL_PRINTF("- Verilator: cpu %0.3f s on %u threads; alloced %0.0f MB\n", cputime,
-              threadsInModels(), modelMB);
-}
-
 //======================================================================
 // VerilatedContext:: Methods - scopes

@@ -2999,36 +2856,6 @@ const VerilatedScopeNameMap* VerilatedContext::scopeNameMap() VL_MT_SAFE {
    return &(impp()->m_impdatap->m_nameMap);
 }

-//======================================================================
-// VerilatedContext:: Methods - trace
-
-void VerilatedContext::trace(VerilatedTraceBaseC* tfp, int levels, int options) VL_MT_SAFE {
-    VL_DEBUG_IF(VL_DBG_MSGF("+ VerilatedContext::trace\n"););
-    if (tfp->isOpen()) {
-        VL_FATAL_MT("", 0, "",
-                    "Testbench C call to 'VerilatedContext::trace()' must not be called"
-                    " after 'VerilatedTrace*::open()'\n");
-    }
-    {
-        // Legacy usage may call {modela}->trace(...) then {modelb}->trace(...)
-        // So check for and suppress second and later calls
-        if (tfp->modelConnected()) return;
-        tfp->modelConnected(true);
-    }
-    // We rely on m_ns.m_traceBaseModelCbs being stable when trace() is called
-    // nope: const VerilatedLockGuard lock{m_mutex};
-    if (m_ns.m_traceBaseModelCbs.empty())
-        VL_FATAL_MT("", 0, "",
-                    "Testbench C call to 'VerilatedContext::trace()' requires model(s) Verilated"
-                    " with --trace or --trace-vcd option");
-    for (auto& cbr : m_ns.m_traceBaseModelCbs) cbr(tfp, levels, options);
-}
-void VerilatedContext::traceBaseModelCbAdd(traceBaseModelCb_t cb) VL_MT_SAFE {
-    // Model creation registering a callback for when Verilated::trace() called
-    const VerilatedLockGuard lock{m_mutex};
-    m_ns.m_traceBaseModelCbs.push_back(cb);
-}
-
 //======================================================================
 // VerilatedSyms:: Methods

@@ -3200,24 +3027,15 @@ void Verilated::stackCheck(QData needSize) VL_MT_UNSAFE {
        if (haveSize == RLIM_INFINITY) haveSize = 0;
    }
    // VL_PRINTF_MT("-Info: stackCheck(%" PRIu64 ") have %" PRIu64 "\n", needSize, haveSize);
-    // Check and request for 1.5x need. This is automated so the user doesn't need to do anything.
-    QData requestSize = needSize + needSize / 2;
-    if (VL_UNLIKELY(haveSize && needSize && haveSize < requestSize)) {
-        // Try to increase the stack limit to the requested size
-        rlim.rlim_cur = requestSize;
-        if (
-#ifdef _VL_TEST_RLIMIT_FAIL
-            true ||
-#endif
-            setrlimit(RLIMIT_STACK, &rlim)) {
-            VL_PRINTF_MT("%%Warning: System has stack size %" PRIu64 " kb"
-                         " which may be too small; failed to request more"
-                         " using 'ulimit -s %" PRIu64 "'\n",
-                         haveSize / 1024, requestSize);
-        }
+    // Check for 1.5x need, but suggest 2x so small model increase won't cause warning
+    // if the user follows the suggestions
+    if (VL_UNLIKELY(haveSize && needSize && haveSize < (needSize + needSize / 2))) {
+        VL_PRINTF_MT("%%Warning: System has stack size %" PRIu64 " kb"
+                     " which may be too small; suggest 'ulimit -c %" PRIu64 "' or larger\n",
+                     haveSize / 1024, (needSize * 2) / 1024);
    }
 #else
-    (void)needSize;  // Unused argument
+    if (false && needSize) {}  // Unused argument
 #endif
 }

@@ -3416,7 +3234,7 @@ void* VerilatedScope::exportFindNullError(int funcnum) VL_MT_SAFE {
    // Slowpath - Called only when find has failed
    const std::string msg = ("Testbench C called '"s + VerilatedImp::exportName(funcnum)
                             + "' but scope wasn't set, perhaps due to dpi import call without "
-                             + "'context', or missing svSetScope. See IEEE 1800-2023 35.5.3.");
+                             + "'context', or missing svSetScope. See IEEE 1800-2017 35.5.3.");
    VL_FATAL_MT("unknown", 0, "", msg.c_str());
    return nullptr;
 }
@@ -3482,7 +3300,3 @@ void VlDeleter::deleteAll() VL_EXCLUDES(m_mutex) VL_EXCLUDES(m_deleteMutex) VL_M
 }

 //===========================================================================
-// OS functions (last, so we have minimal OS dependencies above)
-
-#define VL_ALLOW_VERILATEDOS_C
-#include "verilatedos_c.h"
@@ -55,7 +55,6 @@
 #include <cstring>
 #include <deque>
 #include <functional>
-#include <limits>
 #include <map>
 #include <memory>
 #include <set>
@@ -102,7 +101,6 @@ class VerilatedScope;
 class VerilatedScopeNameMap;
 template <class, class>
 class VerilatedTrace;
-class VerilatedTraceBaseC;
 class VerilatedTraceConfig;
 class VerilatedVar;
 class VerilatedVarNameMap;
@@ -154,27 +152,6 @@ enum VerilatedVarFlags {
    VLVF_DPI_CLAY = (1 << 10)  // DPI compatible C standard layout
 };

-// IEEE 1800-2023 Table 20-6
-enum class VerilatedAssertType : uint8_t {
-    ASSERT_TYPE_CONCURRENT = (1 << 0),
-    ASSERT_TYPE_SIMPLE_IMMEDIATE = (1 << 1),
-    ASSERT_TYPE_OBSERVED_DEFERRED_IMMEDIATE = (1 << 2),
-    ASSERT_TYPE_FINAL_DEFERRED_IMMEDIATE = (1 << 3),
-    ASSERT_TYPE_EXPECT = (1 << 4),
-    ASSERT_TYPE_UNIQUE = (1 << 5),
-    ASSERT_TYPE_UNIQUE0 = (1 << 6),
-    ASSERT_TYPE_PRIORITY = (1 << 7),
-};
-
-// IEEE 1800-2023 Table 20-7
-enum class VerilatedAssertDirectiveType : uint8_t {
-    DIRECTIVE_TYPE_ASSERT = (1 << 0),
-    DIRECTIVE_TYPE_COVER = (1 << 1),
-    DIRECTIVE_TYPE_ASSUME = (1 << 2),
-};
-using VerilatedAssertType_t = std::underlying_type<VerilatedAssertType>::type;
-using VerilatedAssertDirectiveType_t = std::underlying_type<VerilatedAssertDirectiveType>::type;
-
 //=============================================================================
 // Utility functions

@@ -369,24 +346,7 @@ public:
 class VerilatedContext VL_NOT_FINAL {
    friend class VerilatedContextImp;

-private:
-    // MEMBERS
-    // Numer of assertion directive type members. Then each of them will represented as 1-bit in a
-    // mask.
-    static constexpr size_t ASSERT_DIRECTIVE_TYPE_MASK_WIDTH = 3;
-    // Specifies how many groups of directive type bit groups there are based on a number of
-    // assertion types.
-    // Note: we add one bit to store information whether Verilator's internal
-    // directive types are enabled, for example `violation if`s.
-    static constexpr size_t ASSERT_ON_WIDTH
-        = ASSERT_DIRECTIVE_TYPE_MASK_WIDTH * std::numeric_limits<VerilatedAssertType_t>::digits
-          + 1;
-
 protected:
-    // TYPES
-    using traceBaseModelCb_t
-        = std::function<void(VerilatedTraceBaseC*, int, int)>;  // Type of traceBaseModel callbacks
-
    // MEMBERS
    // Slow path variables
    mutable VerilatedMutex m_mutex;  // Mutex for most s_s/s_ns members
@@ -394,18 +354,13 @@ protected:
    struct Serialized final {  // All these members serialized/deserialized
        // No std::strings or pointers or will serialize badly!
        // Fast path
-        uint64_t m_time = 0;  // Current $time (unscaled), 0=at zero, or legacy
-        std::atomic<uint32_t> m_assertOn{
-            std::numeric_limits<uint32_t>::max()};  // Enabled assertions,
-                                                    // for each VerilatedAssertType we store
-                                                    // 3-bits, one for each directive type. Last
-                                                    // bit guards internal directive types.
+        bool m_assertOn = true;  // Assertions are enabled
        bool m_calcUnusedSigs = false;  // Waves file on, need all signals calculated
        bool m_fatalOnError = true;  // Fatal on $stop/non-fatal error
        bool m_fatalOnVpiError = true;  // Fatal on vpi error/unsupported
        bool m_gotError = false;  // A $finish statement executed
        bool m_gotFinish = false;  // A $finish or $stop statement executed
-        bool m_quiet = false;  // Quiet, no summary report
+        uint64_t m_time = 0;  // Current $time (unscaled), 0=at zero, or legacy
        // Slow path
        int8_t m_timeunit;  // Time unit as 0..15
        int8_t m_timeprecision;  // Time precision as 0..15
@@ -435,10 +390,6 @@ protected:
        std::string m_coverageFilename;  // +coverage+file filename
        std::string m_profExecFilename;  // +prof+exec+file filename
        std::string m_profVltFilename;  // +prof+vlt filename
-        std::string m_solverProgram;  // SMT solver program
-        VlOs::DeltaCpuTime m_cpuTimeStart{false};  // CPU time, starts when create first model
-        VlOs::DeltaWallTime m_wallTimeStart{false};  // Wall time, starts when create first model
-        std::vector<traceBaseModelCb_t> m_traceBaseModelCbs;  // Callbacks to traceRegisterModel
    } m_ns;

    mutable VerilatedMutex m_argMutex;  // Protect m_argVec, m_argVecLoaded
@@ -454,8 +405,6 @@ protected:
    const std::unique_ptr<VerilatedContextImpData> m_impdatap;
    // Number of threads to use for simulation (size of m_threadPool + 1 for main thread)
    unsigned m_threads = std::thread::hardware_concurrency();
-    // Number of threads in added models
-    unsigned m_threadsInModels = 0;
    // The thread pool shared by all models added to this context
    std::unique_ptr<VerilatedVirtualBase> m_threadPool;
    // The execution profiler shared by all models added to this context
@@ -487,23 +436,14 @@ public:

    // METHODS - User called

-    /// Return if assertions enabled
-    bool assertOn() const VL_MT_SAFE;
-    /// Enable all assertion types
+    /// Enable assertions
    void assertOn(bool flag) VL_MT_SAFE;
-    /// Get enabled status for given assertion types
-    bool assertOnGet(VerilatedAssertType_t type,
-                     VerilatedAssertDirectiveType_t directive) const VL_MT_SAFE;
-    /// Set enabled status for given assertion types
-    void assertOnSet(VerilatedAssertType_t types,
-                     VerilatedAssertDirectiveType_t directives) VL_MT_SAFE;
-    /// Clear enabled status for given assertion types
-    void assertOnClear(VerilatedAssertType_t types,
-                       VerilatedAssertDirectiveType_t directives) VL_MT_SAFE;
-    /// Return if calculating of unused signals (for traces)
-    bool calcUnusedSigs() const VL_MT_SAFE { return m_s.m_calcUnusedSigs; }
+    /// Return if assertions enabled
+    bool assertOn() const VL_MT_SAFE { return m_s.m_assertOn; }
    /// Enable calculation of unused signals (for traces)
    void calcUnusedSigs(bool flag) VL_MT_SAFE;
+    /// Return if calculating of unused signals (for traces)
+    bool calcUnusedSigs() const VL_MT_SAFE { return m_s.m_calcUnusedSigs; }
    /// Record command-line arguments, for retrieval by $test$plusargs/$value$plusargs,
    /// and for parsing +verilator+ run-time arguments.
    /// This should be called before the first model is created.
@@ -518,58 +458,48 @@ public:
    /// Return VerilatedCovContext, allocate if needed
    /// Note if get unresolved reference then likely forgot to link verilated_cov.cpp
    VerilatedCovContext* coveragep() VL_MT_SAFE;
-    /// Return debug level
-    static inline int debug() VL_MT_SAFE;  /// Set debug level
+    /// Set debug level
    /// Debug is currently global, but for forward compatibility have a per-context method
    static inline void debug(int val) VL_MT_SAFE;
-    /// Return current number of errors/assertions
-    int errorCount() const VL_MT_SAFE { return m_s.m_errorCount; }
+    /// Return debug level
+    static inline int debug() VL_MT_SAFE;
    /// Set current number of errors/assertions
    void errorCount(int val) VL_MT_SAFE;
    /// Increment current number of errors/assertions
    void errorCountInc() VL_MT_SAFE;
-    /// Return number of errors/assertions before stop
-    int errorLimit() const VL_MT_SAFE { return m_s.m_errorLimit; }
+    /// Return current number of errors/assertions
+    int errorCount() const VL_MT_SAFE { return m_s.m_errorCount; }
    /// Set number of errors/assertions before stop
    void errorLimit(int val) VL_MT_SAFE;
-    /// Return if to throw fatal error on $stop/non-fatal
-    bool fatalOnError() const VL_MT_SAFE { return m_s.m_fatalOnError; }
+    /// Return number of errors/assertions before stop
+    int errorLimit() const VL_MT_SAFE { return m_s.m_errorLimit; }
    /// Set to throw fatal error on $stop/non-fatal error
    void fatalOnError(bool flag) VL_MT_SAFE;
-    /// Return if to throw fatal error on VPI errors
-    bool fatalOnVpiError() const VL_MT_SAFE { return m_s.m_fatalOnVpiError; }
+    /// Return if to throw fatal error on $stop/non-fatal
+    bool fatalOnError() const VL_MT_SAFE { return m_s.m_fatalOnError; }
    /// Set to throw fatal error on VPI errors
    void fatalOnVpiError(bool flag) VL_MT_SAFE;
-    /// Return if got a $stop or non-fatal error
-    bool gotError() const VL_MT_SAFE { return m_s.m_gotError; }
+    /// Return if to throw fatal error on VPI errors
+    bool fatalOnVpiError() const VL_MT_SAFE { return m_s.m_fatalOnVpiError; }
    /// Set if got a $stop or non-fatal error
    void gotError(bool flag) VL_MT_SAFE;
-    /// Return if got a $finish or $stop/error
-    bool gotFinish() const VL_MT_SAFE { return m_s.m_gotFinish; }
+    /// Return if got a $stop or non-fatal error
+    bool gotError() const VL_MT_SAFE { return m_s.m_gotError; }
    /// Set if got a $finish or $stop/error
    void gotFinish(bool flag) VL_MT_SAFE;
-    /// Return if quiet enabled
-    bool quiet() const VL_MT_SAFE { return m_s.m_quiet; }
-    /// Enable quiet (also prevents need for OS calls to get CPU time)
-    void quiet(bool flag) VL_MT_SAFE;
-    /// Return randReset value
-    int randReset() VL_MT_SAFE { return m_s.m_randReset; }
+    /// Return if got a $finish or $stop/error
+    bool gotFinish() const VL_MT_SAFE { return m_s.m_gotFinish; }
    /// Select initial value of otherwise uninitialized signals.
    /// 0 = Set to zeros
    /// 1 = Set all bits to one
    /// 2 = Randomize all bits
    void randReset(int val) VL_MT_SAFE;
-    /// Set default random seed, 0 = seed it automatically
-    int randSeed() const VL_MT_SAFE { return m_s.m_randSeed; }
+    /// Return randReset value
+    int randReset() VL_MT_SAFE { return m_s.m_randReset; }
    /// Return default random seed
    void randSeed(int val) VL_MT_SAFE;
-
-    /// Return statistic: CPU time delta from model created until now
-    double statCpuTimeSinceStart() const VL_MT_SAFE_EXCLUDES(m_mutex);
-    /// Return statistic: Wall time delta from model created until now
-    double statWallTimeSinceStart() const VL_MT_SAFE_EXCLUDES(m_mutex);
-    /// Print statistics summary (if not quiet)
-    void statsPrintSummary() VL_MT_UNSAFE;
+    /// Set default random seed, 0 = seed it automatically
+    int randSeed() const VL_MT_SAFE { return m_s.m_randSeed; }

    // Time handling
    /// Returns current simulation time in units of timeprecision().
@@ -614,14 +544,10 @@ public:

    /// Get number of threads used for simulation (including the main thread)
    unsigned threads() const { return m_threads; }
-    /// Get number of threads in added models (for statistical use only)
-    unsigned threadsInModels() const { return m_threadsInModels; }
    /// Set number of threads used for simulation (including the main thread)
    /// Can only be called before the thread pool is created (before first model is added).
    void threads(unsigned n);

-    /// Trace signals in models within the context; called by application code
-    void trace(VerilatedTraceBaseC* tfp, int levels, int options = 0);
    /// Allow traces to at some point be enabled (disables some optimizations)
    void traceEverOn(bool flag) VL_MT_SAFE {
        if (flag) calcUnusedSigs(true);
@@ -645,8 +571,8 @@ public:
        return reinterpret_cast<const VerilatedContextImp*>(this);
    }

-    // Internal: Model and thread setup
    void addModel(VerilatedModel*);
+
    VerilatedVirtualBase* threadPoolp();
    void prepareClone();
    VerilatedVirtualBase* threadPoolpOnClone();
@@ -654,27 +580,23 @@ public:
    enableExecutionProfiler(VerilatedVirtualBase* (*construct)(VerilatedContext&));

    // Internal: coverage
-    std::string coverageFilename() const VL_MT_SAFE;
    void coverageFilename(const std::string& flag) VL_MT_SAFE;
+    std::string coverageFilename() const VL_MT_SAFE;

    // Internal: $dumpfile
-    std::string dumpfile() const VL_MT_SAFE_EXCLUDES(m_timeDumpMutex);
    void dumpfile(const std::string& flag) VL_MT_SAFE_EXCLUDES(m_timeDumpMutex);
+    std::string dumpfile() const VL_MT_SAFE_EXCLUDES(m_timeDumpMutex);
    std::string dumpfileCheck() const VL_MT_SAFE_EXCLUDES(m_timeDumpMutex);

    // Internal: --prof-exec related settings
-    uint64_t profExecStart() const VL_MT_SAFE { return m_ns.m_profExecStart; }
    void profExecStart(uint64_t flag) VL_MT_SAFE;
-    uint32_t profExecWindow() const VL_MT_SAFE { return m_ns.m_profExecWindow; }
+    uint64_t profExecStart() const VL_MT_SAFE { return m_ns.m_profExecStart; }
    void profExecWindow(uint64_t flag) VL_MT_SAFE;
-    std::string profExecFilename() const VL_MT_SAFE;
+    uint32_t profExecWindow() const VL_MT_SAFE { return m_ns.m_profExecWindow; }
    void profExecFilename(const std::string& flag) VL_MT_SAFE;
-    std::string profVltFilename() const VL_MT_SAFE;
+    std::string profExecFilename() const VL_MT_SAFE;
    void profVltFilename(const std::string& flag) VL_MT_SAFE;
-
-    // Internal: SMT solver program
-    std::string solverProgram() const VL_MT_SAFE;
-    void solverProgram(const std::string& flag) VL_MT_SAFE;
+    std::string profVltFilename() const VL_MT_SAFE;

    // Internal: Find scope
    const VerilatedScope* scopeFind(const char* namep) const VL_MT_SAFE;
@@ -684,9 +606,6 @@ public:
    static constexpr size_t serialized1Size() VL_PURE { return sizeof(m_s); }
    void* serialized1Ptr() VL_MT_UNSAFE { return &m_s; }

-    // Internal: trace registration
-    void traceBaseModelCbAdd(traceBaseModelCb_t cb) VL_MT_SAFE;
-
    // Internal: Check magic number
    static void checkMagic(const VerilatedContext* contextp);
    void selfTestClearMagic() { m_magic = 0x2; }
@@ -851,18 +770,18 @@ public:
    }

 #ifndef VL_NO_LEGACY
-    /// Return VerilatedContext::assertOn() using current thread's VerilatedContext
-    static bool assertOn() VL_MT_SAFE { return Verilated::threadContextp()->assertOn(); }
    /// Call VerilatedContext::assertOn using current thread's VerilatedContext
    static void assertOn(bool flag) VL_MT_SAFE { Verilated::threadContextp()->assertOn(flag); }
-    /// Return VerilatedContext::calcUnusedSigs using current thread's VerilatedContext
-    static bool calcUnusedSigs() VL_MT_SAFE {
-        return Verilated::threadContextp()->calcUnusedSigs();
-    }
+    /// Return VerilatedContext::assertOn() using current thread's VerilatedContext
+    static bool assertOn() VL_MT_SAFE { return Verilated::threadContextp()->assertOn(); }
    /// Call VerilatedContext::calcUnusedSigs using current thread's VerilatedContext
    static void calcUnusedSigs(bool flag) VL_MT_SAFE {
        Verilated::threadContextp()->calcUnusedSigs(flag);
    }
+    /// Return VerilatedContext::calcUnusedSigs using current thread's VerilatedContext
+    static bool calcUnusedSigs() VL_MT_SAFE {
+        return Verilated::threadContextp()->calcUnusedSigs();
+    }
    /// Call VerilatedContext::commandArgs using current thread's VerilatedContext
    static void commandArgs(int argc, const char** argv) VL_MT_SAFE {
        Verilated::threadContextp()->commandArgs(argc, argv);
@@ -1005,8 +924,8 @@ public:

    // Internal: Set the mtaskId, called when an mtask starts
    // Per thread, so no need to be in VerilatedContext
-    static uint32_t mtaskId() VL_MT_SAFE { return t_s.t_mtaskId; }
    static void mtaskId(uint32_t id) VL_MT_SAFE { t_s.t_mtaskId = id; }
+    static uint32_t mtaskId() VL_MT_SAFE { return t_s.t_mtaskId; }
    static void endOfEvalReqdInc() VL_MT_SAFE { ++t_s.t_endOfEvalReqd; }
    static void endOfEvalReqdDec() VL_MT_SAFE { --t_s.t_endOfEvalReqd; }

@@ -80,7 +80,6 @@ VK_CPPFLAGS_ALWAYS += \
 		-I$(VERILATOR_ROOT)/include/vltstd \
 		-DVM_COVERAGE=$(VM_COVERAGE) \
 		-DVM_SC=$(VM_SC) \
-		-DVM_TIMING=$(VM_TIMING) \
 		-DVM_TRACE=$(VM_TRACE) \
 		-DVM_TRACE_FST=$(VM_TRACE_FST) \
 		-DVM_TRACE_VCD=$(VM_TRACE_VCD) \
@@ -226,6 +225,7 @@ endif
 #   1. Extract object files from .a
 #   2. Create a new archive from extracted .o and given .o
 %.a: | %.verilator_deplist.tmp
+	$(info Archive $(AR) -rcs $@ $^)
 	$(foreach L, $(filter-out %.a,$^), $(shell echo $L >>[email protected]_deplist.tmp))
 	@if test $(words $(filter %.a,$^)) -eq 0; then \
 		$(RM) -f $@; \
@@ -121,7 +121,7 @@ private:

 public:
    // CONSTRUCTORS
-    explicit VerilatedCovImp(VerilatedContext* contextp)
+    VerilatedCovImp(VerilatedContext* contextp)
        : m_contextp{contextp} {}
    VL_UNCOPYABLE(VerilatedCovImp);

@@ -92,9 +92,9 @@ public:
    std::string defaultFilename() VL_MT_SAFE;
    /// Make all data per_instance, overriding point's per_instance
    void forcePerInstance(bool flag) VL_MT_SAFE;
-    void write() VL_MT_SAFE { write(defaultFilename()); }
    /// Write all coverage data to a file
    void write(const std::string& filename) VL_MT_SAFE;
+    void write() VL_MT_SAFE { write(defaultFilename()); }
    /// Clear coverage points (and call delete on all items)
    void clear() VL_MT_SAFE;
    /// Clear items not matching the provided string
@@ -165,7 +165,7 @@ public:
    /// Return default filename for the current thread
    static std::string defaultFilename() VL_MT_SAFE { return threadCovp()->defaultFilename(); }
    /// Write all coverage data to a file for the current thread
-    static void write(const std::string& filename) VL_MT_SAFE { threadCovp()->write(filename); }
+    static void write(const std::string filename) VL_MT_SAFE { threadCovp()->write(filename); }
    static void write() VL_MT_SAFE { write(defaultFilename()); }
    /// Clear coverage points (and call delete on all items) for the current thread
    static void clear() VL_MT_SAFE { threadCovp()->clear(); }
@@ -770,36 +770,6 @@ int svGetCallerInfo(const char** fileNamepp, int* lineNumberp) {
    return true;
 }

-//======================================================================
-// Time
-
-int svGetTime(const svScope scope, svTimeVal* time) {
-    if (VL_UNLIKELY(!time)) return -1;
-    const QData qtime = VL_TIME_Q();
-    VlWide<2> itime;
-    VL_SET_WQ(itime, qtime);
-    time->low = itime[0];
-    time->high = itime[1];
-    return 0;
-}
-
-int svGetTimeUnit(const svScope scope, int32_t* time_unit) {
-    if (VL_UNLIKELY(!time_unit)) return -1;
-    const VerilatedScope* const vscopep = reinterpret_cast<const VerilatedScope*>(scope);
-    if (!vscopep) {  // Null asks for global, not unlikely
-        *time_unit = Verilated::threadContextp()->timeunit();
-    } else {
-        *time_unit = vscopep->timeunit();
-    }
-    return 0;
-}
-
-int svGetTimePrecision(const svScope scope, int32_t* time_precision) {
-    if (VL_UNLIKELY(!time_precision)) return -1;
-    *time_precision = Verilated::threadContextp()->timeprecision();
-    return 0;
-}
-
 //======================================================================
 // Disables

@@ -192,7 +192,7 @@ class VerilatedFstBuffer VL_NOT_FINAL {
 /// Create a FST dump file in C standalone (no SystemC) simulations.
 /// Also derived for use in SystemC simulations.

-class VerilatedFstC VL_NOT_FINAL : public VerilatedTraceBaseC {
+class VerilatedFstC VL_NOT_FINAL {
    VerilatedFst m_sptrace;  // Trace file being created

    // CONSTRUCTORS
@@ -208,14 +208,11 @@ public:
    // METHODS - User called

    /// Return if file is open
-    bool isOpen() const override VL_MT_SAFE { return m_sptrace.isOpen(); }
+    bool isOpen() const VL_MT_SAFE { return m_sptrace.isOpen(); }
    /// Open a new FST file
    virtual void open(const char* filename) VL_MT_SAFE { m_sptrace.open(filename); }
    /// Close dump
-    void close() VL_MT_SAFE {
-        m_sptrace.close();
-        modelConnected(false);
-    }
+    void close() VL_MT_SAFE { m_sptrace.close(); }
    /// Flush dump
    void flush() VL_MT_SAFE { m_sptrace.flush(); }
    /// Write one cycle of dump data
@@ -106,14 +106,6 @@ extern IData VL_RAND_RESET_I(int obits) VL_MT_SAFE;
 extern QData VL_RAND_RESET_Q(int obits) VL_MT_SAFE;
 /// Random reset a signal of given width (init time only)
 extern WDataOutP VL_RAND_RESET_W(int obits, WDataOutP outwp) VL_MT_SAFE;
-
-/// Random reset a signal of given width (assign time only)
-extern IData VL_RAND_RESET_ASSIGN_I(int obits) VL_MT_SAFE;
-/// Random reset a signal of given width (assign time only)
-extern QData VL_RAND_RESET_ASSIGN_Q(int obits) VL_MT_SAFE;
-/// Random reset a signal of given width (assign time only)
-extern WDataOutP VL_RAND_RESET_ASSIGN_W(int obits, WDataOutP outwp) VL_MT_SAFE;
-
 /// Zero reset a signal (slow - else use VL_ZERO_W)
 extern WDataOutP VL_ZERO_RESET_W(int obits, WDataOutP outwp) VL_MT_SAFE;

@@ -123,9 +115,6 @@ extern void VL_PRINTTIMESCALE(const char* namep, const char* timeunitp,
 extern WDataOutP _vl_moddiv_w(int lbits, WDataOutP owp, WDataInP const lwp, WDataInP const rwp,
                              bool is_modulus) VL_MT_SAFE;

-extern void _vl_vsss_based(WDataOutP owp, int obits, int baseLog2, const char* strp,
-                           size_t posstart, size_t posend) VL_MT_SAFE;
-
 extern IData VL_FGETS_IXI(int obits, void* destp, IData fpi) VL_MT_SAFE;

 extern void VL_FFLUSH_I(IData fdi) VL_MT_SAFE;
@@ -163,7 +152,6 @@ extern std::string VL_STACKTRACE_N() VL_MT_SAFE;
 extern IData VL_SYSTEM_IW(int lhswords, WDataInP const lhsp) VL_MT_SAFE;
 extern IData VL_SYSTEM_IQ(QData lhs) VL_MT_SAFE;
 inline IData VL_SYSTEM_II(IData lhs) VL_MT_SAFE { return VL_SYSTEM_IQ(lhs); }
-extern IData VL_SYSTEM_IN(const std::string& lhs) VL_MT_SAFE;

 extern IData VL_TESTPLUSARGS_I(const std::string& format) VL_MT_SAFE;
 extern const char* vl_mc_scan_plusargs(const char* prefixp) VL_MT_SAFE;  // PLIish
@@ -227,10 +215,6 @@ static inline QData VL_CVT_Q_D(double lhs) VL_PURE {
    return u.q;
 }
 // clang-format on
-// Return string from DPI char*
-static inline std::string VL_CVT_N_CSTR(const char* lhsp) VL_PURE {
-    return lhsp ? std::string{lhsp} : ""s;
-}

 // Return double from lhs (numeric) unsigned
 double VL_ITOR_D_W(int lbits, WDataInP const lwp) VL_PURE;
@@ -254,7 +238,7 @@ static inline double VL_ISTOR_D_Q(int lbits, QData lhs) VL_MT_SAFE {
    VL_SET_WQ(lwp, lhs);
    return VL_ISTOR_D_W(lbits, lwp);
 }
-// Return IData truncated from double (numeric)
+// Return QData from double (numeric)
 static inline IData VL_RTOI_I_D(double lhs) VL_PURE { return static_cast<int32_t>(VL_TRUNC(lhs)); }

 // Sign extend such that if MSB set, we get ffff_ffff, else 0s
@@ -279,7 +263,7 @@ static inline QData VL_EXTENDSIGN_Q(int lbits, QData lhs) VL_PURE {
 extern void _vl_debug_print_w(int lbits, WDataInP const iwp) VL_MT_SAFE;

 //=========================================================================
-// Time handling
+// Pli macros

 // clang-format off

@@ -337,8 +321,6 @@ uint64_t VerilatedContext::time() const VL_MT_SAFE {
 double vl_time_multiplier(int scale) VL_PURE;
 // Return power of 10. e.g. returns 100 if n==2
 uint64_t vl_time_pow10(int n) VL_PURE;
-// Return time as string with timescale suffix
-std::string vl_timescaled_double(double value, const char* format = "%0.0f%s") VL_PURE;

 //=========================================================================
 // Functional macros/routines
@@ -520,18 +502,19 @@ static inline void VL_ASSIGNBIT_WO(int bit, WDataOutP owp) VL_MT_SAFE {
    { (svar).write(rd); }
 #define VL_ASSIGN_SBQ(obits, svar, rd) \
    { (svar).write(rd); }
+#define VL_SC_BITS_PER_DIGIT 30  // This comes from sc_nbdefs.h BITS_PER_DIGIT
 #define VL_ASSIGN_SBW(obits, svar, rwp) \
    { \
        sc_dt::sc_biguint<(obits)> _butemp; \
        int32_t lsb = 0; \
        uint32_t* chunkp = _butemp.get_raw(); \
-        while (lsb + BITS_PER_DIGIT < (obits)) { \
+        while (lsb + VL_SC_BITS_PER_DIGIT < (obits)) { \
            static_assert(std::is_same<IData, EData>::value, "IData and EData mismatch"); \
-            const uint32_t data \
-                = VL_SEL_IWII(lsb + BITS_PER_DIGIT + 1, (rwp).data(), lsb, BITS_PER_DIGIT); \
-            *chunkp = data & VL_MASK_E(BITS_PER_DIGIT); \
+            const uint32_t data = VL_SEL_IWII(lsb + VL_SC_BITS_PER_DIGIT + 1, (rwp).data(), lsb, \
+                                              VL_SC_BITS_PER_DIGIT); \
+            *chunkp = data & VL_MASK_E(VL_SC_BITS_PER_DIGIT); \
            ++chunkp; \
-            lsb += BITS_PER_DIGIT; \
+            lsb += VL_SC_BITS_PER_DIGIT; \
        } \
        if (lsb < (obits)) { \
            const uint32_t msb_data = VL_SEL_IWII((obits) + 1, (rwp).data(), lsb, (obits)-lsb); \
@@ -1326,26 +1309,6 @@ static inline void _vl_insert_WI(WDataOutP iowp, IData ld, int hbit, int lbit,
    }
 }

-// Copy bits from lwp[hbit:lbit] to low bits of lhsr. rbits is real width of lshr
-static inline void _vl_insert_IW(IData& lhsr, WDataInP const lwp, int hbit, int lbit,
-                                 int rbits = 0) VL_MT_SAFE {
-    const int hoffset = VL_BITBIT_E(hbit);
-    const int loffset = VL_BITBIT_E(lbit);
-    const int hword = VL_BITWORD_E(hbit);
-    const int lword = VL_BITWORD_E(lbit);
-    const IData cleanmask = VL_MASK_I(rbits);
-    if (hword == lword) {
-        const IData insmask = (VL_MASK_I(hoffset - loffset + 1));
-        lhsr = (lhsr & ~insmask) | ((lwp[lword] >> loffset) & (insmask & cleanmask));
-    } else {
-        const int nbitsonright = VL_IDATASIZE - loffset;  // bits that filled by lword
-        const IData hinsmask = (VL_MASK_E(hoffset - 0 + 1)) << nbitsonright;
-        const IData linsmask = VL_MASK_E(VL_EDATASIZE - loffset);
-        lhsr = (lhsr & ~linsmask) | ((lwp[lword] >> loffset) & (linsmask & cleanmask));
-        lhsr = (lhsr & ~hinsmask) | ((lwp[hword] << nbitsonright) & (hinsmask & cleanmask));
-    }
-}
-
 // INTERNAL: Stuff large LHS bit 0++ into OUTPUT at specified offset
 // lwp may be "dirty"
 static inline void _vl_insert_WW(WDataOutP iowp, WDataInP const lwp, int hbit, int lbit,
@@ -1585,184 +1548,28 @@ static inline WDataOutP VL_STREAML_WWI(int lbits, WDataOutP owp, WDataInP const
    return owp;
 }

-static inline IData VL_PACK_II(int obits, int lbits, const VlQueue<CData>& q) {
+template <typename T>
+static inline void VL_ASSIGN_DYN_Q(VlQueue<T>& q, int elem_size, int lbits, QData from) {
+    const int size = (lbits + elem_size - 1) / elem_size;
+    q.renew(size);
+    const QData mask = VL_MASK_Q(elem_size);
+    for (int i = 0; i < size; ++i) q.at(i) = (T)((from >> (i * elem_size)) & mask);
+}
+
+template <typename T>
+static inline IData VL_DYN_TO_I(const VlQueue<T>& q, int elem_size) {
    IData ret = 0;
-    for (size_t i = 0; i < q.size(); ++i) ret |= static_cast<IData>(q.at(i)) << (i * lbits);
+    for (int i = 0; i < q.size(); ++i) ret |= q.at(i) << (i * elem_size);
    return ret;
 }

-static inline IData VL_PACK_II(int obits, int lbits, const VlQueue<SData>& q) {
-    IData ret = 0;
-    for (size_t i = 0; i < q.size(); ++i) ret |= static_cast<IData>(q.at(i)) << (i * lbits);
-    return ret;
-}
-
-static inline IData VL_PACK_II(int obits, int lbits, const VlQueue<IData>& q) {
-    IData ret = 0;
-    for (size_t i = 0; i < q.size(); ++i) ret |= q.at(i) << (i * lbits);
-    return ret;
-}
-
-template <std::size_t T_Depth>
-static inline IData VL_PACK_II(int obits, int lbits, const VlUnpacked<CData, T_Depth>& q) {
-    IData ret = 0;
-    for (size_t i = 0; i < T_Depth; ++i)
-        ret |= static_cast<IData>(q[T_Depth - 1 - i]) << (i * lbits);
-    return ret;
-}
-
-template <std::size_t T_Depth>
-static inline IData VL_PACK_II(int obits, int lbits, const VlUnpacked<SData, T_Depth>& q) {
-    IData ret = 0;
-    for (size_t i = 0; i < T_Depth; ++i)
-        ret |= static_cast<IData>(q[T_Depth - 1 - i]) << (i * lbits);
-    return ret;
-}
-
-template <std::size_t T_Depth>
-static inline IData VL_PACK_II(int obits, int lbits, const VlUnpacked<IData, T_Depth>& q) {
-    IData ret = 0;
-    for (size_t i = 0; i < T_Depth; ++i) ret |= q[T_Depth - 1 - i] << (i * lbits);
-    return ret;
-}
-
-static inline QData VL_PACK_QI(int obits, int lbits, const VlQueue<CData>& q) {
+template <typename T>
+static inline QData VL_DYN_TO_Q(const VlQueue<T>& q, int elem_size) {
    QData ret = 0;
-    for (size_t i = 0; i < q.size(); ++i) ret |= static_cast<QData>(q.at(i)) << (i * lbits);
+    for (int i = 0; i < q.size(); ++i) ret |= q.at(i) << (i * elem_size);
    return ret;
 }

-static inline QData VL_PACK_QI(int obits, int lbits, const VlQueue<SData>& q) {
-    QData ret = 0;
-    for (size_t i = 0; i < q.size(); ++i) ret |= static_cast<QData>(q.at(i)) << (i * lbits);
-    return ret;
-}
-
-static inline QData VL_PACK_QI(int obits, int lbits, const VlQueue<IData>& q) {
-    QData ret = 0;
-    for (size_t i = 0; i < q.size(); ++i) ret |= static_cast<QData>(q.at(i)) << (i * lbits);
-    return ret;
-}
-
-template <std::size_t T_Depth>
-static inline QData VL_PACK_QI(int obits, int lbits, const VlUnpacked<CData, T_Depth>& q) {
-    QData ret = 0;
-    for (size_t i = 0; i < T_Depth; ++i)
-        ret |= static_cast<QData>(q[T_Depth - 1 - i]) << (i * lbits);
-    return ret;
-}
-
-template <std::size_t T_Depth>
-static inline QData VL_PACK_QI(int obits, int lbits, const VlUnpacked<SData, T_Depth>& q) {
-    QData ret = 0;
-    for (size_t i = 0; i < T_Depth; ++i)
-        ret |= static_cast<QData>(q[T_Depth - 1 - i]) << (i * lbits);
-    return ret;
-}
-
-template <std::size_t T_Depth>
-static inline QData VL_PACK_QI(int obits, int lbits, const VlUnpacked<IData, T_Depth>& q) {
-    QData ret = 0;
-    for (size_t i = 0; i < T_Depth; ++i)
-        ret |= static_cast<QData>(q[T_Depth - 1 - i]) << (i * lbits);
-    return ret;
-}
-
-static inline QData VL_PACK_QQ(int obits, int lbits, const VlQueue<QData>& q) {
-    QData ret = 0;
-    for (size_t i = 0; i < q.size(); ++i) ret |= q.at(i) << (i * lbits);
-    return ret;
-}
-
-template <std::size_t T_Depth>
-static inline QData VL_PACK_QQ(int obits, int lbits, const VlUnpacked<QData, T_Depth>& q) {
-    QData ret = 0;
-    for (size_t i = 0; i < T_Depth; ++i) ret |= q[T_Depth - 1 - i] << (i * lbits);
-    return ret;
-}
-
-static inline WDataOutP VL_PACK_WI(int obits, int lbits, WDataOutP owp, const VlQueue<CData>& q) {
-    VL_MEMSET_ZERO_W(owp + 1, VL_WORDS_I(obits) - 1);
-    for (size_t i = 0; i < q.size(); ++i)
-        _vl_insert_WI(owp, q.at(i), i * lbits + lbits - 1, i * lbits);
-    return owp;
-}
-
-static inline WDataOutP VL_PACK_WI(int obits, int lbits, WDataOutP owp, const VlQueue<SData>& q) {
-    VL_MEMSET_ZERO_W(owp + 1, VL_WORDS_I(obits) - 1);
-    for (size_t i = 0; i < q.size(); ++i)
-        _vl_insert_WI(owp, q.at(i), i * lbits + lbits - 1, i * lbits);
-    return owp;
-}
-
-static inline WDataOutP VL_PACK_WI(int obits, int lbits, WDataOutP owp, const VlQueue<IData>& q) {
-    VL_MEMSET_ZERO_W(owp + 1, VL_WORDS_I(obits) - 1);
-    for (size_t i = 0; i < q.size(); ++i)
-        _vl_insert_WI(owp, q.at(i), i * lbits + lbits - 1, i * lbits);
-    return owp;
-}
-
-template <std::size_t T_Depth>
-static inline WDataOutP VL_PACK_WI(int obits, int lbits, WDataOutP owp,
-                                   const VlUnpacked<CData, T_Depth>& q) {
-    VL_MEMSET_ZERO_W(owp + 1, VL_WORDS_I(obits) - 1);
-    for (size_t i = 0; i < T_Depth; ++i)
-        _vl_insert_WI(owp, q[T_Depth - 1 - i], i * lbits + lbits - 1, i * lbits);
-    return owp;
-}
-
-template <std::size_t T_Depth>
-static inline WDataOutP VL_PACK_WI(int obits, int lbits, WDataOutP owp,
-                                   const VlUnpacked<SData, T_Depth>& q) {
-    VL_MEMSET_ZERO_W(owp + 1, VL_WORDS_I(obits) - 1);
-    for (size_t i = 0; i < T_Depth; ++i)
-        _vl_insert_WI(owp, q[T_Depth - 1 - i], i * lbits + lbits - 1, i * lbits);
-    return owp;
-}
-
-template <std::size_t T_Depth>
-static inline WDataOutP VL_PACK_WI(int obits, int lbits, WDataOutP owp,
-                                   const VlUnpacked<IData, T_Depth>& q) {
-    VL_MEMSET_ZERO_W(owp + 1, VL_WORDS_I(obits) - 1);
-    for (size_t i = 0; i < T_Depth; ++i)
-        _vl_insert_WI(owp, q[T_Depth - 1 - i], i * lbits + lbits - 1, i * lbits);
-    return owp;
-}
-
-static inline WDataOutP VL_PACK_WQ(int obits, int lbits, WDataOutP owp, const VlQueue<QData>& q) {
-    VL_MEMSET_ZERO_W(owp + 1, VL_WORDS_I(obits) - 1);
-    for (size_t i = 0; i < q.size(); ++i)
-        _vl_insert_WQ(owp, q.at(i), i * lbits + lbits - 1, i * lbits);
-    return owp;
-}
-
-template <std::size_t T_Depth>
-static inline WDataOutP VL_PACK_WQ(int obits, int lbits, WDataOutP owp,
-                                   const VlUnpacked<QData, T_Depth>& q) {
-    VL_MEMSET_ZERO_W(owp + 1, VL_WORDS_I(obits) - 1);
-    for (size_t i = 0; i < T_Depth; ++i)
-        _vl_insert_WQ(owp, q[T_Depth - 1 - i], i * lbits + lbits - 1, i * lbits);
-    return owp;
-}
-
-template <std::size_t N>
-static inline WDataOutP VL_PACK_WW(int obits, int lbits, WDataOutP owp,
-                                   const VlQueue<VlWide<N>>& q) {
-    VL_MEMSET_ZERO_W(owp + 1, VL_WORDS_I(obits) - 1);
-    for (size_t i = 0; i < q.size(); ++i)
-        _vl_insert_WW(owp, q.at(i), i * lbits + lbits - 1, i * lbits);
-    return owp;
-}
-
-template <std::size_t T_Depth, std::size_t N>
-static inline WDataOutP VL_PACK_WW(int obits, int lbits, WDataOutP owp,
-                                   const VlUnpacked<VlWide<N>, T_Depth>& q) {
-    VL_MEMSET_ZERO_W(owp + 1, VL_WORDS_I(obits) - 1);
-    for (size_t i = 0; i < T_Depth; ++i)
-        _vl_insert_WW(owp, q[T_Depth - 1 - i], i * lbits + lbits - 1, i * lbits);
-    return owp;
-}
-
 // Because concats are common and wide, it's valuable to always have a clean output.
 // Thus we specify inputs must be clean, so we don't need to clean the output.
 // Note the bit shifts are always constants, so the adds in these constify out.
@@ -2202,171 +2009,6 @@ static inline WDataOutP VL_SEL_WWII(int obits, int lbits, WDataOutP owp, WDataIn
 //======================================================================
 // Expressions needing insert/select

-static inline void VL_UNPACK_II(int lbits, int rbits, VlQueue<CData>& q, IData from) {
-    const size_t size = (rbits + lbits - 1) / lbits;
-    q.renew(size);
-    const IData mask = VL_MASK_I(lbits);
-    for (size_t i = 0; i < size; ++i) q.at(i) = (from >> (i * lbits)) & mask;
-}
-
-static inline void VL_UNPACK_II(int lbits, int rbits, VlQueue<SData>& q, IData from) {
-    const size_t size = (rbits + lbits - 1) / lbits;
-    q.renew(size);
-    const IData mask = VL_MASK_I(lbits);
-    for (size_t i = 0; i < size; ++i) q.at(i) = (from >> (i * lbits)) & mask;
-}
-
-static inline void VL_UNPACK_II(int lbits, int rbits, VlQueue<IData>& q, IData from) {
-    const size_t size = (rbits + lbits - 1) / lbits;
-    q.renew(size);
-    const IData mask = VL_MASK_I(lbits);
-    for (size_t i = 0; i < size; ++i) q.at(i) = (from >> (i * lbits)) & mask;
-}
-
-static inline void VL_UNPACK_IQ(int lbits, int rbits, VlQueue<CData>& q, QData from) {
-    const size_t size = (rbits + lbits - 1) / lbits;
-    q.renew(size);
-    const IData mask = VL_MASK_I(lbits);
-    for (size_t i = 0; i < size; ++i) q.at(i) = (from >> (i * lbits)) & mask;
-}
-
-static inline void VL_UNPACK_IQ(int lbits, int rbits, VlQueue<SData>& q, QData from) {
-    const size_t size = (rbits + lbits - 1) / lbits;
-    q.renew(size);
-    const IData mask = VL_MASK_I(lbits);
-    for (size_t i = 0; i < size; ++i) q.at(i) = (from >> (i * lbits)) & mask;
-}
-
-static inline void VL_UNPACK_IQ(int lbits, int rbits, VlQueue<IData>& q, QData from) {
-    const size_t size = (rbits + lbits - 1) / lbits;
-    q.renew(size);
-    const IData mask = VL_MASK_I(lbits);
-    for (size_t i = 0; i < size; ++i) q.at(i) = (from >> (i * lbits)) & mask;
-}
-
-static inline void VL_UNPACK_QQ(int lbits, int rbits, VlQueue<QData>& q, QData from) {
-    const size_t size = (rbits + lbits - 1) / lbits;
-    q.renew(size);
-    const QData mask = VL_MASK_Q(lbits);
-    for (size_t i = 0; i < size; ++i) q.at(i) = (from >> (i * lbits)) & mask;
-}
-
-static inline void VL_UNPACK_IW(int lbits, int rbits, VlQueue<CData>& q, WDataInP rwp) {
-    const int size = (rbits + lbits - 1) / lbits;
-    q.renew(size);
-    const IData mask = VL_MASK_I(lbits);
-    for (size_t i = 0; i < size; ++i) q.at(i) = VL_SEL_IWII(rbits, rwp, i * lbits, lbits) & mask;
-}
-
-static inline void VL_UNPACK_IW(int lbits, int rbits, VlQueue<SData>& q, WDataInP rwp) {
-    const int size = (rbits + lbits - 1) / lbits;
-    q.renew(size);
-    const IData mask = VL_MASK_I(lbits);
-    for (size_t i = 0; i < size; ++i) q.at(i) = VL_SEL_IWII(rbits, rwp, i * lbits, lbits) & mask;
-}
-
-static inline void VL_UNPACK_IW(int lbits, int rbits, VlQueue<IData>& q, WDataInP rwp) {
-    const int size = (rbits + lbits - 1) / lbits;
-    q.renew(size);
-    const IData mask = VL_MASK_I(lbits);
-    for (size_t i = 0; i < size; ++i) q.at(i) = VL_SEL_IWII(rbits, rwp, i * lbits, lbits) & mask;
-}
-
-static inline void VL_UNPACK_QW(int lbits, int rbits, VlQueue<QData>& q, WDataInP rwp) {
-    const int size = (rbits + lbits - 1) / lbits;
-    q.renew(size);
-    const QData mask = VL_MASK_Q(lbits);
-    for (size_t i = 0; i < size; ++i) q.at(i) = VL_SEL_QWII(rbits, rwp, i * lbits, lbits) & mask;
-}
-
-template <std::size_t N>
-static inline void VL_UNPACK_WW(int lbits, int rbits, VlQueue<VlWide<N>>& q, WDataInP rwp) {
-    const int size = (rbits + lbits - 1) / lbits;
-    q.renew(size);
-    for (size_t i = 0; i < size; ++i) VL_SEL_WWII(lbits, rbits, q.at(i), rwp, i * lbits, lbits);
-}
-
-template <std::size_t T_Depth>
-static inline void VL_UNPACK_II(int lbits, int rbits, VlUnpacked<CData, T_Depth>& q, IData from) {
-    const IData mask = VL_MASK_I(lbits);
-    for (size_t i = 0; i < T_Depth; ++i) q[i] = (from >> ((T_Depth - 1 - i) * lbits)) & mask;
-}
-
-template <std::size_t T_Depth>
-static inline void VL_UNPACK_II(int lbits, int rbits, VlUnpacked<SData, T_Depth>& q, IData from) {
-    const IData mask = VL_MASK_I(lbits);
-    for (size_t i = 0; i < T_Depth; ++i) q[i] = (from >> ((T_Depth - 1 - i) * lbits)) & mask;
-}
-
-template <std::size_t T_Depth>
-static inline void VL_UNPACK_II(int lbits, int rbits, VlUnpacked<IData, T_Depth>& q, IData from) {
-    const IData mask = VL_MASK_I(lbits);
-    for (size_t i = 0; i < T_Depth; ++i) q[i] = (from >> ((T_Depth - 1 - i) * lbits)) & mask;
-}
-
-template <std::size_t T_Depth>
-static inline void VL_UNPACK_IQ(int lbits, int rbits, VlUnpacked<CData, T_Depth>& q, QData from) {
-    const IData mask = VL_MASK_I(lbits);
-    for (size_t i = 0; i < T_Depth; ++i) q[i] = (from >> ((T_Depth - 1 - i) * lbits)) & mask;
-}
-
-template <std::size_t T_Depth>
-static inline void VL_UNPACK_IQ(int lbits, int rbits, VlUnpacked<SData, T_Depth>& q, QData from) {
-    const IData mask = VL_MASK_I(lbits);
-    for (size_t i = 0; i < T_Depth; ++i) q[i] = (from >> ((T_Depth - 1 - i) * lbits)) & mask;
-}
-
-template <std::size_t T_Depth>
-static inline void VL_UNPACK_IQ(int lbits, int rbits, VlUnpacked<IData, T_Depth>& q, QData from) {
-    const IData mask = VL_MASK_I(lbits);
-    for (size_t i = 0; i < T_Depth; ++i) q[i] = (from >> ((T_Depth - 1 - i) * lbits)) & mask;
-}
-
-template <std::size_t T_Depth>
-static inline void VL_UNPACK_QQ(int lbits, int rbits, VlUnpacked<QData, T_Depth>& q, QData from) {
-    const QData mask = VL_MASK_Q(lbits);
-    for (size_t i = 0; i < T_Depth; ++i) q[i] = (from >> ((T_Depth - 1 - i) * lbits)) & mask;
-}
-
-template <std::size_t T_Depth>
-static inline void VL_UNPACK_IW(int lbits, int rbits, VlUnpacked<CData, T_Depth>& q,
-                                WDataInP rwp) {
-    const IData mask = VL_MASK_I(lbits);
-    for (size_t i = 0; i < T_Depth; ++i)
-        q[i] = VL_SEL_IWII(rbits, rwp, (T_Depth - 1 - i) * lbits, lbits) & mask;
-}
-
-template <std::size_t T_Depth>
-static inline void VL_UNPACK_IW(int lbits, int rbits, VlUnpacked<SData, T_Depth>& q,
-                                WDataInP rwp) {
-    const IData mask = VL_MASK_I(lbits);
-    for (size_t i = 0; i < T_Depth; ++i)
-        q[i] = VL_SEL_IWII(rbits, rwp, (T_Depth - 1 - i) * lbits, lbits) & mask;
-}
-
-template <std::size_t T_Depth>
-static inline void VL_UNPACK_IW(int lbits, int rbits, VlUnpacked<IData, T_Depth>& q,
-                                WDataInP rwp) {
-    const IData mask = VL_MASK_I(lbits);
-    for (size_t i = 0; i < T_Depth; ++i)
-        q[i] = VL_SEL_IWII(rbits, rwp, (T_Depth - 1 - i) * lbits, lbits) & mask;
-}
-
-template <std::size_t T_Depth>
-static inline void VL_UNPACK_QW(int lbits, int rbits, VlUnpacked<QData, T_Depth>& q,
-                                WDataInP rwp) {
-    const QData mask = VL_MASK_Q(lbits);
-    for (size_t i = 0; i < T_Depth; ++i)
-        q[i] = VL_SEL_QWII(rbits, rwp, (T_Depth - 1 - i) * lbits, lbits) & mask;
-}
-
-template <std::size_t T_Depth, std::size_t N>
-static inline void VL_UNPACK_WW(int lbits, int rbits, VlUnpacked<VlWide<N>, T_Depth>& q,
-                                WDataInP rwp) {
-    for (size_t i = 0; i < T_Depth; ++i)
-        VL_SEL_WWII(lbits, rbits, q[i], rwp, (T_Depth - 1 - i) * lbits, lbits);
-}
-
 // Return QData from double (numeric)
 // EMIT_RULE: VL_RTOIROUND_Q_D:  oclean=dirty; lclean==clean/real
 static inline QData VL_RTOIROUND_Q_D(double lhs) VL_PURE {
@@ -2441,97 +2083,6 @@ static inline void VL_ASSIGNSEL_WW(int rbits, int obits, int lsb, WDataOutP iowp
    _vl_insert_WW(iowp, rwp, lsb + obits - 1, lsb, rbits);
 }

-//====================================================
-// Range assignments
-
-// These additional functions copy bits range [obis+roffset-1:roffset] from rhs to lower bits
-// of lhs(select before assigning). Rhs should always be wider than lhs.
-static inline void VL_SELASSIGN_II(int rbits, int obits, CData& lhsr, IData rhs,
-                                   int roffset) VL_PURE {
-    _vl_insert_II(lhsr, rhs >> roffset, obits - 1, 0, rbits);
-}
-static inline void VL_SELASSIGN_II(int rbits, int obits, SData& lhsr, IData rhs,
-                                   int roffset) VL_PURE {
-    _vl_insert_II(lhsr, rhs >> roffset, obits - 1, 0, rbits);
-}
-static inline void VL_SELASSIGN_II(int rbits, int obits, IData& lhsr, IData rhs,
-                                   int roffset) VL_PURE {
-    _vl_insert_II(lhsr, rhs >> roffset, obits - 1, 0, rbits);
-}
-static inline void VL_SELASSIGN_IQ(int rbits, int obits, CData& lhsr, QData rhs,
-                                   int roffset) VL_PURE {
-    // it will be truncated to right CData mask
-    const CData cleanmask = VL_MASK_I(rbits);
-    const CData insmask = VL_MASK_I(obits);
-    lhsr = (lhsr & ~insmask) | (static_cast<CData>(rhs >> roffset) & (insmask & cleanmask));
-}
-static inline void VL_SELASSIGN_IQ(int rbits, int obits, SData& lhsr, QData rhs,
-                                   int roffset) VL_PURE {
-    // it will be truncated to right CData mask
-    const SData cleanmask = VL_MASK_I(rbits);
-    const SData insmask = VL_MASK_I(obits);
-    lhsr = (lhsr & ~insmask) | (static_cast<SData>(rhs >> roffset) & (insmask & cleanmask));
-}
-static inline void VL_SELASSIGN_IQ(int rbits, int obits, IData& lhsr, QData rhs,
-                                   int roffset) VL_PURE {
-    const IData cleanmask = VL_MASK_I(rbits);
-    const IData insmask = VL_MASK_I(obits);
-    lhsr = (lhsr & ~insmask) | (static_cast<IData>(rhs >> roffset) & (insmask & cleanmask));
-}
-
-static inline void VL_SELASSIGN_QQ(int rbits, int obits, QData& lhsr, QData rhs,
-                                   int roffset) VL_PURE {
-    _vl_insert_QQ(lhsr, rhs >> roffset, obits - 1, 0, rbits);
-}
-
-static inline void VL_SELASSIGN_IW(int rbits, int obits, CData& lhsr, WDataInP const rhs,
-                                   int roffset) VL_MT_SAFE {
-    IData l = static_cast<IData>(lhsr);
-    _vl_insert_IW(l, rhs, roffset + obits - 1, roffset, rbits);
-    lhsr = static_cast<CData>(l);
-}
-static inline void VL_SELASSIGN_IW(int rbits, int obits, SData& lhsr, WDataInP const rhs,
-                                   int roffset) VL_MT_SAFE {
-    IData l = static_cast<IData>(lhsr);
-    _vl_insert_IW(l, rhs, roffset + obits - 1, roffset, rbits);
-    lhsr = static_cast<SData>(l);
-}
-static inline void VL_SELASSIGN_IW(int rbits, int obits, IData& lhsr, WDataInP const rhs,
-                                   int roffset) VL_MT_SAFE {
-    _vl_insert_IW(lhsr, rhs, roffset + obits - 1, roffset, rbits);
-}
-static inline void VL_SELASSIGN_QW(int rbits, int obits, QData& lhsr, WDataInP const rhs,
-                                   int roffset) VL_MT_SAFE {
-    // assert VL_QDATASIZE >= rbits > VL_IDATASIZE;
-    IData low = static_cast<IData>(lhsr);
-    IData high = static_cast<IData>(lhsr >> VL_IDATASIZE);
-    if (obits <= VL_IDATASIZE) {
-        _vl_insert_IW(low, rhs, obits + roffset - 1, roffset, VL_IDATASIZE);
-    } else {
-        _vl_insert_IW(low, rhs, roffset + VL_IDATASIZE - 1, roffset, VL_IDATASIZE);
-        _vl_insert_IW(high, rhs, roffset + obits - 1, roffset + VL_IDATASIZE,
-                      rbits - VL_IDATASIZE);
-    }
-    lhsr = (static_cast<QData>(high) << VL_IDATASIZE) | low;
-}
-
-static inline void VL_SELASSIGN_WW(int rbits, int obits, WDataOutP iowp, WDataInP const rwp,
-                                   int roffset) VL_MT_SAFE {
-    // assert rbits > VL_QDATASIZE
-    const int wordoff = roffset / VL_EDATASIZE;
-    const int lsb = roffset & VL_SIZEBITS_E;
-    const int upperbits = lsb == 0 ? 0 : VL_EDATASIZE - lsb;
-    // If roffset is not aligned, we copy some bits to align it.
-    if (lsb != 0) {
-        const int w = obits < upperbits ? obits : upperbits;
-        const int insmask = VL_MASK_E(w);
-        iowp[0] = (iowp[0] & ~insmask) | ((rwp[wordoff] >> lsb) & insmask);
-        if (w == obits) return;
-        obits -= w;
-    }
-    _vl_insert_WW(iowp, rwp + wordoff + (lsb != 0), upperbits + obits - 1, upperbits, rbits);
-}
-
 //======================================================================
 // Triops

@@ -116,7 +116,7 @@ IData VL_DIST_ERLANG(IData& seedr, IData uk, IData umean) VL_MT_SAFE {
        return 0;
    }
    double x = 1.0;
-    for (int32_t i = 1; i <= k; i++) x = x * _vl_dbase_uniform(seedr, 0, 1);
+    for (int32_t i = 1; i <= k; i++) { x = x * _vl_dbase_uniform(seedr, 0, 1); }
    const double a = static_cast<double>(mean);
    const double b = static_cast<double>(k);
    double r = -a * log(x) / b;
@@ -1,430 +0,0 @@
-// -*- mode: C++; c-file-style: "cc-mode" -*-
-//*************************************************************************
-//
-// Code available from: https://verilator.org
-//
-// Copyright 2024 by Wilson Snyder.  This program is free software; you can
-// redistribute it and/or modify it under the terms of either the GNU Lesser
-// General Public License Version 3 or the Perl Artistic License Version 2.0.
-// SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
-//
-//=========================================================================
-///
-/// \file
-/// \brief Verilated randomization implementation code
-///
-/// This file must be compiled and linked against all Verilated objects
-/// that use randomization features.
-///
-/// See the internals documentation docs/internals.rst for details.
-///
-//=========================================================================
-
-#include "verilated_random.h"
-
-#include <iostream>
-#include <sstream>
-#include <streambuf>
-
-#define _VL_SOLVER_HASH_LEN 1
-#define _VL_SOLVER_HASH_LEN_TOTAL 4
-
-// clang-format off
-#if defined(__unix__) || defined(__unix) || (defined(__APPLE__) && defined(__MACH__))
-# define _VL_SOLVER_PIPE  // Allow pipe SMT solving.  Needs fork()
-#endif
-
-#ifdef _VL_SOLVER_PIPE
-# include <sys/wait.h>
-# include <fcntl.h>
-#endif
-
-#if defined(_WIN32) || defined(__MINGW32__)
-# include <io.h>  // open, read, write, close
-#endif
-// clang-format on
-
-class Process final : private std::streambuf, public std::iostream {
-    static constexpr int BUFFER_SIZE = 4096;
-    const char* const* m_cmd = nullptr;  // fork() process argv
-#ifdef _VL_SOLVER_PIPE
-    pid_t m_pid = 0;  // fork() process id
-#else
-    int m_pid = 0;  // fork() process id - always zero as disabled
-#endif
-    bool m_pidExited = true;  // If subprocess has exited and can be opened
-    int m_pidStatus = 0;  // fork() process exit status, valid if m_pidExited
-    int m_writeFd = -1;  // File descriptor TO subprocess
-    int m_readFd = -1;  // File descriptor FROM subprocess
-    char m_readBuf[BUFFER_SIZE];
-    char m_writeBuf[BUFFER_SIZE];
-
-public:
-    typedef std::streambuf::traits_type traits_type;
-
-protected:
-    int overflow(int c = traits_type::eof()) override {
-        char c2 = static_cast<char>(c);
-        if (pbase() == pptr()) return 0;
-        size_t size = pptr() - pbase();
-        ssize_t n = ::write(m_writeFd, pbase(), size);
-        if (n == -1) perror("write");
-        if (n <= 0) {
-            wait_report();
-            return traits_type::eof();
-        }
-        if (n == size)
-            setp(m_writeBuf, m_writeBuf + sizeof(m_writeBuf));
-        else
-            setp(m_writeBuf + n, m_writeBuf + sizeof(m_writeBuf));
-        if (c != traits_type::eof()) sputc(c2);
-        return 0;
-    }
-    int underflow() override {
-        sync();
-        ssize_t n = ::read(m_readFd, m_readBuf, sizeof(m_readBuf));
-        if (n == -1) perror("read");
-        if (n <= 0) {
-            wait_report();
-            return traits_type::eof();
-        }
-        setg(m_readBuf, m_readBuf, m_readBuf + n);
-        return traits_type::to_int_type(m_readBuf[0]);
-    }
-    int sync() override {
-        overflow();
-        return 0;
-    }
-
-public:
-    explicit Process(const char* const* const cmd = nullptr)
-        : std::streambuf{}
-        , std::iostream{this}
-        , m_cmd{cmd} {
-        open(cmd);
-    }
-
-    void wait_report() {
-        if (m_pidExited) return;
-#ifdef _VL_SOLVER_PIPE
-        if (waitpid(m_pid, &m_pidStatus, 0) != m_pid) return;
-        if (m_pidStatus) {
-            std::stringstream msg;
-            msg << "Subprocess command `" << m_cmd[0];
-            for (const char* const* arg = m_cmd + 1; *arg; arg++) msg << ' ' << *arg;
-            msg << "' failed: ";
-            if (WIFSIGNALED(m_pidStatus))
-                msg << strsignal(WTERMSIG(m_pidStatus))
-                    << (WCOREDUMP(m_pidStatus) ? " (core dumped)" : "");
-            else if (WIFEXITED(m_pidStatus))
-                msg << "exit status " << WEXITSTATUS(m_pidStatus);
-            const std::string str = msg.str();
-            VL_WARN_MT("", 0, "Process", str.c_str());
-        }
-#endif
-        m_pidExited = true;
-        m_pid = 0;
-        closeFds();
-    }
-
-    void closeFds() {
-        if (m_writeFd != -1) {
-            close(m_writeFd);
-            m_writeFd = -1;
-        }
-        if (m_readFd != -1) {
-            close(m_readFd);
-            m_readFd = -1;
-        }
-    }
-
-    bool open(const char* const* const cmd) {
-        setp(std::begin(m_writeBuf), std::end(m_writeBuf));
-        setg(m_readBuf, m_readBuf, m_readBuf);
-#ifdef _VL_SOLVER_PIPE
-        if (!cmd || !cmd[0]) return false;
-        m_cmd = cmd;
-        int fd_stdin[2];  // Can't use std::array
-        int fd_stdout[2];  // Can't use std::array
-        constexpr int P_RD = 0;
-        constexpr int P_WR = 1;
-
-        if (pipe(fd_stdin) != 0) {
-            perror("Process::open: pipe");
-            return false;
-        }
-        if (pipe(fd_stdout) != 0) {
-            perror("Process::open: pipe");
-            close(fd_stdin[P_RD]);
-            close(fd_stdin[P_WR]);
-            return false;
-        }
-
-        if (fd_stdin[P_RD] <= 2 || fd_stdin[P_WR] <= 2 || fd_stdout[P_RD] <= 2
-            || fd_stdout[P_WR] <= 2) {
-            // We'd have to rearrange all of the FD usages in this case.
-            // Too unlikely; verilator isn't a daemon.
-            fprintf(stderr, "stdin/stdout closed before pipe opened\n");
-            close(fd_stdin[P_RD]);
-            close(fd_stdin[P_WR]);
-            close(fd_stdout[P_RD]);
-            close(fd_stdout[P_WR]);
-            return false;
-        }
-
-        const pid_t pid = fork();
-        if (pid < 0) {
-            perror("Process::open: fork");
-            close(fd_stdin[P_RD]);
-            close(fd_stdin[P_WR]);
-            close(fd_stdout[P_RD]);
-            close(fd_stdout[P_WR]);
-            return false;
-        }
-        if (pid == 0) {
-            // Child
-            close(fd_stdin[P_WR]);
-            dup2(fd_stdin[P_RD], STDIN_FILENO);
-            close(fd_stdout[P_RD]);
-            dup2(fd_stdout[P_WR], STDOUT_FILENO);
-            execvp(cmd[0], const_cast<char* const*>(cmd));
-            std::stringstream msg;
-            msg << "Process::open: execvp(" << cmd[0] << ")";
-            const std::string str = msg.str();
-            perror(str.c_str());
-            _exit(127);
-        }
-        // Parent
-        m_pid = pid;
-        m_pidExited = false;
-        m_pidStatus = 0;
-        m_readFd = fd_stdout[P_RD];
-        m_writeFd = fd_stdin[P_WR];
-
-        close(fd_stdin[P_RD]);
-        close(fd_stdout[P_WR]);
-
-        return true;
-#else
-        return false;
-#endif
-    }
-};
-
-static Process& getSolver() {
-    static Process s_solver;
-    static bool s_done = false;
-    if (s_done) return s_solver;
-    s_done = true;
-
-    static std::vector<const char*> s_argv;
-    static std::string s_program = Verilated::threadContextp()->solverProgram();
-    s_argv.emplace_back(&s_program[0]);
-    for (char* arg = &s_program[0]; *arg; arg++) {
-        if (*arg == ' ') {
-            *arg = '\0';
-            s_argv.emplace_back(arg + 1);
-        }
-    }
-    s_argv.emplace_back(nullptr);
-
-    const char* const* const cmd = &s_argv[0];
-    s_solver.open(cmd);
-    s_solver << "(set-logic QF_BV)\n";
-    s_solver << "(check-sat)\n";
-    s_solver << "(reset)\n";
-    std::string s;
-    getline(s_solver, s);
-    if (s == "sat") return s_solver;
-
-    std::stringstream msg;
-    msg << "Unable to communicate with SAT solver, please check its installation or specify a "
-           "different one in VERILATOR_SOLVER environment variable.\n";
-    msg << " ... Tried: $";
-    for (const char* const* arg = cmd; *arg; arg++) msg << ' ' << *arg;
-    msg << '\n';
-    const std::string str = msg.str();
-    VL_WARN_MT("", 0, "randomize", str.c_str());
-
-    while (getline(s_solver, s)) {}
-    return s_solver;
-}
-
-//======================================================================
-// VlRandomizer:: Methods
-
-void VlRandomVar::emit(std::ostream& s) const { s << m_name; }
-void VlRandomConst::emit(std::ostream& s) const {
-    s << "#b";
-    for (int i = 0; i < m_width; i++) s << (VL_BITISSET_Q(m_val, m_width - i - 1) ? '1' : '0');
-}
-void VlRandomBinOp::emit(std::ostream& s) const {
-    s << '(' << m_op << ' ';
-    m_lhs->emit(s);
-    s << ' ';
-    m_rhs->emit(s);
-    s << ')';
-}
-void VlRandomExtract::emit(std::ostream& s) const {
-    s << "((_ extract " << m_idx << ' ' << m_idx << ") ";
-    m_expr->emit(s);
-    s << ')';
-}
-bool VlRandomVar::set(std::string&& val) const {
-    VlWide<VL_WQ_WORDS_E> qowp;
-    VL_SET_WQ(qowp, 0ULL);
-    WDataOutP owp = qowp;
-    int obits = width();
-    if (obits > VL_QUADSIZE) owp = reinterpret_cast<WDataOutP>(datap());
-    int i;
-    for (i = 0; val[i] && val[i] != '#'; i++) {}
-    if (val[i++] != '#') return false;
-    switch (val[i++]) {
-    case 'b': _vl_vsss_based(owp, obits, 1, &val[i], 0, val.size() - i); break;
-    case 'o': _vl_vsss_based(owp, obits, 3, &val[i], 0, val.size() - i); break;
-    case 'h':  // FALLTHRU
-    case 'x': _vl_vsss_based(owp, obits, 4, &val[i], 0, val.size() - i); break;
-    default:
-        VL_WARN_MT(__FILE__, __LINE__, "randomize",
-                   "Internal: Unable to parse solver's randomized number");
-        return false;
-    }
-    if (obits <= VL_BYTESIZE) {
-        CData* const p = static_cast<CData*>(datap());
-        *p = VL_CLEAN_II(obits, obits, owp[0]);
-    } else if (obits <= VL_SHORTSIZE) {
-        SData* const p = static_cast<SData*>(datap());
-        *p = VL_CLEAN_II(obits, obits, owp[0]);
-    } else if (obits <= VL_IDATASIZE) {
-        IData* const p = static_cast<IData*>(datap());
-        *p = VL_CLEAN_II(obits, obits, owp[0]);
-    } else if (obits <= VL_QUADSIZE) {
-        QData* const p = static_cast<QData*>(datap());
-        *p = VL_CLEAN_QQ(obits, obits, VL_SET_QW(owp));
-    } else {
-        _vl_clean_inplace_w(obits, owp);
-    }
-    return true;
-}
-
-std::shared_ptr<const VlRandomExpr> VlRandomizer::randomConstraint(VlRNG& rngr, int bits) {
-    unsigned long long hash = VL_RANDOM_RNG_I(rngr) & ((1 << bits) - 1);
-    std::shared_ptr<const VlRandomExpr> concat = nullptr;
-    std::vector<std::shared_ptr<const VlRandomExpr>> varbits;
-    for (const auto& var : m_vars) {
-        for (int i = 0; i < var.second->width(); i++)
-            varbits.emplace_back(std::make_shared<const VlRandomExtract>(var.second, i));
-    }
-    for (int i = 0; i < bits; i++) {
-        std::shared_ptr<const VlRandomExpr> bit = nullptr;
-        for (unsigned j = 0; j * 2 < varbits.size(); j++) {
-            unsigned idx = j + VL_RANDOM_RNG_I(rngr) % (varbits.size() - j);
-            auto sel = varbits[idx];
-            std::swap(varbits[idx], varbits[j]);
-            bit = bit == nullptr ? sel : std::make_shared<const VlRandomBinOp>("bvxor", bit, sel);
-        }
-        concat = concat == nullptr ? bit
-                                   : std::make_shared<const VlRandomBinOp>("concat", concat, bit);
-    }
-    return std::make_shared<const VlRandomBinOp>(
-        "=", concat, std::make_shared<const VlRandomConst>(hash, bits));
-}
-
-bool VlRandomizer::next(VlRNG& rngr) {
-    if (m_vars.empty()) return true;
-    std::iostream& f = getSolver();
-    if (!f) return false;
-
-    f << "(set-option :produce-models true)\n";
-    f << "(set-logic QF_BV)\n";
-    for (const auto& var : m_vars) {
-        f << "(declare-fun " << var.second->name() << " () (_ BitVec " << var.second->width()
-          << "))\n";
-    }
-    for (const std::string& constraint : m_constraints) { f << "(assert " << constraint << ")\n"; }
-    f << "(check-sat)\n";
-
-    bool sat = parseSolution(f);
-    if (!sat) {
-        f << "(reset)\n";
-        return false;
-    }
-
-    for (int i = 0; i < _VL_SOLVER_HASH_LEN_TOTAL && sat; i++) {
-        f << "(assert ";
-        randomConstraint(rngr, _VL_SOLVER_HASH_LEN)->emit(f);
-        f << ")\n";
-        f << "\n(check-sat)\n";
-        sat = parseSolution(f);
-    }
-
-    f << "(reset)\n";
-    return true;
-}
-
-bool VlRandomizer::parseSolution(std::iostream& f) {
-    std::string sat;
-    do { std::getline(f, sat); } while (sat == "");
-
-    if (sat == "unsat") return false;
-    if (sat != "sat") {
-        std::stringstream msg;
-        msg << "Internal: Solver error: " << sat;
-        const std::string str = msg.str();
-        VL_WARN_MT(__FILE__, __LINE__, "randomize", str.c_str());
-        return false;
-    }
-
-    f << "(get-value (";
-    for (const auto& var : m_vars) f << var.second->name() << ' ';
-    f << "))\n";
-
-    // Quasi-parse S-expression of the form ((x #xVALUE) (y #bVALUE) (z #xVALUE))
-    char c;
-    f >> c;
-    if (c != '(') {
-        VL_WARN_MT(__FILE__, __LINE__, "randomize",
-                   "Internal: Unable to parse solver's response: invalid S-expression");
-        return false;
-    }
-
-    while (true) {
-        f >> c;
-        if (c == ')') break;
-        if (c != '(') {
-            VL_WARN_MT(__FILE__, __LINE__, "randomize",
-                       "Internal: Unable to parse solver's response: invalid S-expression");
-            return false;
-        }
-
-        std::string name, value;
-        f >> name;
-        std::getline(f, value, ')');
-
-        auto it = m_vars.find(name);
-        if (it == m_vars.end()) continue;
-        const VlRandomVar& varr = *it->second;
-        if (m_randmode && !varr.randModeIdxNone()) {
-            if (!(m_randmode->at(varr.randModeIdx()))) continue;
-        }
-
-        varr.set(std::move(value));
-    }
-
-    return true;
-}
-
-void VlRandomizer::hard(std::string&& constraint) {
-    m_constraints.emplace_back(std::move(constraint));
-}
-
-void VlRandomizer::clear() { m_constraints.clear(); }
-
-#ifdef VL_DEBUG
-void VlRandomizer::dump() const {
-    for (const auto& var : m_vars) {
-        VL_PRINTF("Variable (%d): %s\n", var.second->width(), var.second->name());
-    }
-    for (const std::string& c : m_constraints) VL_PRINTF("Constraint: %s\n", c.c_str());
-}
-#endif
@@ -1,128 +0,0 @@
-// -*- mode: C++; c-file-style: "cc-mode" -*-
-//*************************************************************************
-//
-// Code available from: https://verilator.org
-//
-// Copyright 2024 by Wilson Snyder.  This program is free software; you can
-// redistribute it and/or modify it under the terms of either the GNU Lesser
-// General Public License Version 3 or the Perl Artistic License Version 2.0.
-// SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
-//
-//*************************************************************************
-///
-/// \file
-/// \brief Verilated randomization header
-///
-/// This file is included automatically by Verilator in some of the C++ files
-/// it generates if randomization features are used.
-///
-/// This file is not part of the Verilated public-facing API.
-/// It is only for internal use.
-///
-/// See the internals documentation docs/internals.rst for details.
-///
-//*************************************************************************
-#ifndef VERILATOR_VERILATED_RANDOM_H_
-#define VERILATOR_VERILATED_RANDOM_H_
-
-#include "verilated.h"
-
-//=============================================================================
-// VlRandomExpr and subclasses represent expressions for the constraint solver.
-
-class VlRandomExpr VL_NOT_FINAL {
-public:
-    virtual void emit(std::ostream& s) const = 0;
-};
-class VlRandomVar final : public VlRandomExpr {
-    const char* const m_name;  // Variable name
-    void* const m_datap;  // Reference to variable data
-    const int m_width;  // Variable width in bits
-    const std::uint32_t m_randModeIdx;  // rand_mode index
-
-public:
-    VlRandomVar(const char* name, int width, void* datap, std::uint32_t randModeIdx)
-        : m_name{name}
-        , m_datap{datap}
-        , m_width{width}
-        , m_randModeIdx{randModeIdx} {}
-    const char* name() const { return m_name; }
-    int width() const { return m_width; }
-    void* datap() const { return m_datap; }
-    std::uint32_t randModeIdx() const { return m_randModeIdx; }
-    bool randModeIdxNone() const { return randModeIdx() == std::numeric_limits<unsigned>::max(); }
-    bool set(std::string&&) const;
-    void emit(std::ostream& s) const override;
-};
-
-class VlRandomConst final : public VlRandomExpr {
-    const QData m_val;  // Constant value
-    const int m_width;  // Constant width in bits
-
-public:
-    VlRandomConst(QData val, int width)
-        : m_val{val}
-        , m_width{width} {
-        assert(width <= sizeof(m_val) * 8);
-    }
-    void emit(std::ostream& s) const override;
-};
-
-class VlRandomExtract final : public VlRandomExpr {
-    const std::shared_ptr<const VlRandomExpr> m_expr;  // Sub-expression
-    const unsigned m_idx;  // Extracted index
-
-public:
-    VlRandomExtract(std::shared_ptr<const VlRandomExpr> expr, unsigned idx)
-        : m_expr{expr}
-        , m_idx{idx} {}
-    void emit(std::ostream& s) const override;
-};
-
-class VlRandomBinOp final : public VlRandomExpr {
-    const char* const m_op;  // Binary operation identifier
-    const std::shared_ptr<const VlRandomExpr> m_lhs, m_rhs;  // Sub-expressions
-
-public:
-    VlRandomBinOp(const char* op, std::shared_ptr<const VlRandomExpr> lhs,
-                  std::shared_ptr<const VlRandomExpr> rhs)
-        : m_op{op}
-        , m_lhs{lhs}
-        , m_rhs{rhs} {}
-    void emit(std::ostream& s) const override;
-};
-
-//=============================================================================
-// VlRandomizer is the object holding constraints and variable references.
-
-class VlRandomizer final {
-    // MEMBERS
-    std::vector<std::string> m_constraints;  // Solver-dependent constraints
-    std::map<std::string, std::shared_ptr<const VlRandomVar>> m_vars;  // Solver-dependent
-                                                                       // variables
-    const VlQueue<CData>* m_randmode;  // rand_mode state;
-
-    // PRIVATE METHODS
-    std::shared_ptr<const VlRandomExpr> randomConstraint(VlRNG& rngr, int bits);
-    bool parseSolution(std::iostream& file);
-
-public:
-    // METHODS
-    // Finds the next solution satisfying the constraints
-    bool next(VlRNG& rngr);
-    template <typename T>
-    void write_var(T& var, int width, const char* name,
-                   std::uint32_t randmodeIdx = std::numeric_limits<std::uint32_t>::max()) {
-        auto it = m_vars.find(name);
-        if (it != m_vars.end()) return;
-        m_vars[name] = std::make_shared<const VlRandomVar>(name, width, &var, randmodeIdx);
-    }
-    void hard(std::string&& constraint);
-    void clear();
-    void set_randmode(const VlQueue<CData>& randmode) { m_randmode = &randmode; }
-#ifdef VL_DEBUG
-    void dump() const;
-#endif
-};
-
-#endif  // Guard
@@ -95,7 +95,8 @@ void VerilatedDeserialize::header() VL_MT_UNSAFE_ONE {
    if (VL_UNLIKELY(os.readDiffers(VLTSAVE_HEADER_STR, std::strlen(VLTSAVE_HEADER_STR)))) {
        const std::string fn = filename();
        const std::string msg
-            = "Can't deserialize; file has wrong header signature, or file not found: "s
+            = std::
+                  string{"Can't deserialize; file has wrong header signature, or file not found: "}
              + filename();
        VL_FATAL_MT(fn.c_str(), 0, "", msg.c_str());
        // Die before we close() as close would infinite loop
@@ -40,7 +40,7 @@ package std;

      task put(T message);
 `ifdef VERILATOR_TIMING
-         while (m_bound != 0 && m_queue.size() >= m_bound)
+         if (m_bound != 0)
            wait (m_queue.size() < m_bound);
         m_queue.push_back(message);
 `endif
@@ -56,9 +56,7 @@ package std;

      task get(ref T message);
 `ifdef VERILATOR_TIMING
-         while (m_queue.size() == 0) begin
-            wait (m_queue.size() > 0);
-         end
+         wait (m_queue.size() > 0);
         message = m_queue.pop_front();
 `endif
      endtask
@@ -73,9 +71,7 @@ package std;

      task peek(ref T message);
 `ifdef VERILATOR_TIMING
-         while (m_queue.size() == 0) begin
-            wait (m_queue.size() > 0);
-         end
+         wait (m_queue.size() > 0);
         message = m_queue[0];
 `endif
      endtask
@@ -102,9 +98,7 @@ package std;

      task get(int keyCount = 1);
 `ifdef VERILATOR_TIMING
-         while (m_keyCount < keyCount) begin
-            wait (m_keyCount >= keyCount);
-         end
+         wait (m_keyCount >= keyCount);
         m_keyCount -= keyCount;
 `endif
      endtask
@@ -195,7 +189,4 @@ package std;
         $urandom(s.atoi());  // Set the seed using a string
      endfunction
   endclass
-   function int randomize();
-      randomize = 0;
-   endfunction
 endpackage
@@ -59,7 +59,7 @@ void VlDelayScheduler::resume() {
 #endif
    bool resumed = false;

-    while (!m_queue.empty() && (m_queue.cbegin()->first == m_context.time())) {
+    while (!m_queue.empty() && (m_queue.begin()->first == m_context.time())) {
        VlCoroutineHandle handle = std::move(m_queue.begin()->second);
        m_queue.erase(m_queue.begin());
        handle.resume();
@@ -67,16 +67,9 @@ void VlDelayScheduler::resume() {
    }

    if (!m_zeroDelayed.empty()) {
-        // First, we need to move the coroutines out of the queue, as a resumed coroutine can
-        // suspend on #0 again, adding itself to the queue, which can result in reallocating the
-        // queue mid-iteration.
-        // We swap with the m_zeroDlyResumed field to keep the allocated buffer.
-        m_zeroDlyResumed.swap(m_zeroDelayed);
-        for (auto&& handle : m_zeroDlyResumed) handle.resume();
-        m_zeroDlyResumed.clear();
+        for (auto&& handle : m_zeroDelayed) handle.resume();
+        m_zeroDelayed.clear();
        resumed = true;
-        // We are now in the Active region, so any coroutines added to m_zeroDelayed in the
-        // meantime will have to wait until the next Inactive region.
    }

    if (!resumed) {
@@ -87,7 +80,7 @@ void VlDelayScheduler::resume() {
 }

 uint64_t VlDelayScheduler::nextTimeSlot() const {
-    if (!m_queue.empty()) return m_queue.cbegin()->first;
+    if (!m_queue.empty()) return m_queue.begin()->first;
    if (m_zeroDelayed.empty())
        VL_FATAL_MT(__FILE__, __LINE__, "", "%Error: There is no next time slot scheduled");
    return m_context.time();
@@ -32,18 +32,14 @@
 // clang-format off
 // Some preprocessor magic to support both Clang and GCC coroutines with both libc++ and libstdc++
 #if defined _LIBCPP_VERSION  // libc++
-# if defined(__has_include) && !__has_include(<coroutine>) && __has_include(<experimental/coroutine>)
-#  if __clang_major__ > 13  // Clang > 13 warns that coroutine types in std::experimental are deprecated
-#   pragma clang diagnostic push
-#   pragma clang diagnostic ignored "-Wdeprecated-experimental-coroutine"
-#  endif
-#  include <experimental/coroutine>
-   namespace std {
-       using namespace experimental;  // Bring std::experimental into the std namespace
-   }
-# else
-#  include <coroutine>
+# if __clang_major__ > 13  // Clang > 13 warns that coroutine types in std::experimental are deprecated
+#  pragma clang diagnostic push
+#  pragma clang diagnostic ignored "-Wdeprecated-experimental-coroutine"
 # endif
+# include <experimental/coroutine>
+  namespace std {
+      using namespace experimental;  // Bring std::experimental into the std namespace
+  }
 #else
 # if defined __clang__ && defined __GLIBCXX__ && !defined __cpp_impl_coroutine
 #  define __cpp_impl_coroutine 1  // Clang doesn't define this, but it's needed for libstdc++
@@ -169,9 +165,6 @@ class VlDelayScheduler final {
    VerilatedContext& m_context;
    VlDelayedCoroutineQueue m_queue;  // Coroutines to be restored at a certain simulation time
    std::vector<VlCoroutineHandle> m_zeroDelayed;  // Coroutines waiting for #0
-    std::vector<VlCoroutineHandle> m_zeroDlyResumed;  // Coroutines that waited for #0 and are
-                                                      // to be resumed. Kept as a field to avoid
-                                                      // reallocation.

 public:
    // CONSTRUCTORS
@@ -187,7 +180,7 @@ public:
    bool empty() const { return m_queue.empty() && m_zeroDelayed.empty(); }
    // Are there coroutines to resume at the current simulation time?
    bool awaitingCurrentTime() const {
-        return (!m_queue.empty() && (m_queue.cbegin()->first <= m_context.time()))
+        return (!m_queue.empty() && (m_queue.begin()->first <= m_context.time()))
               || !m_zeroDelayed.empty();
    }
 #ifdef VL_DEBUG
@@ -200,9 +193,9 @@ public:
            VlProcessRef process;  // Data of the suspended process, null if not needed
            VlDelayedCoroutineQueue& queue;
            std::vector<VlCoroutineHandle>& queueZeroDelay;
-            const uint64_t delay;
-            const VlDelayPhase phase;
-            const VlFileLineDebug fileline;
+            uint64_t delay;
+            VlDelayPhase phase;
+            VlFileLineDebug fileline;

            bool await_ready() const { return false; }  // Always suspend
            void await_suspend(std::coroutine_handle<> coro) {
@@ -215,7 +208,7 @@ public:
            void await_resume() const {}
        };

-        const VlDelayPhase phase = (delay == 0) ? VlDelayPhase::INACTIVE : VlDelayPhase::ACTIVE;
+        VlDelayPhase phase = (delay == 0) ? VlDelayPhase::INACTIVE : VlDelayPhase::ACTIVE;
 #ifdef VL_DEBUG
        if (phase == VlDelayPhase::INACTIVE) {
            VL_WARN_MT(filename, lineno, VL_UNKNOWN,
@@ -30,9 +30,8 @@
 #include <condition_variable>
 #include <memory>
 #include <string>
-#include <type_traits>
-#include <map>
-#include <set>
+#include <unordered_map>
+#include <unordered_set>
 #include <vector>

 #include <deque>
@@ -180,21 +179,6 @@ public:
        , m_useFstWriterThread{useFstWriterThread} {}
 };

-//=============================================================================
-// VerilatedTraceBaseC - base class of all Verilated*C trace classes
-// Internal use only
-
-class VerilatedTraceBaseC VL_NOT_FINAL {
-    bool m_modelConnected = false;  // Model connected by calling Verilated::trace()
-public:
-    /// True if file currently open
-    virtual bool isOpen() const VL_MT_SAFE = 0;
-
-    // internal use only
-    bool modelConnected() const VL_MT_SAFE { return m_modelConnected; }
-    void modelConnected(bool flag) VL_MT_SAFE { m_modelConnected = flag; }
-};
-
 //=============================================================================
 // VerilatedTrace

@@ -221,6 +205,10 @@ private:
    friend OffloadBuffer;

    struct CallbackRecord final {
+        // Note: would make these fields const, but some old STL implementations
+        // (the one in Ubuntu 14.04 with GCC 4.8.4 in particular) use the
+        // assignment operator on inserting into collections, so they don't work
+        // with const fields...
        union {  // The callback
            const initCb_t m_initCb;
            const dumpCb_t m_dumpCb;
@@ -295,7 +283,7 @@ private:
    uint64_t m_timeLastDump = 0;  // Last time we did a dump
    bool m_didSomeDump = false;  // Did at least one dump (i.e.: m_timeLastDump is valid)
    VerilatedContext* m_contextp = nullptr;  // The context used by the traced models
-    std::set<const VerilatedModel*> m_models;  // The collection of models being traced
+    std::unordered_set<const VerilatedModel*> m_models;  // The collection of models being traced

    void addCallbackRecord(std::vector<CallbackRecord>& cbVec, CallbackRecord&& cbRec)
        VL_MT_SAFE_EXCLUDES(m_mutex);
@@ -594,7 +582,7 @@ public:
        m_offloadBufferWritep[0] = (bits << 4) | VerilatedTraceOffloadCommand::CHG_WDATA;
        m_offloadBufferWritep[1] = code;
        m_offloadBufferWritep += 2;
-        for (int i = 0; i < (bits + 31) / 32; ++i) *m_offloadBufferWritep++ = newvalp[i];
+        for (int i = 0; i < (bits + 31) / 32; ++i) { *m_offloadBufferWritep++ = newvalp[i]; }
        VL_DEBUG_IF(assert(m_offloadBufferWritep <= m_offloadBufferEndp););
    }
    void chgDouble(uint32_t code, double newval) {
@@ -60,6 +60,22 @@ static double timescaleToDouble(const char* unitp) VL_PURE {
    return value;
 }

+static std::string doubleToTimescale(double value) VL_PURE {
+    const char* suffixp = "s";
+    // clang-format off
+    if      (value >= 1e0)   { suffixp = "s"; value *= 1e0; }
+    else if (value >= 1e-3)  { suffixp = "ms"; value *= 1e3; }
+    else if (value >= 1e-6)  { suffixp = "us"; value *= 1e6; }
+    else if (value >= 1e-9)  { suffixp = "ns"; value *= 1e9; }
+    else if (value >= 1e-12) { suffixp = "ps"; value *= 1e12; }
+    else if (value >= 1e-15) { suffixp = "fs"; value *= 1e15; }
+    else if (value >= 1e-18) { suffixp = "as"; value *= 1e18; }
+    // clang-format on
+    char valuestr[100];
+    VL_SNPRINTF(valuestr, 100, "%0.0f%s", value, suffixp);
+    return valuestr;  // Gets converted to string, so no ref to stack
+}
+
 //=========================================================================
 // Buffer management

@@ -174,16 +190,13 @@ void VerilatedTrace<VL_SUB_T, VL_BUF_T>::offloadWorkerThreadMain() {

                //===
                // Rare commands
-            case VerilatedTraceOffloadCommand::TIME_CHANGE: {
+            case VerilatedTraceOffloadCommand::TIME_CHANGE:
                VL_TRACE_OFFLOAD_DEBUG("Command TIME_CHANGE " << top);
                readp -= 1;  // No code in this command, undo increment
-                const uint64_t timeui
-                    = static_cast<uint64_t>(*reinterpret_cast<const uint32_t*>(readp)) << 32ULL
-                      | static_cast<uint64_t>(*reinterpret_cast<const uint32_t*>(readp + 1));
-                emitTimeChange(timeui);
+                emitTimeChange(*reinterpret_cast<const uint64_t*>(readp));
                readp += 2;
                continue;
-            }
+
            case VerilatedTraceOffloadCommand::TRACE_BUFFER:
                VL_TRACE_OFFLOAD_DEBUG("Command TRACE_BUFFER " << top);
                readp -= 1;  // No code in this command, undo increment
@@ -405,7 +418,7 @@ bool VerilatedTrace<VL_SUB_T, VL_BUF_T>::declCode(uint32_t code, const std::stri

 template <>
 std::string VerilatedTrace<VL_SUB_T, VL_BUF_T>::timeResStr() const {
-    return vl_timescaled_double(m_timeRes);
+    return doubleToTimescale(m_timeRes);
 }

 //=========================================================================
@@ -561,10 +574,7 @@ void VerilatedTrace<VL_SUB_T, VL_BUF_T>::dump(uint64_t timeui) VL_MT_SAFE_EXCLUD

            // Tell worker to update time point
            m_offloadBufferWritep[0] = VerilatedTraceOffloadCommand::TIME_CHANGE;
-            *reinterpret_cast<uint32_t*>(m_offloadBufferWritep + 1)
-                = static_cast<uint32_t>(timeui >> 32ULL);
-            *reinterpret_cast<uint32_t*>(m_offloadBufferWritep + 2)
-                = static_cast<uint32_t>(timeui);
+            *reinterpret_cast<uint64_t*>(m_offloadBufferWritep + 1) = timeui;
            m_offloadBufferWritep += 3;
        } else {
            // Update time point
@@ -633,13 +643,12 @@ void VerilatedTrace<VL_SUB_T, VL_BUF_T>::addModel(VerilatedModel* modelp)

    // Validate
    if (!newModel) {  // LCOV_EXCL_START
-        VL_FATAL_MT(
-            __FILE__, __LINE__, "",
-            "The same model has already been added to this trace file or VerilatedContext");
+        VL_FATAL_MT(__FILE__, __LINE__, "",
+                    "The same model has already been added to this trace file");
    }
    if (VL_UNCOVERABLE(m_contextp && contextp != m_contextp)) {
        VL_FATAL_MT(__FILE__, __LINE__, "",
-                    "A trace file instance can only handle models from the same VerilatedContext");
+                    "A trace file instance can only handle models from the same context");
    }
    if (VL_UNCOVERABLE(m_didSomeDump)) {
        VL_FATAL_MT(__FILE__, __LINE__, "",
@@ -36,6 +36,7 @@
 #include <memory>
 #include <set>
 #include <string>
+#include <unordered_set>
 #include <utility>

 //=========================================================================
@@ -414,20 +415,8 @@ public:

 static int _vl_cmp_w(int words, WDataInP const lwp, WDataInP const rwp) VL_PURE;

-template <std::size_t T_Words>
-struct VlWide;
-
-// Type trait to check if a type is VlWide
-template <typename>
-struct VlIsVlWide : public std::false_type {};
-
-template <std::size_t T_Words>
-struct VlIsVlWide<VlWide<T_Words>> : public std::true_type {};
-
 template <std::size_t T_Words>
 struct VlWide final {
-    static constexpr size_t Words = T_Words;
-
    // MEMBERS
    // This should be the only data member, otherwise generated static initializers need updating
    EData m_storage[T_Words];  // Contents of the packed array
@@ -512,29 +501,28 @@ public:
        return *this;
    }

-    // Construct new object from _V_alue and/or _C_ontainer child objects
-    static VlQueue consV(const T_Value& lhs) {
+    static VlQueue cons(const T_Value& lhs) {
        VlQueue out;
        out.push_back(lhs);
        return out;
    }
-    static VlQueue consVV(const T_Value& lhs, const T_Value& rhs) {
+    static VlQueue cons(const T_Value& lhs, const T_Value& rhs) {
        VlQueue out;
        out.push_back(rhs);
        out.push_back(lhs);
        return out;
    }
-    static VlQueue consCV(const VlQueue& lhs, const T_Value& rhs) {
+    static VlQueue cons(const VlQueue& lhs, const T_Value& rhs) {
        VlQueue out = lhs;
        out.push_front(rhs);
        return out;
    }
-    static VlQueue consVC(const T_Value& lhs, const VlQueue& rhs) {
+    static VlQueue cons(const T_Value& lhs, const VlQueue& rhs) {
        VlQueue out = rhs;
        out.push_back(lhs);
        return out;
    }
-    static VlQueue consCC(const VlQueue& lhs, const VlQueue& rhs) {
+    static VlQueue cons(const VlQueue& lhs, const VlQueue& rhs) {
        VlQueue out = rhs;
        for (const auto& i : lhs.m_deque) out.push_back(i);
        return out;
@@ -627,7 +615,7 @@ public:

    // inside (set membership operator)
    bool inside(const T_Value& value) const {
-        return std::find(m_deque.cbegin(), m_deque.cend(), value) != m_deque.cend();
+        return std::find(m_deque.begin(), m_deque.end(), value) != m_deque.end();
    }

    // Return slice q[lsb:msb]
@@ -752,7 +740,7 @@ public:
        // Can't use std::find_if as need index number
        IData index = 0;
        for (const auto& i : m_deque) {
-            if (with_func(index, i)) return VlQueue::consV(i);
+            if (with_func(index, i)) return VlQueue::cons(i);
            ++index;
        }
        return VlQueue{};
@@ -761,7 +749,7 @@ public:
    VlQueue<IData> find_first_index(Func with_func) const {
        IData index = 0;
        for (const auto& i : m_deque) {
-            if (with_func(index, i)) return VlQueue<IData>::consV(index);
+            if (with_func(index, i)) return VlQueue<IData>::cons(index);
            ++index;
        }
        return VlQueue<IData>{};
@@ -770,7 +758,7 @@ public:
    VlQueue find_last(Func with_func) const {
        IData index = m_deque.size() - 1;
        for (auto& item : vlstd::reverse_view(m_deque)) {
-            if (with_func(index, item)) return VlQueue::consV(item);
+            if (with_func(index, item)) return VlQueue::cons(item);
            --index;
        }
        return VlQueue{};
@@ -779,7 +767,7 @@ public:
    VlQueue<IData> find_last_index(Func with_func) const {
        IData index = m_deque.size() - 1;
        for (auto& item : vlstd::reverse_view(m_deque)) {
-            if (with_func(index, item)) return VlQueue<IData>::consV(index);
+            if (with_func(index, item)) return VlQueue<IData>::cons(index);
            --index;
        }
        return VlQueue<IData>{};
@@ -788,31 +776,31 @@ public:
    // Reduction operators
    VlQueue min() const {
        if (m_deque.empty()) return VlQueue{};
-        const auto it = std::min_element(m_deque.cbegin(), m_deque.cend());
-        return VlQueue::consV(*it);
+        const auto it = std::min_element(m_deque.begin(), m_deque.end());
+        return VlQueue::cons(*it);
    }
    template <typename Func>
    VlQueue min(Func with_func) const {
        if (m_deque.empty()) return VlQueue{};
-        const auto it = std::min_element(m_deque.cbegin(), m_deque.cend(),
+        const auto it = std::min_element(m_deque.begin(), m_deque.end(),
                                         [&with_func](const IData& a, const IData& b) {
                                             return with_func(0, a) < with_func(0, b);
                                         });
-        return VlQueue::consV(*it);
+        return VlQueue::cons(*it);
    }
    VlQueue max() const {
        if (m_deque.empty()) return VlQueue{};
-        const auto it = std::max_element(m_deque.cbegin(), m_deque.cend());
-        return VlQueue::consV(*it);
+        const auto it = std::max_element(m_deque.begin(), m_deque.end());
+        return VlQueue::cons(*it);
    }
    template <typename Func>
    VlQueue max(Func with_func) const {
        if (m_deque.empty()) return VlQueue{};
-        const auto it = std::max_element(m_deque.cbegin(), m_deque.cend(),
+        const auto it = std::max_element(m_deque.begin(), m_deque.end(),
                                         [&with_func](const IData& a, const IData& b) {
                                             return with_func(0, a) < with_func(0, b);
                                         });
-        return VlQueue::consV(*it);
+        return VlQueue::cons(*it);
    }

    T_Value r_sum() const {
@@ -829,40 +817,40 @@ public:
    }
    T_Value r_product() const {
        if (m_deque.empty()) return T_Value(0);
-        auto it = m_deque.cbegin();
+        auto it = m_deque.begin();
        T_Value out{*it};
        ++it;
-        for (; it != m_deque.cend(); ++it) out *= *it;
+        for (; it != m_deque.end(); ++it) out *= *it;
        return out;
    }
    template <typename Func>
    T_Value r_product(Func with_func) const {
        if (m_deque.empty()) return T_Value(0);
-        auto it = m_deque.cbegin();
+        auto it = m_deque.begin();
        IData index = 0;
        T_Value out{with_func(index, *it)};
        ++it;
        ++index;
-        for (; it != m_deque.cend(); ++it) out *= with_func(index++, *it);
+        for (; it != m_deque.end(); ++it) out *= with_func(index++, *it);
        return out;
    }
    T_Value r_and() const {
        if (m_deque.empty()) return T_Value(0);
-        auto it = m_deque.cbegin();
+        auto it = m_deque.begin();
        T_Value out{*it};
        ++it;
-        for (; it != m_deque.cend(); ++it) out &= *it;
+        for (; it != m_deque.end(); ++it) out &= *it;
        return out;
    }
    template <typename Func>
    T_Value r_and(Func with_func) const {
        if (m_deque.empty()) return T_Value(0);
-        auto it = m_deque.cbegin();
+        auto it = m_deque.begin();
        IData index = 0;
        T_Value out{with_func(index, *it)};
        ++it;
        ++index;
-        for (; it != m_deque.cend(); ++it) out &= with_func(index, *it);
+        for (; it != m_deque.end(); ++it) out &= with_func(index, *it);
        return out;
    }
    T_Value r_or() const {
@@ -903,8 +891,8 @@ public:
    }
 };

-template <class T_Value, size_t T_MaxSize>
-std::string VL_TO_STRING(const VlQueue<T_Value, T_MaxSize>& obj) {
+template <class T_Value>
+std::string VL_TO_STRING(const VlQueue<T_Value>& obj) {
    return obj.to_string();
 }

@@ -960,7 +948,7 @@ public:
    // Return last element.  Verilog: function int last(ref index)
    int last(T_Key& indexr) const {
        const auto it = m_map.crbegin();
-        if (it == m_map.crend()) return 0;
+        if (it == m_map.rend()) return 0;
        indexr = it->first;
        return 1;
    }
@@ -1089,76 +1077,78 @@ public:
    template <typename Func>
    VlQueue<T_Value> find_first(Func with_func) const {
        const auto it
-            = std::find_if(m_map.cbegin(), m_map.cend(), [=](const std::pair<T_Key, T_Value>& i) {
+            = std::find_if(m_map.begin(), m_map.end(), [=](const std::pair<T_Key, T_Value>& i) {
                  return with_func(i.first, i.second);
              });
        if (it == m_map.end()) return VlQueue<T_Value>{};
-        return VlQueue<T_Value>::consV(it->second);
+        return VlQueue<T_Value>::cons(it->second);
    }
    template <typename Func>
    VlQueue<T_Key> find_first_index(Func with_func) const {
        const auto it
-            = std::find_if(m_map.cbegin(), m_map.cend(), [=](const std::pair<T_Key, T_Value>& i) {
+            = std::find_if(m_map.begin(), m_map.end(), [=](const std::pair<T_Key, T_Value>& i) {
                  return with_func(i.first, i.second);
              });
        if (it == m_map.end()) return VlQueue<T_Value>{};
-        return VlQueue<T_Key>::consV(it->first);
+        return VlQueue<T_Key>::cons(it->first);
    }
    template <typename Func>
    VlQueue<T_Value> find_last(Func with_func) const {
-        const auto it = std::find_if(
-            m_map.crbegin(), m_map.crend(),
-            [=](const std::pair<T_Key, T_Value>& i) { return with_func(i.first, i.second); });
+        const auto it
+            = std::find_if(m_map.rbegin(), m_map.rend(), [=](const std::pair<T_Key, T_Value>& i) {
+                  return with_func(i.first, i.second);
+              });
        if (it == m_map.rend()) return VlQueue<T_Value>{};
-        return VlQueue<T_Value>::consV(it->second);
+        return VlQueue<T_Value>::cons(it->second);
    }
    template <typename Func>
    VlQueue<T_Key> find_last_index(Func with_func) const {
-        const auto it = std::find_if(
-            m_map.crbegin(), m_map.crend(),
-            [=](const std::pair<T_Key, T_Value>& i) { return with_func(i.first, i.second); });
+        const auto it
+            = std::find_if(m_map.rbegin(), m_map.rend(), [=](const std::pair<T_Key, T_Value>& i) {
+                  return with_func(i.first, i.second);
+              });
        if (it == m_map.rend()) return VlQueue<T_Value>{};
-        return VlQueue<T_Key>::consV(it->first);
+        return VlQueue<T_Key>::cons(it->first);
    }

    // Reduction operators
    VlQueue<T_Value> min() const {
        if (m_map.empty()) return VlQueue<T_Value>();
        const auto it = std::min_element(
-            m_map.cbegin(), m_map.cend(),
+            m_map.begin(), m_map.end(),
            [](const std::pair<T_Key, T_Value>& a, const std::pair<T_Key, T_Value>& b) {
                return a.second < b.second;
            });
-        return VlQueue<T_Value>::consV(it->second);
+        return VlQueue<T_Value>::cons(it->second);
    }
    template <typename Func>
    VlQueue<T_Value> min(Func with_func) const {
        if (m_map.empty()) return VlQueue<T_Value>();
        const auto it = std::min_element(
-            m_map.cbegin(), m_map.cend(),
+            m_map.begin(), m_map.end(),
            [&with_func](const std::pair<T_Key, T_Value>& a, const std::pair<T_Key, T_Value>& b) {
                return with_func(a.first, a.second) < with_func(b.first, b.second);
            });
-        return VlQueue<T_Value>::consV(it->second);
+        return VlQueue<T_Value>::cons(it->second);
    }
    VlQueue<T_Value> max() const {
        if (m_map.empty()) return VlQueue<T_Value>();
        const auto it = std::max_element(
-            m_map.cbegin(), m_map.cend(),
+            m_map.begin(), m_map.end(),
            [](const std::pair<T_Key, T_Value>& a, const std::pair<T_Key, T_Value>& b) {
                return a.second < b.second;
            });
-        return VlQueue<T_Value>::consV(it->second);
+        return VlQueue<T_Value>::cons(it->second);
    }
    template <typename Func>
    VlQueue<T_Value> max(Func with_func) const {
        if (m_map.empty()) return VlQueue<T_Value>();
        const auto it = std::max_element(
-            m_map.cbegin(), m_map.cend(),
+            m_map.begin(), m_map.end(),
            [&with_func](const std::pair<T_Key, T_Value>& a, const std::pair<T_Key, T_Value>& b) {
                return with_func(a.first, a.second) < with_func(b.first, b.second);
            });
-        return VlQueue<T_Value>::consV(it->second);
+        return VlQueue<T_Value>::cons(it->second);
    }

    T_Value r_sum() const {
@@ -1174,36 +1164,36 @@ public:
    }
    T_Value r_product() const {
        if (m_map.empty()) return T_Value(0);
-        auto it = m_map.cbegin();
+        auto it = m_map.begin();
        T_Value out{it->second};
        ++it;
-        for (; it != m_map.cend(); ++it) out *= it->second;
+        for (; it != m_map.end(); ++it) out *= it->second;
        return out;
    }
    template <typename Func>
    T_Value r_product(Func with_func) const {
        if (m_map.empty()) return T_Value(0);
-        auto it = m_map.cbegin();
+        auto it = m_map.begin();
        T_Value out{with_func(it->first, it->second)};
        ++it;
-        for (; it != m_map.cend(); ++it) out *= with_func(it->first, it->second);
+        for (; it != m_map.end(); ++it) out *= with_func(it->first, it->second);
        return out;
    }
    T_Value r_and() const {
        if (m_map.empty()) return T_Value(0);
-        auto it = m_map.cbegin();
+        auto it = m_map.begin();
        T_Value out{it->second};
        ++it;
-        for (; it != m_map.cend(); ++it) out &= it->second;
+        for (; it != m_map.end(); ++it) out &= it->second;
        return out;
    }
    template <typename Func>
    T_Value r_and(Func with_func) const {
        if (m_map.empty()) return T_Value(0);
-        auto it = m_map.cbegin();
+        auto it = m_map.begin();
        T_Value out{with_func(it->first, it->second)};
        ++it;
-        for (; it != m_map.cend(); ++it) out &= with_func(it->first, it->second);
+        for (; it != m_map.end(); ++it) out &= with_func(it->first, it->second);
        return out;
    }
    T_Value r_or() const {
@@ -1321,11 +1311,7 @@ public:
    // Similar to 'neq' above, *this = that used for change detection
    void assign(const VlUnpacked<T_Value, T_Depth>& that) { *this = that; }
    bool operator==(const VlUnpacked<T_Value, T_Depth>& that) const { return !neq(that); }
-    bool operator!=(const VlUnpacked<T_Value, T_Depth>& that) const { return neq(that); }
-    // interface to C style arrays (used in ports), see issue #5125
-    bool neq(const T_Value that[T_Depth]) const { return neq(*this, that); }
-    void assign(const T_Value that[T_Depth]) { std::copy_n(that, T_Depth, m_storage); }
-    void operator=(const T_Value that[T_Depth]) { assign(that); }
+    bool operator!=(const VlUnpacked<T_Value, T_Depth>& that) { return neq(that); }

    // inside (set membership operator)
    bool inside(const T_Value& value) const {
@@ -1402,7 +1388,7 @@ public:
    VlQueue<T_Key> unique_index(Func with_func) const {
        VlQueue<T_Key> out;
        IData index = 0;
-        std::set<T_Value> saw;
+        std::unordered_set<T_Value> saw;
        for (const auto& i : m_storage) {
            const auto i_mapped = with_func(index, i);
            auto it = saw.find(i_mapped);
@@ -1439,7 +1425,7 @@ public:
        // Can't use std::find_if as need index number
        IData index = 0;
        for (const auto& i : m_storage) {
-            if (with_func(index, i)) return VlQueue<T_Value>::consV(i);
+            if (with_func(index, i)) return VlQueue<T_Value>::cons(i);
            ++index;
        }
        return VlQueue<T_Value>{};
@@ -1448,7 +1434,7 @@ public:
    VlQueue<T_Key> find_first_index(Func with_func) const {
        IData index = 0;
        for (const auto& i : m_storage) {
-            if (with_func(index, i)) return VlQueue<IData>::consV(index);
+            if (with_func(index, i)) return VlQueue<IData>::cons(index);
            ++index;
        }
        return VlQueue<T_Key>{};
@@ -1456,14 +1442,14 @@ public:
    template <typename Func>
    VlQueue<T_Value> find_last(Func with_func) const {
        for (int i = T_Depth - 1; i >= 0; i--) {
-            if (with_func(i, m_storage[i])) return VlQueue<T_Value>::consV(m_storage[i]);
+            if (with_func(i, m_storage[i])) return VlQueue<T_Value>::cons(m_storage[i]);
        }
        return VlQueue<T_Value>{};
    }
    template <typename Func>
    VlQueue<T_Key> find_last_index(Func with_func) const {
        for (int i = T_Depth - 1; i >= 0; i--) {
-            if (with_func(i, m_storage[i])) return VlQueue<IData>::consV(i);
+            if (with_func(i, m_storage[i])) return VlQueue<IData>::cons(i);
        }
        return VlQueue<T_Key>{};
    }
@@ -1471,7 +1457,7 @@ public:
    // Reduction operators
    VlQueue<T_Value> min() const {
        const auto it = std::min_element(std::begin(m_storage), std::end(m_storage));
-        return VlQueue<T_Value>::consV(*it);
+        return VlQueue<T_Value>::cons(*it);
    }
    template <typename Func>
    VlQueue<T_Value> min(Func with_func) const {
@@ -1479,11 +1465,11 @@ public:
                                         [&with_func](const IData& a, const IData& b) {
                                             return with_func(0, a) < with_func(0, b);
                                         });
-        return VlQueue<T_Value>::consV(*it);
+        return VlQueue<T_Value>::cons(*it);
    }
    VlQueue<T_Value> max() const {
        const auto it = std::max_element(std::begin(m_storage), std::end(m_storage));
-        return VlQueue<T_Value>::consV(*it);
+        return VlQueue<T_Value>::cons(*it);
    }
    template <typename Func>
    VlQueue<T_Value> max(Func with_func) const {
@@ -1491,7 +1477,7 @@ public:
                                         [&with_func](const IData& a, const IData& b) {
                                             return with_func(0, a) < with_func(0, b);
                                         });
-        return VlQueue<T_Value>::consV(*it);
+        return VlQueue<T_Value>::cons(*it);
    }

    // Dumping. Verilog: str = $sformatf("%p", assoc)
@@ -1515,15 +1501,6 @@ private:
        return false;
    }

-    template <typename T_Val, std::size_t T_Dep>
-    static bool neq(const VlUnpacked<T_Val, T_Dep>& a, const T_Val b[T_Dep]) {
-        for (size_t i = 0; i < T_Dep; ++i) {
-            // Recursive 'neq', in case T_Val is also a VlUnpacked<_, _>
-            if (neq(a.m_storage[i], b[i])) return true;
-        }
-        return false;
-    }
-
    template <typename T_Other>  //
    static bool neq(const T_Other& a, const T_Other& b) {
        // Base case (T_Other is not VlUnpacked<_, _>), fall back on !=
@@ -1536,181 +1513,6 @@ std::string VL_TO_STRING(const VlUnpacked<T_Value, T_Depth>& obj) {
    return obj.to_string();
 }

-//===================================================================
-// Helper to apply the given indices to a target expression
-
-template <size_t Curr, size_t Rank, typename T_Target>
-struct VlApplyIndices final {
-    VL_ATTR_ALWINLINE
-    static auto& apply(T_Target& target, const size_t* indicesp) {
-        return VlApplyIndices<Curr + 1, Rank, decltype(target[indicesp[Curr]])>::apply(
-            target[indicesp[Curr]], indicesp);
-    }
-};
-
-template <size_t Rank, typename T_Target>
-struct VlApplyIndices<Rank, Rank, T_Target> final {
-    VL_ATTR_ALWINLINE
-    static T_Target& apply(T_Target& target, const size_t*) { return target; }
-};
-
-//===================================================================
-// Commit queue for NBAs - currently only for unpacked arrays
-//
-// This data-structure is used to handle non-blocking assignments
-// that might execute a variable number of times in a single
-// evaluation. It has 2 operations:
-// - 'enqueue' will add an update to the queue
-// - 'commit' will apply all enqueued updates to the target variable,
-//   in the order they were enqueued. This ensures the last NBA
-//   takes effect as it is expected.
-// There are 2 specializations of this class below:
-// - A version when a partial element update is not required,
-//   e.g, to handle:
-//      logic [31:0] array[N];
-//      for (int i = 0 ; i < N ; ++i) array[i] <= x;
-//   Here 'enqueue' takes the RHS ('x'), and the array indices ('i')
-//   as arguments.
-// - A different version when a partial element update is required,
-//   e.g. for:
-//      logic [31:0] array[N];
-//      for (int i = 0 ; i < N ; ++i) array[i][3:1] <= y;
-//   Here 'enqueue' takes one additional argument, which is a bitmask
-//   derived from the bit selects (_[3:1]), which masks the bits that
-//   need to be updated, and additionally the RHS is widened to a full
-//   element size, with the bits inserted into the masked region.
-template <typename T_Target,  // Type of the variable this commit queue updates
-          bool Partial,  // Whether partial element updates are necessary
-          // The following we could figure out from 'T_Target using type traits, but passing
-          // explicitly to avoid template expansion, as Verilator already knows them
-          typename T_Element,  // Non-array leaf element type of T_Target array
-          std::size_t T_Rank  // Rank of T_Target (i.e.: how many dimensions it has)
-          >
-class VlNBACommitQueue;
-
-// Specialization for whole element updates only
-template <typename T_Target, typename T_Element, std::size_t T_Rank>
-class VlNBACommitQueue<T_Target, /* Partial: */ false, T_Element, T_Rank> final {
-    // TYPES
-    struct Entry final {
-        T_Element value;
-        size_t indices[T_Rank];
-    };
-
-    // STATE
-    std::vector<Entry> m_pending;  // Pending updates, in program order
-
-public:
-    // CONSTRUCTOR
-    VlNBACommitQueue() = default;
-    VL_UNCOPYABLE(VlNBACommitQueue);
-
-    // METHODS
-    template <typename... Args>
-    void enqueue(const T_Element& value, Args... indices) {
-        m_pending.emplace_back(Entry{value, {indices...}});
-    }
-
-    // Note: T_Commit might be different from T_Target. Specifically, when the signal is a
-    // top-level IO port, T_Commit will be a native C array, while T_Target, will be a VlUnpacked
-    template <typename T_Commit>
-    void commit(T_Commit& target) {
-        if (m_pending.empty()) return;
-        for (const Entry& entry : m_pending) {
-            VlApplyIndices<0, T_Rank, T_Commit>::apply(target, entry.indices) = entry.value;
-        }
-        m_pending.clear();
-    }
-};
-
-// With partial element updates
-template <typename T_Target, typename T_Element, std::size_t T_Rank>
-class VlNBACommitQueue<T_Target, /* Partial: */ true, T_Element, T_Rank> final {
-    // TYPES
-    struct Entry final {
-        T_Element value;
-        T_Element mask;
-        size_t indices[T_Rank];
-    };
-
-    // STATE
-    std::vector<Entry> m_pending;  // Pending updates, in program order
-
-    // STATIC METHODS
-
-    // Binary & | ~ for elements to use for masking in partial updates. Sorry for the templates.
-    template <typename T>
-    VL_ATTR_ALWINLINE static typename std::enable_if<!VlIsVlWide<T>::value, T>::type
-    bAnd(const T& a, const T& b) {
-        return a & b;
-    }
-
-    template <typename T>
-    VL_ATTR_ALWINLINE static typename std::enable_if<VlIsVlWide<T>::value, T>::type
-    bAnd(const T& a, const T& b) {
-        T result;
-        for (size_t i = 0; i < T::Words; ++i) {
-            result.m_storage[i] = a.m_storage[i] & b.m_storage[i];
-        }
-        return result;
-    }
-
-    template <typename T>
-    VL_ATTR_ALWINLINE static typename std::enable_if<!VlIsVlWide<T>::value, T>::type
-    bOr(const T& a, const T& b) {
-        return a | b;
-    }
-
-    template <typename T>
-    VL_ATTR_ALWINLINE static typename std::enable_if<VlIsVlWide<T>::value, T>::type  //
-    bOr(const T& a, const T& b) {
-        T result;
-        for (size_t i = 0; i < T::Words; ++i) {
-            result.m_storage[i] = a.m_storage[i] | b.m_storage[i];
-        }
-        return result;
-    }
-
-    template <typename T>
-    VL_ATTR_ALWINLINE static typename std::enable_if<!VlIsVlWide<T>::value, T>::type
-    bNot(const T& a) {
-        return ~a;
-    }
-
-    template <typename T>
-    VL_ATTR_ALWINLINE static typename std::enable_if<VlIsVlWide<T>::value, T>::type
-    bNot(const T& a) {
-        T result;
-        for (size_t i = 0; i < T::Words; ++i) result.m_storage[i] = ~a.m_storage[i];
-        return result;
-    }
-
-public:
-    // CONSTRUCTOR
-    VlNBACommitQueue() = default;
-    VL_UNCOPYABLE(VlNBACommitQueue);
-
-    // METHODS
-    template <typename... Args>
-    void enqueue(const T_Element& value, const T_Element& mask, Args... indices) {
-        m_pending.emplace_back(Entry{value, mask, {indices...}});
-    }
-
-    // Note: T_Commit might be different from T_Target. Specifically, when the signal is a
-    // top-level IO port, T_Commit will be a native C array, while T_Target, will be a VlUnpacked
-    template <typename T_Commit>
-    void commit(T_Commit& target) {
-        if (m_pending.empty()) return;
-        for (const Entry& entry : m_pending) {  //
-            auto& ref = VlApplyIndices<0, T_Rank, T_Commit>::apply(target, entry.indices);
-            // Maybe inefficient, but it works for now ...
-            const auto oldValue = ref;
-            ref = bOr(bAnd(entry.value, entry.mask), bAnd(oldValue, bNot(entry.mask)));
-        }
-        m_pending.clear();
-    }
-};
-
 //===================================================================
 // Object that VlDeleter is capable of deleting

@@ -1787,16 +1589,12 @@ public:
 };

 //===================================================================
-// Represents the null pointer. Used for:
-// * setting VlClassRef to null instead of via nullptr_t, to prevent the implicit conversion of 0
-//   to nullptr,
-// * comparing interface pointers to null.
+// Represents the null pointer. Used for setting VlClassRef to null instead of
+// via nullptr_t, to prevent the implicit conversion of 0 to nullptr.

 struct VlNull final {
    operator bool() const { return false; }
-    bool operator==(void* ptr) const { return !ptr; }
 };
-inline bool operator==(void* ptr, VlNull) { return !ptr; }

 //===================================================================
 // Verilog class reference container
@@ -1909,7 +1707,7 @@ public:
    T_Class* operator->() const { return m_objp; }
    // For 'if (ptr)...'
    operator bool() const { return m_objp; }
-    // In SV A == B iff both are handles to the same object (IEEE 1800-2023 8.4)
+    // In SV A == B iff both are handles to the same object (IEEE 1800-2017 8.4)
    template <typename T_OtherClass>
    bool operator==(const VlClassRef<T_OtherClass>& rhs) const {
        return m_objp == rhs.m_objp;
@@ -268,7 +268,7 @@ void VerilatedVcd::bufferFlush() VL_MT_UNSAFE_ONE {
    // We add output data to m_writep.
    // When it gets nearly full we dump it using this routine which calls write()
    // This is much faster than using buffered I/O
-    if (VL_UNLIKELY(!m_isOpen)) return;
+    if (VL_UNLIKELY(!isOpen())) return;
    const char* wp = m_wrBufp;
    while (true) {
        const ssize_t remaining = (m_writep - wp);
@@ -251,7 +251,7 @@ public:
 /// Class representing a VCD dump file in C standalone (no SystemC)
 /// simulations.  Also derived for use in SystemC simulations.

-class VerilatedVcdC VL_NOT_FINAL : public VerilatedTraceBaseC {
+class VerilatedVcdC VL_NOT_FINAL {
    VerilatedVcd m_sptrace;  // Trace file being created

    // CONSTRUCTORS
@@ -267,7 +267,7 @@ public:
    // METHODS - User called

    /// Return if file is open
-    bool isOpen() const override VL_MT_SAFE { return m_sptrace.isOpen(); }
+    bool isOpen() const VL_MT_SAFE { return m_sptrace.isOpen(); }
    /// Open a new VCD file
    /// This includes a complete header dump each time it is called,
    /// just as if this object was deleted and reconstructed.
@@ -283,10 +283,7 @@ public:
    /// first may be removed.  Cat files together to create viewable vcd.
    void rolloverSize(size_t size) VL_MT_SAFE { m_sptrace.rolloverSize(size); }
    /// Close dump
-    void close() VL_MT_SAFE {
-        m_sptrace.close();
-        modelConnected(false);
-    }
+    void close() VL_MT_SAFE { m_sptrace.close(); }
    /// Flush dump
    void flush() VL_MT_SAFE { m_sptrace.flush(); }
    /// Write one cycle of dump data
@@ -31,14 +31,11 @@
 #include "verilated.h"
 #include "verilated_imp.h"

-#include "vltstd/vpi_user.h"
-
-#include <cstdarg>
-#include <cstdio>
 #include <list>
 #include <map>
 #include <set>
 #include <string>
+#include <unordered_set>
 #include <utility>
 #include <vector>

@@ -266,24 +263,33 @@ class VerilatedVpioScope VL_NOT_FINAL : public VerilatedVpio {
 protected:
    const VerilatedScope* const m_scopep;
    bool m_toplevel = false;
-    const char* m_name;
-    const char* m_fullname;

 public:
    explicit VerilatedVpioScope(const VerilatedScope* scopep)
        : m_scopep{scopep} {
-        m_fullname = m_scopep->name();
-        if (std::strncmp(m_fullname, "TOP.", 4) == 0) m_fullname += 4;
-        m_name = m_scopep->identifier();
+        std::string scopename = m_scopep->name();
+        std::string::size_type pos = std::string::npos;
+        // Look for '.' not inside escaped identifier
+        size_t i = 0;
+        while (i < scopename.length()) {
+            if (scopename[i] == '\\') {
+                while (i < scopename.length() && scopename[i] != ' ') ++i;
+                ++i;  // Proc ' ', it should always be there. Then grab '.' on next cycle
+            } else {
+                while (i < scopename.length() && scopename[i] != '.') ++i;
+                if (i < scopename.length()) pos = i++;
+            }
+        }
+        if (VL_UNLIKELY(pos == std::string::npos)) m_toplevel = true;
    }
    ~VerilatedVpioScope() override = default;
    static VerilatedVpioScope* castp(vpiHandle h) {
        return dynamic_cast<VerilatedVpioScope*>(reinterpret_cast<VerilatedVpio*>(h));
    }
-    uint32_t type() const override { return vpiGenScope; }
+    uint32_t type() const override { return vpiScope; }
    const VerilatedScope* scopep() const { return m_scopep; }
-    const char* name() const override { return m_name; }
-    const char* fullname() const override { return m_fullname; }
+    const char* name() const override { return m_scopep->name(); }
+    const char* fullname() const override { return m_scopep->name(); }
    bool toplevel() const { return m_toplevel; }
 };

@@ -463,29 +469,22 @@ public:
 };

 class VerilatedVpioModule final : public VerilatedVpioScope {
+    const char* m_name;
+    const char* m_fullname;

 public:
    explicit VerilatedVpioModule(const VerilatedScope* modulep)
        : VerilatedVpioScope{modulep} {
-        // Look for '.' not inside escaped identifier
-        const std::string scopename = m_fullname;
-        std::string::size_type pos = std::string::npos;
-        size_t i = 0;
-        while (i < scopename.length()) {
-            if (scopename[i] == '\\') {
-                while (i < scopename.length() && scopename[i] != ' ') ++i;
-                ++i;  // Proc ' ', it should always be there. Then grab '.' on next cycle
-            } else {
-                while (i < scopename.length() && scopename[i] != '.') ++i;
-                if (i < scopename.length()) pos = i++;
-            }
-        }
-        if (VL_UNLIKELY(pos == std::string::npos)) m_toplevel = true;
+        m_fullname = m_scopep->name();
+        if (std::strncmp(m_fullname, "TOP.", 4) == 0) m_fullname += 4;
+        m_name = m_scopep->identifier();
    }
    static VerilatedVpioModule* castp(vpiHandle h) {
        return dynamic_cast<VerilatedVpioModule*>(reinterpret_cast<VerilatedVpio*>(h));
    }
    uint32_t type() const override { return vpiModule; }
+    const char* name() const override { return m_name; }
+    const char* fullname() const override { return m_fullname; }
 };

 class VerilatedVpioModuleIter final : public VerilatedVpio {
@@ -508,8 +507,8 @@ public:
                delete this;  // IEEE 37.2.2 vpi_scan at end does a vpi_release_handle
                return nullptr;
            }
+            const VerilatedScope::Type itype = (*m_it)->type();
            const VerilatedScope* const modp = *m_it++;
-            const VerilatedScope::Type itype = modp->type();
            if (itype == VerilatedScope::SCOPE_MODULE) {
                return (new VerilatedVpioModule{modp})->castVpiHandle();
            }
@@ -517,54 +516,26 @@ public:
    }
 };

-class VerilatedVpioScopeIter final : public VerilatedVpio {
-    const std::vector<const VerilatedScope*>* m_vec;
-    std::vector<const VerilatedScope*>::const_iterator m_it;
-
-public:
-    explicit VerilatedVpioScopeIter(const std::vector<const VerilatedScope*>& vec)
-        : m_vec{&vec} {
-        m_it = m_vec->begin();
-    }
-    ~VerilatedVpioScopeIter() override = default;
-    static VerilatedVpioScopeIter* castp(vpiHandle h) {
-        return dynamic_cast<VerilatedVpioScopeIter*>(reinterpret_cast<VerilatedVpio*>(h));
-    }
-    uint32_t type() const override { return vpiIterator; }
-    vpiHandle dovpi_scan() override {
-        while (true) {
-            if (m_it == m_vec->end()) {
-                delete this;  // IEEE 37.2.2 vpi_scan at end does a vpi_release_handle
-                return nullptr;
-            }
-            const VerilatedScope* const modp = *m_it++;
-            const VerilatedScope::Type itype = modp->type();
-            if (itype == VerilatedScope::SCOPE_OTHER) {
-                return (new VerilatedVpioScope{modp})->castVpiHandle();
-            } else if (itype == VerilatedScope::SCOPE_MODULE) {
-                return (new VerilatedVpioModule{modp})->castVpiHandle();
-            }
-        }
-    }
-};
-
-static const char* d_unit = "$unit";
 class VerilatedVpioPackage final : public VerilatedVpioScope {
-    std::string m_fullname_string;
+    std::string m_name;
+    std::string m_fullname;

 public:
    explicit VerilatedVpioPackage(const VerilatedScope* modulep)
        : VerilatedVpioScope{modulep} {
-        m_fullname_string = std::string{m_fullname} + "::";
-        if (m_fullname_string == "\\$unit ::") m_fullname_string = "$unit::";
-
-        if (strcmp(m_name, "\\$unit ") == 0) m_name = d_unit;
+        const char* sfullname = m_scopep->name();
+        if (std::strncmp(sfullname, "TOP.", 4) == 0) sfullname += 4;
+        m_fullname = std::string{sfullname} + "::";
+        if (m_fullname == "\\$unit ::") m_fullname = "$unit::";
+        m_name = std::string(m_scopep->identifier());
+        if (m_name == "\\$unit ") m_name = "$unit";
    }
    static VerilatedVpioPackage* castp(vpiHandle h) {
        return dynamic_cast<VerilatedVpioPackage*>(reinterpret_cast<VerilatedVpio*>(h));
    }
-    const char* fullname() const override { return m_fullname_string.c_str(); }
    uint32_t type() const override { return vpiPackage; }
+    const char* name() const override { return m_name.c_str(); }
+    const char* fullname() const override { return m_fullname.c_str(); }
 };

 class VerilatedVpioInstanceIter final : public VerilatedVpio {
@@ -633,146 +604,6 @@ public:
    void invalidate() { m_id = 0; }
 };

-class VerilatedVpiPutHolder final {
-    VerilatedVpioVar m_var;
-    s_vpi_value m_value;
-    union Storage {
-        char init = 0;  // to ensure trivial constructor
-        std::string str;
-        std::vector<s_vpi_vecval> vec;
-        ~Storage() noexcept {/* handled by VerilatedVpiPutHolder */};
-    } m_storage{};
-
-public:
-    VerilatedVpiPutHolder(const VerilatedVpioVar* vop, p_vpi_value valuep)
-        : m_var{vop} {
-        m_value.format = valuep->format;
-        switch (valuep->format) {
-        case vpiBinStrVal:  // FALLTHRU
-        case vpiOctStrVal:  // FALLTHRU
-        case vpiDecStrVal:  // FALLTHRU
-        case vpiHexStrVal:  // FALLTHRU
-        case vpiStringVal: {
-            new (&m_storage.str) std::string{valuep->value.str};
-            m_value.value.str = const_cast<char*>(m_storage.str.c_str());
-            break;
-        }
-        case vpiScalarVal: {
-            m_value.value.scalar = valuep->value.scalar;
-            break;
-        }
-        case vpiIntVal: {
-            m_value.value.integer = valuep->value.integer;
-            break;
-        }
-        case vpiRealVal: {
-            m_value.value.real = valuep->value.real;
-            break;
-        }
-        case vpiVectorVal: {
-            size_t words = 0;
-            switch (vop->varp()->vltype()) {
-            case VLVT_UINT8:
-            case VLVT_UINT16:
-            case VLVT_UINT32: {
-                words = 1;
-                break;
-            }
-            case VLVT_UINT64: {
-                words = 2;
-                break;
-            }
-            case VLVT_WDATA: {
-                words = VL_WORDS_I(vop->varp()->packed().elements());
-                break;
-            }
-            default: break;
-            }
-            new (&m_storage.vec)
-                std::vector<s_vpi_vecval>{valuep->value.vector, &valuep->value.vector[words]};
-            m_value.value.vector = m_storage.vec.data();
-            break;
-        }
-        }
-    }
-
-    VerilatedVpiPutHolder(VerilatedVpiPutHolder const& o)
-        : m_var{o.m_var}
-        , m_value{o.m_value} {
-        switch (m_value.format) {
-        case vpiBinStrVal:  // FALLTHRU
-        case vpiOctStrVal:  // FALLTHRU
-        case vpiDecStrVal:  // FALLTHRU
-        case vpiHexStrVal:  // FALLTHRU
-        case vpiStringVal: {
-            new (&m_storage.str) std::string{o.m_storage.str};
-            break;
-        }
-        case vpiVectorVal: {
-            new (&m_storage.vec) std::vector<s_vpi_vecval>{o.m_storage.vec};
-            break;
-        }
-        }
-    }
-
-    VerilatedVpiPutHolder(VerilatedVpiPutHolder&& o) noexcept
-        : m_var{std::move(o.m_var)}
-        , m_value{std::move(o.m_value)} {
-        switch (m_value.format) {
-        case vpiBinStrVal:  // FALLTHRU
-        case vpiOctStrVal:  // FALLTHRU
-        case vpiDecStrVal:  // FALLTHRU
-        case vpiHexStrVal:  // FALLTHRU
-        case vpiStringVal: {
-            new (&m_storage.str) std::string{std::move(o.m_storage.str)};
-            break;
-        }
-        case vpiVectorVal: {
-            new (&m_storage.vec) std::vector<s_vpi_vecval>{std::move(o.m_storage.vec)};
-            break;
-        }
-        }
-    }
-
-    ~VerilatedVpiPutHolder() noexcept {
-        switch (m_value.format) {
-        case vpiBinStrVal:  // FALLTHRU
-        case vpiOctStrVal:  // FALLTHRU
-        case vpiDecStrVal:  // FALLTHRU
-        case vpiHexStrVal:  // FALLTHRU
-        case vpiStringVal: m_storage.str.~basic_string(); break;
-        case vpiVectorVal: m_storage.vec.~vector(); break;
-        }
-    }
-
-    VerilatedVpioVar* varp() { return &m_var; }
-    p_vpi_value valuep() { return &m_value; }
-
-    static bool canInertialDelay(p_vpi_value valuep) {
-        switch (valuep->format) {
-        case vpiBinStrVal:  // FALLTHRU
-        case vpiOctStrVal:  // FALLTHRU
-        case vpiDecStrVal:  // FALLTHRU
-        case vpiHexStrVal:  // FALLTHRU
-        case vpiStringVal: {
-            if (VL_UNLIKELY(!valuep->value.str)) return false;
-            break;
-        }
-        case vpiScalarVal:  // FALLTHRU
-        case vpiIntVal:  // FALLTHRU
-        case vpiRealVal: break;
-        case vpiVectorVal: {
-            if (VL_UNLIKELY(!valuep->value.vector)) return false;
-            break;
-        }
-        default: {
-            return false;
-        }
-        }
-        return true;
-    }
-};
-
 struct VerilatedVpiTimedCbsCmp final {
    // Ordering sets keyed by time, then callback unique id
    bool operator()(const std::pair<QData, uint64_t>& a,
@@ -795,11 +626,9 @@ class VerilatedVpiImp final {
    std::array<VpioCbList, CB_ENUM_MAX_VALUE> m_cbCurrentLists;
    VpioFutureCbs m_futureCbs;  // Time based callbacks for future timestamps
    VpioFutureCbs m_nextCbs;  // cbNextSimTime callbacks
-    std::list<VerilatedVpiPutHolder> m_inertialPuts;  // Pending vpi puts due to vpiInertialDelay
    VerilatedVpiError* m_errorInfop = nullptr;  // Container for vpi error info
    VerilatedAssertOneThread m_assertOne;  // Assert only called from single thread
    uint64_t m_nextCallbackId = 1;  // Id to identify callback
-    bool m_evalNeeded = false;  // Model has had signals updated via vpi_put_value()

    static VerilatedVpiImp& s() {  // Singleton
        static VerilatedVpiImp s_s;
@@ -921,7 +750,7 @@ public:
        assertOneCheck();
        VpioCbList& cbObjList = s().m_cbCurrentLists[cbValueChange];
        bool called = false;
-        std::set<VerilatedVpioVar*> update;  // set of objects to update after callbacks
+        std::unordered_set<VerilatedVpioVar*> update;  // set of objects to update after callbacks
        if (cbObjList.empty()) return called;
        const auto last = std::prev(cbObjList.end());  // prevent looping over newly added elements
        for (auto it = cbObjList.begin(); true;) {
@@ -958,17 +787,6 @@ public:
    }
    static void dumpCbs() VL_MT_UNSAFE_ONE;
    static VerilatedVpiError* error_info() VL_MT_UNSAFE_ONE;  // getter for vpi error info
-    static bool evalNeeded() { return s().m_evalNeeded; }
-    static void evalNeeded(bool evalNeeded) { s().m_evalNeeded = evalNeeded; }
-    static void inertialDelay(const VerilatedVpioVar* vop, p_vpi_value valuep) {
-        s().m_inertialPuts.emplace_back(vop, valuep);
-    }
-    static void doInertialPuts() {
-        for (auto& it : s().m_inertialPuts) {
-            vpi_put_value(it.varp()->castVpiHandle(), it.valuep(), nullptr, vpiNoDelay);
-        }
-        s().m_inertialPuts.clear();
-    }
 };

 //======================================================================
@@ -1071,11 +889,6 @@ PLI_INT32 VerilatedVpioReasonCb::dovpi_remove_cb() {
    return 1;
 }

-void VerilatedVpi::clearEvalNeeded() VL_MT_UNSAFE_ONE { VerilatedVpiImp::evalNeeded(false); }
-bool VerilatedVpi::evalNeeded() VL_MT_UNSAFE_ONE { return VerilatedVpiImp::evalNeeded(); }
-
-void VerilatedVpi::doInertialPuts() VL_MT_UNSAFE_ONE { VerilatedVpiImp::doInertialPuts(); }
-
 //======================================================================
 // VerilatedVpiImp implementation

@@ -2165,21 +1978,13 @@ vpiHandle vpi_iterate(PLI_INT32 type, vpiHandle object) {
        return ((new VerilatedVpioVarIter{vop, true})->castVpiHandle());
    }
    case vpiModule: {
-        const VerilatedVpioScope* const vop = VerilatedVpioScope::castp(object);
+        const VerilatedVpioModule* const vop = VerilatedVpioModule::castp(object);
        const VerilatedHierarchyMap* const map = VerilatedImp::hierarchyMap();
        const VerilatedScope* const modp = vop ? vop->scopep() : nullptr;
        const auto it = vlstd::as_const(map)->find(const_cast<VerilatedScope*>(modp));
        if (it == map->end()) return nullptr;
        return ((new VerilatedVpioModuleIter{it->second})->castVpiHandle());
    }
-    case vpiInternalScope: {
-        const VerilatedVpioScope* const vop = VerilatedVpioScope::castp(object);
-        const VerilatedHierarchyMap* const map = VerilatedImp::hierarchyMap();
-        const VerilatedScope* const modp = vop ? vop->scopep() : nullptr;
-        const auto it = vlstd::as_const(map)->find(const_cast<VerilatedScope*>(modp));
-        if (it == map->end()) return nullptr;
-        return ((new VerilatedVpioScopeIter{it->second})->castVpiHandle());
-    }
    case vpiInstance: {
        if (object) return nullptr;
        const VerilatedHierarchyMap* const map = VerilatedImp::hierarchyMap();
@@ -2355,28 +2160,13 @@ bool vl_check_format(const VerilatedVar* varp, const p_vpi_value valuep, const c
    return status;
 }

-static void vl_strprintf(std::string& buffer, char const* fmt, ...) {
-    va_list args, args_copy;
-    va_start(args, fmt);
-    buffer.clear();
-    // Make copy of args since we may need to call VL_VSNPRINTF more than once
-    va_copy(args_copy, args);
-    // Try VL_VSNPRINTF in existing buffer
-    const int result
-        = VL_VSNPRINTF(const_cast<char*>(buffer.data()), buffer.capacity(), fmt, args_copy);
-    va_end(args_copy);
-    const int required = result + 1;  // Returned size doesn't include NUL terminator
-    // If there wasn't enough space, reallocate and try again
-    if (buffer.capacity() < required) {
-        buffer.reserve(required * 2);
-        VL_VSNPRINTF(const_cast<char*>(buffer.data()), buffer.capacity(), fmt, args);
-    }
-    va_end(args);
-}
-
 void vl_get_value(const VerilatedVar* varp, void* varDatap, p_vpi_value valuep,
                  const char* fullname) {
    if (!vl_check_format(varp, valuep, fullname, true)) return;
+    // Maximum required size is for binary string, one byte per bit plus null termination
+    static thread_local char t_outStr[VL_VALUE_STRING_MAX_WORDS * VL_EDATASIZE + 1];
+    // cppcheck-suppress variableScope
+    static const thread_local int t_outStrSz = sizeof(t_outStr) - 1;
    // string data type is dynamic and may vary in size during simulation
    static thread_local std::string t_outDynamicStr;
    // We used to presume vpiValue.format = vpiIntVal or if single bit vpiScalarVal
@@ -2420,21 +2210,43 @@ void vl_get_value(const VerilatedVar* varp, void* varDatap, p_vpi_value valuep,
            return;
        }
    } else if (valuep->format == vpiBinStrVal) {
+        valuep->value.str = t_outStr;
        int bits = varp->packed().elements();
-        t_outDynamicStr.resize(bits);
        const CData* datap = (reinterpret_cast<CData*>(varDatap));
-        for (size_t i = 0; i < bits; ++i) {
-            const char val = (datap[i >> 3] >> (i & 7)) & 1;
-            t_outDynamicStr[bits - i - 1] = val ? '1' : '0';
+        int i;
+        if (bits > t_outStrSz) {
+            // limit maximum size of output to size of buffer to prevent overrun.
+            VL_VPI_WARNING_(
+                __FILE__, __LINE__,
+                "%s: Truncating string value of %s for %s"
+                " as buffer size (%d, VL_VALUE_STRING_MAX_WORDS=%d) is less than required (%d)",
+                __func__, VerilatedVpiError::strFromVpiVal(valuep->format), fullname, t_outStrSz,
+                VL_VALUE_STRING_MAX_WORDS, bits);
+            bits = t_outStrSz;
        }
-        valuep->value.str = const_cast<PLI_BYTE8*>(t_outDynamicStr.c_str());
+        for (i = 0; i < bits; ++i) {
+            const char val = (datap[i >> 3] >> (i & 7)) & 1;
+            t_outStr[bits - i - 1] = val ? '1' : '0';
+        }
+        t_outStr[i] = '\0';
        return;
    } else if (valuep->format == vpiOctStrVal) {
+        valuep->value.str = t_outStr;
        int chars = (varp->packed().elements() + 2) / 3;
-        t_outDynamicStr.resize(chars);
        const int bytes = VL_BYTES_I(varp->packed().elements());
        const CData* datap = (reinterpret_cast<CData*>(varDatap));
-        for (size_t i = 0; i < chars; ++i) {
+        int i;
+        if (chars > t_outStrSz) {
+            // limit maximum size of output to size of buffer to prevent overrun.
+            VL_VPI_WARNING_(
+                __FILE__, __LINE__,
+                "%s: Truncating string value of %s for %s"
+                " as buffer size (%d, VL_VALUE_STRING_MAX_WORDS=%d) is less than required (%d)",
+                __func__, VerilatedVpiError::strFromVpiVal(valuep->format), fullname, t_outStrSz,
+                VL_VALUE_STRING_MAX_WORDS, chars);
+            chars = t_outStrSz;
+        }
+        for (i = 0; i < chars; ++i) {
            const div_t idx = div(i * 3, 8);
            int val = datap[idx.quot];
            if ((idx.quot + 1) < bytes) {
@@ -2453,31 +2265,46 @@ void vl_get_value(const VerilatedVar* varp, void* varDatap, p_vpi_value valuep,
                    val &= (1 << rem) - 1;
                }
            }
-            t_outDynamicStr[chars - i - 1] = '0' + (val & 7);
+            t_outStr[chars - i - 1] = '0' + (val & 7);
        }
-        valuep->value.str = const_cast<PLI_BYTE8*>(t_outDynamicStr.c_str());
+        t_outStr[i] = '\0';
        return;
    } else if (valuep->format == vpiDecStrVal) {
+        valuep->value.str = t_outStr;
+        // outStrSz does not include nullptr termination so add one
        if (varp->vltype() == VLVT_UINT8) {
-            vl_strprintf(t_outDynamicStr, "%hhu",
-                         static_cast<unsigned char>(*(reinterpret_cast<CData*>(varDatap))));
+            VL_SNPRINTF(t_outStr, t_outStrSz + 1, "%hhu",
+                        static_cast<unsigned char>(*(reinterpret_cast<CData*>(varDatap))));
+            return;
        } else if (varp->vltype() == VLVT_UINT16) {
-            vl_strprintf(t_outDynamicStr, "%hu",
-                         static_cast<unsigned short>(*(reinterpret_cast<SData*>(varDatap))));
+            VL_SNPRINTF(t_outStr, t_outStrSz + 1, "%hu",
+                        static_cast<unsigned short>(*(reinterpret_cast<SData*>(varDatap))));
+            return;
        } else if (varp->vltype() == VLVT_UINT32) {
-            vl_strprintf(t_outDynamicStr, "%u",
-                         static_cast<unsigned int>(*(reinterpret_cast<IData*>(varDatap))));
+            VL_SNPRINTF(t_outStr, t_outStrSz + 1, "%u",
+                        static_cast<unsigned int>(*(reinterpret_cast<IData*>(varDatap))));
+            return;
        } else if (varp->vltype() == VLVT_UINT64) {
-            vl_strprintf(t_outDynamicStr, "%llu",
-                         static_cast<unsigned long long>(*(reinterpret_cast<QData*>(varDatap))));
+            VL_SNPRINTF(t_outStr, t_outStrSz + 1, "%llu",
+                        static_cast<unsigned long long>(*(reinterpret_cast<QData*>(varDatap))));
+            return;
        }
-        valuep->value.str = const_cast<PLI_BYTE8*>(t_outDynamicStr.c_str());
-        return;
    } else if (valuep->format == vpiHexStrVal) {
+        valuep->value.str = t_outStr;
        int chars = (varp->packed().elements() + 3) >> 2;
-        t_outDynamicStr.resize(chars);
        const CData* datap = (reinterpret_cast<CData*>(varDatap));
-        for (size_t i = 0; i < chars; ++i) {
+        int i;
+        if (chars > t_outStrSz) {
+            // limit maximum size of output to size of buffer to prevent overrun.
+            VL_VPI_WARNING_(
+                __FILE__, __LINE__,
+                "%s: Truncating string value of %s for %s"
+                " as buffer size (%d, VL_VALUE_STRING_MAX_WORDS=%d) is less than required (%d)",
+                __func__, VerilatedVpiError::strFromVpiVal(valuep->format), fullname, t_outStrSz,
+                VL_VALUE_STRING_MAX_WORDS, chars);
+            chars = t_outStrSz;
+        }
+        for (i = 0; i < chars; ++i) {
            char val = (datap[i >> 1] >> ((i & 1) << 2)) & 15;
            if (i == (chars - 1)) {
                // most significant char, mask off nonexistent bits when vector
@@ -2488,9 +2315,9 @@ void vl_get_value(const VerilatedVar* varp, void* varDatap, p_vpi_value valuep,
                    val &= (1 << rem) - 1;
                }
            }
-            t_outDynamicStr[chars - i - 1] = "0123456789abcdef"[static_cast<int>(val)];
+            t_outStr[chars - i - 1] = "0123456789abcdef"[static_cast<int>(val)];
        }
-        valuep->value.str = const_cast<PLI_BYTE8*>(t_outDynamicStr.c_str());
+        t_outStr[i] = '\0';
        return;
    } else if (valuep->format == vpiStringVal) {
        if (varp->vltype() == VLVT_STRING) {
@@ -2503,15 +2330,26 @@ void vl_get_value(const VerilatedVar* varp, void* varDatap, p_vpi_value valuep,
                return;
            }
        } else {
+            valuep->value.str = t_outStr;
            int bytes = VL_BYTES_I(varp->packed().elements());
-            t_outDynamicStr.resize(bytes);
            const CData* datap = (reinterpret_cast<CData*>(varDatap));
-            for (size_t i = 0; i < bytes; ++i) {
+            int i;
+            if (bytes > t_outStrSz) {
+                // limit maximum size of output to size of buffer to prevent overrun.
+                VL_VPI_WARNING_(__FILE__, __LINE__,
+                                "%s: Truncating string value of %s for %s"
+                                " as buffer size (%d, VL_VALUE_STRING_MAX_WORDS=%d) is less than "
+                                "required (%d)",
+                                __func__, VerilatedVpiError::strFromVpiVal(valuep->format),
+                                fullname, t_outStrSz, VL_VALUE_STRING_MAX_WORDS, bytes);
+                bytes = t_outStrSz;
+            }
+            for (i = 0; i < bytes; ++i) {
                const char val = datap[bytes - i - 1];
                // other simulators replace [leading?] zero chars with spaces, replicate here.
-                t_outDynamicStr[i] = val ? val : ' ';
+                t_outStr[i] = val ? val : ' ';
            }
-            valuep->value.str = const_cast<PLI_BYTE8*>(t_outDynamicStr.c_str());
+            t_outStr[i] = '\0';
            return;
        }
    } else if (valuep->format == vpiIntVal) {
@@ -2560,7 +2398,7 @@ void vpi_get_value(vpiHandle object, p_vpi_value valuep) {
 }

 vpiHandle vpi_put_value(vpiHandle object, p_vpi_value valuep, p_vpi_time /*time_p*/,
-                        PLI_INT32 flags) {
+                        PLI_INT32 /*flags*/) {
    VL_DEBUG_IF_PLI(VL_DBG_MSGF("- vpi: vpi_put_value %p %p\n", object, valuep););
    VerilatedVpiImp::assertOneCheck();
    VL_VPI_ERROR_RESET_();
@@ -2568,24 +2406,11 @@ vpiHandle vpi_put_value(vpiHandle object, p_vpi_value valuep, p_vpi_time /*time_
        VL_VPI_WARNING_(__FILE__, __LINE__, "Ignoring vpi_put_value with nullptr value pointer");
        return nullptr;
    }
-    PLI_INT32 delay_mode = flags & 0xfff;
    if (const VerilatedVpioVar* const vop = VerilatedVpioVar::castp(object)) {
-        if (delay_mode == vpiInertialDelay) {
-            if (!VerilatedVpiPutHolder::canInertialDelay(valuep)) {
-                VL_VPI_WARNING_(
-                    __FILE__, __LINE__,
-                    "%s: Unsupported p_vpi_value as requested for '%s' with vpiInertialDelay",
-                    __func__, vop->fullname());
-                return nullptr;
-            }
-            VerilatedVpiImp::inertialDelay(vop, valuep);
-            return object;
-        }
        VL_DEBUG_IF_PLI(
            VL_DBG_MSGF("- vpi:   vpi_put_value name=%s fmt=%d vali=%d\n", vop->fullname(),
                        valuep->format, valuep->value.integer);
            VL_DBG_MSGF("- vpi:   varp=%p  putatp=%p\n", vop->varp()->datap(), vop->varDatap()););
-        VerilatedVpiImp::evalNeeded(true);

        if (VL_UNLIKELY(!vop->varp()->isPublicRW())) {
            VL_VPI_WARNING_(__FILE__, __LINE__,
@@ -30,7 +30,7 @@
 #include "verilated_syms.h"

 //======================================================================
-// From IEEE 1800-2023 annex M
+// From IEEE 1800-2017 annex M

 #include "vltstd/sv_vpi_user.h"

@@ -54,13 +54,6 @@ public:
    static QData cbNextDeadline() VL_MT_UNSAFE_ONE;
    /// Debug dump of callbacks
    static void dumpCbs() VL_MT_UNSAFE_ONE;
-    /// Checks VPI dirty state (i.e. whether vpi_put_value() has
-    /// been called since the last clearEvalNeeded())
-    static bool evalNeeded() VL_MT_UNSAFE_ONE;
-    /// Clears VPI dirty state (see evalNeeded())
-    static void clearEvalNeeded() VL_MT_UNSAFE_ONE;
-    /// Perform inertially delayed puts
-    static void doInertialPuts() VL_MT_UNSAFE_ONE;

    // Self test, for internal use only
    static void selfTest() VL_MT_UNSAFE_ONE;
@@ -58,9 +58,6 @@
 # define VL_ATTR_PRINTF(fmtArgNum) __attribute__((format(printf, (fmtArgNum), (fmtArgNum) + 1)))
 # define VL_ATTR_PURE __attribute__((pure))
 # define VL_ATTR_UNUSED __attribute__((unused))
-#ifndef VL_ATTR_WARN_UNUSED_RESULT
-# define VL_ATTR_WARN_UNUSED_RESULT __attribute__((warn_unused_result))
-#endif
 # if !defined(_WIN32) && !defined(__MINGW32__)
 // All VL_ATTR_WEAK symbols must be marked with the macOS -U linker flag in verilated.mk.in
 #  define VL_ATTR_WEAK __attribute__((weak))
@@ -167,9 +164,6 @@
 #ifndef VL_ATTR_UNUSED
 # define VL_ATTR_UNUSED  ///< Attribute that function that may be never used
 #endif
-#ifndef VL_ATTR_WARN_UNUSED_RESULT
-# define VL_ATTR_WARN_UNUSED_RESULT  ///< Attribute that return value of function must be used
-#endif
 #ifndef VL_ATTR_WEAK
 # define VL_ATTR_WEAK  ///< Attribute that function external that is optionally defined
 #endif
@@ -343,7 +337,6 @@ extern "C" void __gcov_dump();
 #include <cstdint>
 #include <cinttypes>
 #include <cmath>
-#include <ctime>

 #ifndef VL_NO_LEGACY
 using vluint8_t = uint8_t;  ///< 8-bit unsigned type (backward compatibility)
@@ -611,50 +604,6 @@ static inline double VL_ROUND(double n) {
 #define VL_OFFSETOF(type, field) \
    (reinterpret_cast<size_t>(&(reinterpret_cast<type*>(0x10000000)->field)) - 0x10000000)

-//=========================================================================
-// Time and performance
-
-#include <string>
-
-namespace VlOs {
-
-/// Get environment variable
-extern std::string getenvStr(const std::string& envvar,
-                             const std::string& defaultValue) VL_MT_SAFE;
-extern uint64_t memUsageBytes() VL_MT_SAFE;  ///< Return memory usage in bytes, or 0 if unknown
-
-// Internal: Record CPU time, starting point on construction, and current delta from that
-class DeltaCpuTime final {
-    double m_start{};  // Time constructed at
-    static double gettime() VL_MT_SAFE;
-
-public:
-    // Construct, and if startit is true, start() timer
-    explicit DeltaCpuTime(bool startit) {
-        if (startit) start();
-    }
-    void start() VL_MT_SAFE { m_start = gettime(); }  // Start timer; record current time
-    double deltaTime() const VL_MT_SAFE {  // Return time between now and start()
-        return (m_start == 0.0) ? 0.0 : gettime() - m_start;
-    }
-};
-// Internal: Record wall time, starting point on construction, and current delta from that
-class DeltaWallTime final {
-    double m_start{};  // Time constructed at
-    static double gettime() VL_MT_SAFE;
-
-public:
-    // Construct, and if startit is true, start() timer
-    explicit DeltaWallTime(bool startit) {
-        if (startit) start();
-    }
-    void start() VL_MT_SAFE { m_start = gettime(); }  // Start timer; record current time
-    double deltaTime() const VL_MT_SAFE {  // Return time between now and start()
-        return (m_start == 0.0) ? 0.0 : gettime() - m_start;
-    }
-};
-}  //namespace VlOs
-
 //=========================================================================
 // Conversions

@@ -688,6 +637,14 @@ T const& as_const(T& v) VL_MT_SAFE {
    return v;
 }

+// C++14's std::exchange
+template <class T, class U = T>
+T exchange(T& obj, U&& new_value) {
+    T old_value = std::move(obj);
+    obj = std::forward<U>(new_value);
+    return old_value;
+}
+
 };  // namespace vlstd

 //=========================================================================
@@ -1,129 +0,0 @@
-// -*- mode: C++; c-file-style: "cc-mode" -*-
-//*************************************************************************
-//
-// Code available from: https://verilator.org
-//
-// Copyright 2003-2024 by Wilson Snyder. This program is free software; you can
-// redistribute it and/or modify it under the terms of either the GNU
-// Lesser General Public License Version 3 or the Perl Artistic License
-// Version 2.0.
-// SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
-//
-//*************************************************************************
-///
-/// \file
-/// \brief Verilated/Verilator common implementation for OS portability
-///
-/// This is compiled as part of other .cpp files to reduce compile time
-/// and as such is a .h file rather than .cpp file.
-///
-//*************************************************************************
-
-#ifndef VL_ALLOW_VERILATEDOS_C
-#error "This file should be included only from V3Os.cpp/Verilated.cpp"
-#endif
-
-#include "verilatedos.h"
-
-// clang-format off
-#if defined(_WIN32) || defined(__MINGW32__)
-# include <windows.h>   // LONG for bcrypt.h on MINGW
-# include <processthreadsapi.h>  // GetProcessTimes
-# include <psapi.h>   // GetProcessMemoryInfo
-#endif
-// clang-format on
-
-namespace VlOs {
-
-//=========================================================================
-// VlOs::VlGetCpuTime/VlGetWallTime implementation
-
-double DeltaCpuTime::gettime() VL_MT_SAFE {
-#if defined(_WIN32) || defined(__MINGW32__)
-    FILETIME lpCreationTime, lpExitTime, lpKernelTime, lpUserTime;
-    if (0
-        != GetProcessTimes(GetCurrentProcess(), &lpCreationTime, &lpExitTime, &lpKernelTime,
-                           &lpUserTime)) {
-        return static_cast<double>(static_cast<uint64_t>(lpUserTime.dwLowDateTime)
-                                   | static_cast<uint64_t>(lpUserTime.dwHighDateTime) << 32ULL)
-               * 1e-7;
-    }
-#else
-    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
-    timespec ts;
-    if (0 == clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts))  // MT-Safe  // LCOV_EXCL_BR_LINE
-        return ts.tv_sec + ts.tv_nsec * 1e-9;
-#endif
-    return 0.0;  // LCOV_EXCL_LINE
-}
-double DeltaWallTime::gettime() VL_MT_SAFE {
-#if defined(_WIN32) || defined(__MINGW32__)
-    FILETIME ft;  // contains number of 0.1us intervals since the beginning of 1601 UTC.
-    GetSystemTimeAsFileTime(&ft);
-    const uint64_t tenthus
-        = ((static_cast<uint64_t>(ft.dwHighDateTime) << 32) + ft.dwLowDateTime + 5ULL);
-    return static_cast<double>(tenthus) * 1e-7;
-#else
-    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
-    timespec ts;
-    if (0 == clock_gettime(CLOCK_MONOTONIC, &ts))  // MT-Safe  // LCOV_EXCL_BR_LINE
-        return ts.tv_sec + ts.tv_nsec * 1e-9;
-    return 0.0;  // LCOV_EXCL_LINE
-#endif
-}
-
-//=========================================================================
-// VlOs::memUsageBytes implementation
-
-uint64_t memUsageBytes() VL_MT_SAFE {
-#if defined(_WIN32) || defined(__MINGW32__)
-    const HANDLE process = GetCurrentProcess();
-    PROCESS_MEMORY_COUNTERS pmc;
-    if (GetProcessMemoryInfo(process, &pmc, sizeof(pmc))) {
-        // The best we can do using simple Windows APIs is to get the size of the working set.
-        return pmc.WorkingSetSize;
-    }
-    return 0;
-#else
-    // Highly unportable. Sorry
-    const char* const statmFilename = "/proc/self/statm";
-    FILE* const fp = fopen(statmFilename, "r");
-    if (!fp) return 0;
-    uint64_t size, resident, share, text, lib, data, dt;  // All in pages
-    const int items = fscanf(
-        fp, "%" SCNu64 " %" SCNu64 " %" SCNu64 " %" SCNu64 " %" SCNu64 " %" SCNu64 " %" SCNu64,
-        &size, &resident, &share, &text, &lib, &data, &dt);
-    fclose(fp);
-    if (VL_UNCOVERABLE(7 != items)) return 0;
-    return (text + data) * getpagesize();
-#endif
-}
-
-//=========================================================================
-// VlOs::getenvStr implementation
-
-std::string getenvStr(const std::string& envvar, const std::string& defaultValue) VL_MT_SAFE {
-    std::string ret;
-#if defined(_MSC_VER)
-    // Note: MinGW does not offer _dupenv_s
-    const char* envvalue = nullptr;
-    _dupenv_s((char**)&envvalue, nullptr, envvar.c_str());
-    if (envvalue != nullptr) {
-        const std::string result{envvalue};
-        free((void*)envvalue);
-        ret = result;
-    } else {
-        ret = defaultValue;
-    }
-#else
-    if (const char* const envvalue = getenv(envvar.c_str())) {
-        ret = envvalue;
-    } else {
-        ret = defaultValue;
-    }
-#endif
-    return ret;
-}
-
-//=========================================================================
-}  //namespace VlOs
@@ -150,21 +150,10 @@ extern "C" {
 #define vpiIntegerNet               681
 #define vpiLogicNet                 vpiNet
 #define vpiTimeNet                  682
-#define vpiUnionNet                 525
-#define vpiShortRealNet             526
-#define vpiRealNet                  527
-#define vpiByteNet                  528
-#define vpiShortIntNet              529
-#define vpiIntNet                   530
-#define vpiLongIntNet               531
-#define vpiBitNet                   532
-#define vpiInterconnectNet          533
-#define vpiInterconnectArray        534
 #define vpiStructNet                683
 #define vpiBreak                    684
 #define vpiContinue                 685
 #define vpiPackedArrayNet           693
-#define vpiNettypeDecl              523
 #define vpiConstraintExpr           747
 #define vpiElseConst                748
 #define vpiImplication              749
@@ -185,8 +174,6 @@ extern "C" {
 #define vpiBaseTypespec             703
 #define vpiElemTypespec             704

-#define vpiNetTypedefAlias          705
-
 #define vpiInputSkew                706
 #define vpiOutputSkew               707
 #define vpiGlobalClocking           708
@@ -219,8 +206,7 @@ extern "C" {
 #define vpiMessages                 735
 #define vpiLoopVars                 737

-#define vpiConcurrentAssertion      740
-#define vpiConcurrentAssertions     vpiConcurrentAssertion
+#define vpiConcurrentAssertions     740
 #define vpiMatchItem                741
 #define vpiMember                   742
 #define vpiElement                  743
@@ -235,7 +221,6 @@ extern "C" {
 /**************************************************************************/
 /************************ generic object properties ***********************/
 /**************************************************************************/
-
 #define vpiTop                      600

 #define vpiUnit                     602
@@ -270,6 +255,7 @@ extern "C" {
 #define vpiModportPort          2
 /* vpiPort is also a port type. It is defined in vpi_user.h */

+
 #define vpiConstantVariable         612
 #define vpiStructUnionMember        615

@@ -421,7 +407,6 @@ extern "C" {
 /***************************** structure *****************************/

 /**************************** CALLBACK REASONS ****************************/
-#define vpiMethodFuncCall           648
 #define cbStartOfThread             600 /* callback on thread creation */
 #define cbEndOfThread               601 /* callback on thread termination */
 #define cbEnterThread               602 /* callback on reentering thread */
@@ -7,7 +7,7 @@
 * This file contains the constant definitions, structure definitions,
 * and routine declarations used by SystemVerilog DPI.
 *
- * This file is from the SystemVerilog IEEE 1800-2023 Annex I.
+ * This file is from the SystemVerilog IEEE 1800-2017 Annex I.
 */

 #ifndef INCLUDED_SVDPI
@@ -111,26 +111,6 @@ typedef uint32_t svBitVecVal;
    ((N) == 32 ? (VALUE) : \
    (((VALUE) & (1 << (N))) ? ((VALUE) | ~SV_MASK(N)) : ((VALUE) & SV_MASK(N))))

-#ifndef VPI_TIME
-#define VPI_TIME
-typedef struct t_vpi_time {
-    int32_t type;
-    uint32_t high, low;
-    double   real;
-} s_vpi_time, *p_vpi_time;
-
-#define vpiScaledRealTime 1
-#define vpiSimTime        2
-#define vpiSuppressTime   3
-#endif
-
-/*   time value */
-typedef   s_vpi_time svTimeVal;
-
-/* time value types */
-#define sv_scaled_real_time vpiScaledRealTime
-#define sv_sim_time         vpiSimTime
-
 /*
 * Implementation-dependent representation.
 */
@@ -297,7 +277,7 @@ XXTERN svScope svGetScope( void );

 /*
 * Set context for subsequent export function execution.
- * This function shall be called before calling an export function, unless
+ * This function must be called before calling an export function, unless
 * the export function is called while executing an import function. In that
 * case the export function shall inherit the scope of the surrounding import
 * function. This is known as the "default scope".
@@ -317,7 +297,7 @@ XXTERN svScope svGetScopeFromName(const char* scopeName);

 /*
 * Store an arbitrary user data pointer for later retrieval by svGetUserData()
- * The userKey is generated by the user. It needs to be guaranteed by the user to
+ * The userKey is generated by the user. It must be guaranteed by the user to
 * be unique from all other userKey's for all unique data storage requirements
 * It is recommended that the address of static functions or variables in the
 * user's C code be used as the userKey.
@@ -349,49 +329,24 @@ XXTERN void* svGetUserData(const svScope scope, void* userKey);
 * modified. Whether this information is available or not is implementation-
 * specific. Note that the string provided (if any) is owned by the SV
 * implementation and is valid only until the next call to any SV function.
- * Applications shall not modify this string or free it.
+ * Applications must not modify this string or free it
 */
 XXTERN int svGetCallerInfo(const char** fileName, int *lineNumber);

 /*
 * Returns 1 if the current execution thread is in the disabled state.
- * Disable protocol shall be adhered to if in the disabled state.
+ * Disable protocol must be adhered to if in the disabled state.
 */
 XXTERN int svIsDisabledState( void );

 /*
 * Imported functions call this API function during disable processing to
 * acknowledge that they are correctly participating in the DPI disable protocol.
- * This function shall be called before returning from an imported function that is
+ * This function must be called before returning from an imported function that is
 * in the disabled state.
 */
 XXTERN void svAckDisabledState( void );

-/*                                                                                                         Mantis 5713/D9
- * Retrieve the current simulation time, scaled to the time unit of the scope.
-* If scope is NULL, then time is scaled to the simulation time unit.
-* It is an error to call svGetTime() with an invalid svScope.
-* This function returns -1 for all error cases, 0 upon success.
-*/
-XXTERN int svGetTime(const svScope scope, svTimeVal* time);
-
-/*
- * Retrieve the time unit for scope.
- * If scope is NULL, then simulation time unit is retrieved.
-* It is an error to call svGetTimeUnit() with an invalid svScope.
-* This function returns -1 for all error cases, 0 upon success.
-*/
-XXTERN int svGetTimeUnit(const svScope scope, int32_t* time_unit);
-
-/*
- * Retrieve the time precision for scope.
- * If scope is NULL, then simulation time unit is retrieved.
-* It is an error to call svGetTimePrecision() with an invalid svScope.
-* This function returns -1 for all error cases, 0 upon success.
-*/
-XXTERN int svGetTimePrecision(const svScope scope, int32_t* time_precision);
-
-
 /*
 **********************************************************
 * DEPRECATED PORTION OF FILE STARTS FROM HERE.
@@ -1,7 +1,7 @@
 /*******************************************************************************
 * vpi_user.h
 *
- * IEEE Std 1800-2023 Programming Language Interface (PLI)
+ * IEEE Std 1800-2017 Programming Language Interface (PLI)
 *
 * This file contains the constant definitions, structure definitions, and
 * routine declarations used by the SystemVerilog Verification Procedural
@@ -344,9 +344,6 @@ typedef PLI_UINT32 *vpiHandle;
 #define vpiSupply0                11   /* supply-0 net */
 #define vpiNone                   12   /* no default net type (1364-2001) */
 #define vpiUwire                  13   /* unresolved wire net (1364-2005) */
-#define vpiNettypeNet             14   /* user-defined nettype net */
-#define vpiNettypeNetSelect       15   /* user-defined nettype net subelement */
-#define vpiInterconnect           16   /* interconnect net */

 #define vpiExplicitScalared      23   /* explicitly scalared (Boolean) */
 #define vpiExplicitVectored      24   /* explicitly vectored (Boolean) */
@@ -576,9 +573,6 @@ typedef PLI_UINT32 *vpiHandle;

 /******************************* time structure *******************************/

-#ifndef VPI_TIME /* added in 1800-2023 */
-#define VPI_TIME
-
 typedef struct t_vpi_time
 {
  PLI_INT32  type;               /* [vpiScaledRealTime, vpiSimTime,
@@ -593,8 +587,6 @@ typedef struct t_vpi_time
 #define vpiSimTime        2
 #define vpiSuppressTime   3

-#endif
-
 /****************************** delay structures ******************************/

 typedef struct t_vpi_delay
@@ -749,8 +741,9 @@ typedef struct t_vpi_arrayvalue
 typedef struct t_vpi_systf_data
 {
  PLI_INT32 type;                       /* vpiSysTask, vpiSysFunc */
-  PLI_INT32 sysfunctype;                /* vpi[Int,Real,Time,Sized,SizedSigned]Func */
-  PLI_BYTE8 *tfname;                    /* first character has to be '$' */
+  PLI_INT32 sysfunctype;                /* vpiSysTask, vpi[Int,Real,Time,Sized,
+                                                           SizedSigned]Func */
+  PLI_BYTE8 *tfname;                    /* first character must be '$' */
  PLI_INT32 (*calltf)(PLI_BYTE8 *);
  PLI_INT32 (*compiletf)(PLI_BYTE8 *);
  PLI_INT32 (*sizetf)(PLI_BYTE8 *);     /* for sized function callbacks only */
@@ -434,7 +434,7 @@ class CallAnnotationsValidator:
            self.process_translation_unit(translation_unit)
            self._main_source_file = ""
            self._defines = {}
-        elif len(errors) != 0:
+        else:
            print(f"%Error: parsing failed: {filename}", file=sys.stderr)
            for error in errors:
                print(f"        {error}", file=sys.stderr)
@@ -180,18 +180,9 @@ def test():
    if Args.stage_enabled[18]:
        ci_fold_start("upload")
        print("Stage 18: Upload")
-        # curl -Os https://cli.codecov.io/latest/linux/codecov ; sudo chmod +x codecov
-        # --disable-search does not seem to work
-        # -d with false directory does not seem to work
-        # So, remove gcno files before calling codecov
-        upload_dir = "nodist/obj_dir/upload"
-        os.makedirs(upload_dir, exist_ok=True)
-        cmd = ("ci/codecov -v upload-process -Z" + " -f " + cc_dir +
-               "/app_total.info )")
-        print("print: Not running:")
-        print("  export CODECOV_TOKEN=<hidden>")
-        print("  find . -name '*.gcno' -exec rm {} \\;")
-        print("  " + cmd)
+        cmd = "bash <(cat ci/coverage-upload.sh) -f " + cc_dir + "/app_total.info"
+        print("print: Not running: export CODECOV_TOKEN=<hidden>")
+        print("print: Not running: " + cmd)
        ci_fold_end()

    if Args.stage_enabled[19]:
@@ -262,21 +253,12 @@ def cleanup_abs_paths_info(cc_dir, infile, outfile):
    lines = []
    with open(infile, "r", encoding="utf8") as fh:
        for line in fh:
-            if re.search(r'^SF:', line) and not re.search(r'^SF:/usr/', line):
+            if re.search(r'^SF:', line):
                line = re.sub(os.environ['VERILATOR_ROOT'] + '/',
                              '',
                              line,
                              count=1)
                line = re.sub(cc_dir + '/', '', line, count=1)
-                line = re.sub(r'^SF:.*?/include/',
-                              'SF:include/',
-                              line,
-                              count=1)
-                line = re.sub(r'^SF:.*?/src/', 'SF:src/', line, count=1)
-                line = re.sub(r'^SF:.*?/test_regress/',
-                              'SF:test_regress/',
-                              line,
-                              count=1)
                line = re.sub(r'obj_dbg/verilog.y$', 'verilog.y', line)
                # print("Remaining SF: "+line)
            lines.append(line)
@@ -382,13 +364,12 @@ parser.add_argument('--scenarios',
                    help='pass test scenarios onto driver.pl test harness')
 parser.add_argument(
    '--stages',
-    '--stage',
    action='store',
    help='runs a specific stage or range of stages (see the script)')
 parser.add_argument(
-    '--tests',
    '--test',
    action='append',
+    dest='tests',
    default=[],
    help=
    'Instead of normal regressions, run the specified test(s), may be used multiple times'
@@ -18,21 +18,20 @@
        $ ./fastcov.py --exclude /usr/include test/ --lcov -o report.info
        $ genhtml -o code_coverage report.info
 """
+
 import re
 import os
 import sys
 import glob
 import json
 import time
-import fnmatch
 import logging
 import argparse
 import threading
 import subprocess
 import multiprocessing
-from pathlib import Path

-FASTCOV_VERSION = (1,15)
+FASTCOV_VERSION = (1,7)
 MINIMUM_PYTHON  = (3,5)
 MINIMUM_GCOV    = (9,0,0)

@@ -41,10 +40,6 @@ START_TIME    = time.monotonic()
 GCOVS_TOTAL   = 0
 GCOVS_SKIPPED = 0

-# Gcov Coverage File Extensions
-GCOV_GCNO_EXT = ".gcno" # gcno = "[gc]ov [no]te"
-GCOV_GCDA_EXT = ".gcda" # gcda = "[gc]ov [da]ta"
-
 # For when things go wrong...
 # Start error codes at 3 because 1-2 are special
 # See https://stackoverflow.com/a/1535733/2516916
@@ -54,8 +49,6 @@ EXIT_CODES = {
    "python_version": 4,
    "unsupported_coverage_format": 5,
    "excl_not_found": 6,
-    "bad_chunk_file": 7,
-    "missing_json_key": 8,
 }

 # Disable all logging in case developers are using this as a module
@@ -67,132 +60,6 @@ class FastcovFormatter(logging.Formatter):
        log_message = super(FastcovFormatter, self).format(record)
        return "[{:.3f}s] {}".format(stopwatch(), log_message)

-class DiffParseError(Exception):
-    pass
-
-class DiffParser(object):
-    def _refinePaths(self, diff_metadata, diff_base_dir):
-        diff_metadata.pop('/dev/null', None)
-        diff_metadata.pop('', None)
-        for key, value in diff_metadata.copy().items():
-            diff_metadata.pop(key)
-            #sources without added lines will be excluded
-            if value:
-                newpath = os.path.join(diff_base_dir, key) if diff_base_dir else os.path.abspath(key)
-                diff_metadata[newpath] = value
-
-    def _parseTargetFile(self, line_with_target_file):
-        #f.e. '+++ b/README.md1' or '+++ b/README.md1   timestamp'
-        target_source = line_with_target_file[4:].partition('\t')[0].strip()
-        target_source = target_source[2:] if target_source.startswith('b/') else target_source
-        return target_source
-
-    def _parseHunkBoundaries(self, line_with_hunk_boundaries, line_index):
-        #f.e. '@@ -121,4 +122,4 @@ Time to process all gcda and parse all gcov:'
-        # Here ['-121,4', '+122,4']
-        lines_info = line_with_hunk_boundaries[3:].partition("@@")[0].strip().split(' ')
-        if len(lines_info) != 2:
-            raise DiffParseError("Found invalid hunk. Line #{}. {}".format(line_index, line_with_hunk_boundaries))
-        # Here ['122','4']
-        target_lines_info = lines_info[1].strip('+').partition(',')
-        target_line_current = int(target_lines_info[0])
-        target_lines_count = int(target_lines_info[2]) if target_lines_info[2] else 1
-
-        # Here ['121','4']
-        source_lines_info = lines_info[0].strip('-').partition(',')
-        source_line_current = int(source_lines_info[0])
-        source_lines_count = int(source_lines_info[2]) if source_lines_info[2] else 1
-        return target_line_current, target_lines_count, source_line_current, source_lines_count
-
-    def parseDiffFile(self, diff_file, diff_base_dir, fallback_encodings=[]):
-        diff_metadata = {}
-        target_source = None
-        target_hunk = set()
-        target_line_current = 0
-        target_line_end = 0
-        source_line_current = 0
-        source_line_end = 0
-        found_hunk = False
-        for i, line in enumerate(getSourceLines(diff_file, fallback_encodings), 1):
-            line = line.rstrip()
-            if not found_hunk:
-                if line.startswith('+++ '):
-                    # refresh file
-                    target_source = self._parseTargetFile(line)
-                elif line.startswith('@@ '):
-                    # refresh hunk
-                    target_line_current, target_lines_count, source_line_current, source_lines_count =  self._parseHunkBoundaries(line, i)
-                    target_line_end = target_line_current + target_lines_count
-                    source_line_end = source_line_current + source_lines_count
-                    target_hunk = set()
-                    found_hunk = True
-                continue
-            if target_line_current > target_line_end or source_line_current > source_line_end:
-                raise DiffParseError("Hunk longer than expected. Line #{}. {}".format(i, line))
-
-            if line.startswith('+'):
-                #line related to target
-                target_hunk.add(target_line_current)
-                target_line_current = target_line_current + 1
-            elif line.startswith(' ') or line == '':
-                # line related to both
-                target_line_current = target_line_current + 1
-                source_line_current = source_line_current + 1
-            elif line.startswith('-'):
-                # line related to source
-                source_line_current = source_line_current + 1
-            elif not line.startswith('\\'):  # No newline at end of file
-                # line with newline marker is not included into any boundaries
-                raise DiffParseError("Found unrecognized hunk line type. Line #{}. {}".format(i, line))
-
-            if target_line_current == target_line_end and source_line_current == source_line_end:
-                # Checked all lines, save data
-                if target_source in diff_metadata:
-                    diff_metadata[target_source] = target_hunk.union(diff_metadata[target_source])
-                else:
-                    diff_metadata[target_source] = target_hunk
-                target_hunk = set()
-                found_hunk = False
-
-        if target_line_current != target_line_end or source_line_current != source_line_end:
-            raise DiffParseError("Unexpected end of file. Expected hunk with {} target lines, {} source lines".format(
-                target_line_end - target_line_current, source_line_end - source_line_current))
-
-        self._refinePaths(diff_metadata, diff_base_dir)
-        return diff_metadata
-
-    def filterByDiff(self, diff_file, dir_base_dir, fastcov_json, fallback_encodings=[]):
-        diff_metadata = self.parseDiffFile(diff_file, dir_base_dir, fallback_encodings)
-        logging.debug("Include only next files: {}".format(diff_metadata.keys()))
-        excluded_files_count = 0
-        excluded_lines_count = 0
-        for source in list(fastcov_json["sources"].keys()):
-            diff_lines = diff_metadata.get(source, None)
-            if not diff_lines:
-                excluded_files_count = excluded_files_count + 1
-                logging.debug("Exclude {} according to diff file".format(source))
-                fastcov_json["sources"].pop(source)
-                continue
-            for test_name, report_data in fastcov_json["sources"][source].copy().items():
-                #No info about functions boundaries, removing all
-                for function in list(report_data["functions"].keys()):
-                    report_data["functions"].pop(function, None)
-                for line in list(report_data["lines"].keys()):
-                    if line not in diff_lines:
-                        excluded_lines_count = excluded_lines_count + 1
-                        report_data["lines"].pop(line)
-                for branch_line in list(report_data["branches"].keys()):
-                    if branch_line not in diff_lines:
-                        report_data["branches"].pop(branch_line)
-                if len(report_data["lines"]) == 0:
-                    fastcov_json["sources"][source].pop(test_name)
-            if len(fastcov_json["sources"][source]) == 0:
-                excluded_files_count = excluded_files_count + 1
-                logging.debug('Exclude {} file as it has no lines due to diff filter'.format(source))
-                fastcov_json["sources"].pop(source)
-        logging.info("Excluded {} files and {} lines according to diff file".format(excluded_files_count, excluded_lines_count))
-        return fastcov_json
-
 def chunks(l, n):
    """Yield successive n-sized chunks from l."""
    for i in range(0, len(l), n):
@@ -202,10 +69,6 @@ def setExitCode(key):
    global EXIT_CODE
    EXIT_CODE = EXIT_CODES[key]

-def setExitCodeRaw(code):
-    global EXIT_CODE
-    EXIT_CODE = code
-
 def incrementCounters(total, skipped):
    global GCOVS_TOTAL
    global GCOVS_SKIPPED
@@ -235,48 +98,10 @@ def getGcovVersion(gcov):
    p.wait()
    return parseVersionFromLine(output.split("\n")[0])

-def tryParseNumber(s):
-    try:
-        return int(s)
-    except ValueError:
-        # Log a warning if not hyphen
-        if s != "-":
-            logging.warning("Unsupported numerical value '%s', using 0", s)
-
-        # Default to 0 if we can't parse the number (e.g. "-", "NaN", etc.)
-        return 0
-
 def removeFiles(files):
    for file in files:
        os.remove(file)

-def processPrefix(path, prefix, prefix_strip):
-    p = Path(path)
-    if p.exists() or not p.is_absolute():
-        return path
-
-    if prefix_strip > 0:
-        segments = p.parts
-
-        if len(segments) < prefix_strip + 1:
-            logging.warning("Couldn't strip %i path levels from %s.", prefix_strip, path)
-            return path
-
-        segments = segments[prefix_strip+1:]
-        p = Path(segments[0])
-        segments = segments[1:]
-        for s in segments:
-            p = p.joinpath(s)
-
-    if len(prefix) > 0:
-        if p.is_absolute():
-            p = Path(prefix).joinpath(p.relative_to('/'))
-        else:
-            p = Path(prefix).joinpath(p)
-
-    return str(p)
-
-
 def getFilteredCoverageFiles(coverage_files, exclude):
    def excludeGcda(gcda):
        for ex in exclude:
@@ -286,16 +111,11 @@ def getFilteredCoverageFiles(coverage_files, exclude):
        return True
    return list(filter(excludeGcda, coverage_files))

-def globCoverageFiles(cwd, coverage_type):
-    return glob.glob(os.path.join(os.path.abspath(cwd), "**/*" + coverage_type), recursive=True)
-
 def findCoverageFiles(cwd, coverage_files, use_gcno):
    coverage_type = "user provided"
    if not coverage_files:
-        # gcov strips off extension of whatever you pass it and searches [extensionless name] + .gcno/.gcda
-        # We should pass either gcno or gcda, but not both - if you pass both it will be processed twice
-        coverage_type = GCOV_GCNO_EXT if use_gcno else GCOV_GCDA_EXT
-        coverage_files = globCoverageFiles(cwd, coverage_type)
+        coverage_type = "gcno" if use_gcno else "gcda"
+        coverage_files = glob.glob(os.path.join(os.path.abspath(cwd), "**/*." + coverage_type), recursive=True)

    logging.info("Found {} coverage files ({})".format(len(coverage_files), coverage_type))
    logging.debug("Coverage files found:\n    %s", "\n    ".join(coverage_files))
@@ -305,32 +125,15 @@ def gcovWorker(data_q, metrics_q, args, chunk, gcov_filter_options):
    base_report   = {"sources": {}}
    gcovs_total   = 0
    gcovs_skipped = 0
-    error_exit    = False

-    gcov_bin = args.gcov
-    gcov_args = ["--json-format", "--stdout"]
+    gcov_args = "-it"
    if args.branchcoverage or args.xbranchcoverage:
-        gcov_args.append("--branch-probabilities")
+        gcov_args += "b"

-    encoding = sys.stdout.encoding if sys.stdout.encoding else 'UTF-8'
-    workdir  = args.cdirectory if args.cdirectory else "."
-
-    p = subprocess.Popen([gcov_bin] + gcov_args + chunk, cwd=workdir, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL)
-    for i, line in enumerate(iter(p.stdout.readline, b'')):
-        try:
-            intermediate_json = json.loads(line.decode(encoding))
-        except json.decoder.JSONDecodeError as e:
-            logging.error("Could not process chunk file '{}' ({}/{})".format(chunk[i], i+1, len(chunk)))
-            logging.error(str(e))
-            setExitCode("bad_chunk_file")
-            continue
-
-        if "current_working_directory" not in intermediate_json:
-            logging.error("Missing 'current_working_directory' for data file: {}".format(intermediate_json))
-            setExitCode("missing_json_key")
-            continue
-
-        intermediate_json_files = processGcovs(args.cdirectory, intermediate_json["files"], intermediate_json["current_working_directory"], gcov_filter_options)
+    p = subprocess.Popen([args.gcov, gcov_args] + chunk, cwd=args.cdirectory, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL)
+    for line in iter(p.stdout.readline, b''):
+        intermediate_json = json.loads(line.decode(sys.stdout.encoding))
+        intermediate_json_files = processGcovs(args.cdirectory, intermediate_json["files"], gcov_filter_options)
        for f in intermediate_json_files:
            distillSource(f, base_report["sources"], args.test_name, args.xbranchcoverage)
        gcovs_total   += len(intermediate_json["files"])
@@ -340,8 +143,6 @@ def gcovWorker(data_q, metrics_q, args, chunk, gcov_filter_options):
    data_q.put(base_report)
    metrics_q.put((gcovs_total, gcovs_skipped))

-    sys.exit(EXIT_CODE)
-
 def processGcdas(args, coverage_files, gcov_filter_options):
    chunk_size = max(args.minimum_chunk, int(len(coverage_files) / args.jobs) + 1)

@@ -362,8 +163,6 @@ def processGcdas(args, coverage_files, gcov_filter_options):

    for p in processes:
        p.join()
-        if p.exitcode != 0:
-            setExitCodeRaw(p.exitcode)

    base_fastcov = fastcov_jsons.pop()
    for fj in fastcov_jsons:
@@ -385,12 +184,6 @@ def shouldFilterSource(source, gcov_filter_options):
            logging.debug("Filtering coverage for '%s' due to option '--exclude %s'", source, ex)
            return True

-    # Check exclude filter
-    for ex_glob in gcov_filter_options["exclude_glob"]:
-        if fnmatch.fnmatch(source, ex_glob):
-            logging.debug("Filtering coverage for '%s' due to option '--exclude-glob %s'", source, ex_glob)
-            return True
-
    # Check include filter
    if gcov_filter_options["include"]:
        included = False
@@ -412,12 +205,9 @@ def filterFastcov(fastcov_json, args):
        if shouldFilterSource(source, gcov_filter_options):
            del fastcov_json["sources"][source]

-def processGcov(cwd, gcov, source_base_dir, files, gcov_filter_options):
-    # Uses cwd if set, else source_base_dir from gcov json. If both are empty, uses "."
-    base_dir = cwd if cwd else source_base_dir
-    base_dir = base_dir if base_dir else "."
+def processGcov(cwd, gcov, files, gcov_filter_options):
    # Add absolute path
-    gcov["file_abs"] = os.path.abspath(os.path.join(base_dir, gcov["file"]))
+    gcov["file_abs"] = os.path.abspath(os.path.join(cwd, gcov["file"]))

    if shouldFilterSource(gcov["file_abs"], gcov_filter_options):
        return
@@ -425,10 +215,10 @@ def processGcov(cwd, gcov, source_base_dir, files, gcov_filter_options):
    files.append(gcov)
    logging.debug("Accepted coverage for '%s'", gcov["file_abs"])

-def processGcovs(cwd, gcov_files, source_base_dir, gcov_filter_options):
+def processGcovs(cwd, gcov_files, gcov_filter_options):
    files = []
    for gcov in gcov_files:
-        processGcov(cwd, gcov, source_base_dir, files, gcov_filter_options)
+        processGcov(cwd, gcov, files, gcov_filter_options)
    return files

 def dumpBranchCoverageToLcovInfo(f, branches):
@@ -498,44 +288,15 @@ def getSourceLines(source, fallback_encodings=[]):
    with open(source, errors="ignore") as f:
        return f.readlines()

-def containsMarker(markers, strBody):
-    for marker in markers:
-        if marker in strBody:
-            return True
-    return False
-
-# Returns whether source coverage changed or not
-def exclProcessSource(fastcov_sources, source, exclude_branches_sw, include_branches_sw, exclude_line_marker, fallback_encodings, gcov_prefix, gcov_prefix_strip):
-    source_to_open = processPrefix(source, gcov_prefix, gcov_prefix_strip)
-
-    # Before doing any work, check if this file even needs to be processed
-    if not exclude_branches_sw and not include_branches_sw:
-        # Ignore unencodable characters
-        with open(source_to_open, errors="ignore") as f:
-            if not containsMarker(exclude_line_marker + ["LCOV_EXCL"], f.read()):
-                return False
-
-    # If we've made it this far we have to check every line
-
+def exclProcessSource(fastcov_sources, source, exclude_branches_sw, include_branches_sw, fallback_encodings):
    start_line = 0
    end_line = 0
    # Start enumeration at line 1 because the first line of the file is line 1 not 0
-    for i, line in enumerate(getSourceLines(source_to_open, fallback_encodings), 1):
+    for i, line in enumerate(getSourceLines(source, fallback_encodings), 1):
        # Cycle through test names (likely only 1)
        for test_name in fastcov_sources[source]:
            fastcov_data = fastcov_sources[source][test_name]

-            # Check if branch coverage should be deleted based on CLI options
-            if (exclude_branches_sw or include_branches_sw) and (i in fastcov_data["branches"]):
-                del_exclude_br = exclude_branches_sw and any(line.lstrip().startswith(e) for e in exclude_branches_sw)
-                del_include_br = include_branches_sw and all(not line.lstrip().startswith(e) for e in include_branches_sw)
-                if del_exclude_br or del_include_br:
-                    del fastcov_data["branches"][i]
-
-            # Skip to next line as soon as possible
-            if not containsMarker(exclude_line_marker + ["LCOV_EXCL"], line):
-                continue
-
            # Build line to function dict so can quickly delete by line number
            line_to_func = {}
            for f in fastcov_data["functions"].keys():
@@ -544,7 +305,16 @@ def exclProcessSource(fastcov_sources, source, exclude_branches_sw, include_bran
                    line_to_func[l] = set()
                line_to_func[l].add(f)

-            if any(marker in line for marker in exclude_line_marker):
+            if i in fastcov_data["branches"]:
+                del_exclude_br = exclude_branches_sw and any(line.lstrip().startswith(e) for e in exclude_branches_sw)
+                del_include_br = include_branches_sw and all(not line.lstrip().startswith(e) for e in include_branches_sw)
+                if del_exclude_br or del_include_br:
+                    del fastcov_data["branches"][i]
+
+            if "LCOV_EXCL" not in line:
+                continue
+
+            if "LCOV_EXCL_LINE" in line:
                for key in ["lines", "branches"]:
                    if i in fastcov_data[key]:
                        del fastcov_data[key][i]
@@ -577,56 +347,26 @@ def exclProcessSource(fastcov_sources, source, exclude_branches_sw, include_bran
                if i in fastcov_data["branches"]:
                    del fastcov_data["branches"][i]

-    # Source coverage changed
-    return True
-
-def exclMarkerWorker(data_q, fastcov_sources, chunk, exclude_branches_sw, include_branches_sw, exclude_line_marker, fallback_encodings, gcov_prefix, gcov_prefix_strip):
-    changed_sources = []
-
+def exclMarkerWorker(fastcov_sources, chunk, exclude_branches_sw, include_branches_sw, fallback_encodings):
    for source in chunk:
        try:
-            if exclProcessSource(fastcov_sources, source, exclude_branches_sw, include_branches_sw, exclude_line_marker, fallback_encodings, gcov_prefix, gcov_prefix_strip):
-                changed_sources.append((source, fastcov_sources[source]))
+            exclProcessSource(fastcov_sources, source, exclude_branches_sw, include_branches_sw, fallback_encodings)
        except FileNotFoundError:
            logging.error("Could not find '%s' to scan for exclusion markers...", source)
            setExitCode("excl_not_found") # Set exit code because of error

-    # Write out changed sources back to main fastcov file
-    data_q.put(changed_sources)
-
-    # Exit current process with appropriate code
-    sys.exit(EXIT_CODE)
-
-def processExclusionMarkers(fastcov_json, jobs, exclude_branches_sw, include_branches_sw, exclude_line_marker, min_chunk_size, fallback_encodings, gcov_prefix, gcov_prefix_strip):
+def scanExclusionMarkers(fastcov_json, jobs, exclude_branches_sw, include_branches_sw, min_chunk_size, fallback_encodings):
    chunk_size = max(min_chunk_size, int(len(fastcov_json["sources"]) / jobs) + 1)

-    processes = []
-    data_q    = multiprocessing.Queue()
+    threads = []
    for chunk in chunks(list(fastcov_json["sources"].keys()), chunk_size):
-        p = multiprocessing.Process(target=exclMarkerWorker, args=(data_q, fastcov_json["sources"], chunk, exclude_branches_sw, include_branches_sw, exclude_line_marker, fallback_encodings, gcov_prefix, gcov_prefix_strip))
-        processes.append(p)
-        p.start()
+        t = threading.Thread(target=exclMarkerWorker, args=(fastcov_json["sources"], chunk, exclude_branches_sw, include_branches_sw, fallback_encodings))
+        threads.append(t)
+        t.start()

-    logging.info("Spawned {} exclusion marker scanning processes, each processing at most {} source files".format(len(processes), chunk_size))
-
-    changed_sources = []
-    for p in processes:
-        changed_sources += data_q.get()
-
-    for p in processes:
-        p.join()
-        if p.exitcode != 0:
-            setExitCodeRaw(p.exitcode)
-
-    for changed_source in changed_sources:
-        fastcov_json["sources"][changed_source[0]] = changed_source[1]
-
-def validateSources(fastcov_json, gcov_prefix, gcov_prefix_strip):
-    logging.info("Checking if all sources exist")
-    for source in fastcov_json["sources"].keys():
-        source = processPrefix(source, gcov_prefix, gcov_prefix_strip)
-        if not os.path.exists(source):
-            logging.error("Cannot find '{}'".format(source))
+    logging.info("Spawned {} threads each scanning at most {} source files".format(len(threads), chunk_size))
+    for t in threads:
+        t.join()

 def distillFunction(function_raw, functions):
    function_name   = function_raw["name"]
@@ -673,13 +413,6 @@ def filterExceptionalBranches(branches):
 def distillLine(line_raw, lines, branches, include_exceptional_branches):
    line_number = int(line_raw["line_number"])
    count       = int(line_raw["count"])
-    if count <  0:
-        if "function_name" in line_raw:
-            logging.warning("Ignoring negative count found in '%s'.", line_raw["function_name"])
-        else:
-            logging.warning("Ignoring negative count.")
-        count = 0
-
    if line_number not in lines:
        lines[line_number] = count
    else:
@@ -725,7 +458,6 @@ def getGcovFilterOptions(args):
        "sources": set([os.path.abspath(s) for s in args.sources]), #Make paths absolute, use set for fast lookups
        "include": args.includepost,
        "exclude": args.excludepost,
-        "exclude_glob":args.excludepost_glob
    }

 def addDicts(dict1, dict2):
@@ -797,30 +529,30 @@ def parseInfo(path):
                current_test_name = line[3:].strip()
            elif line.startswith("SF:"):
                current_sf = line[3:].strip()
-                fastcov_json["sources"].setdefault(current_sf, {
+                fastcov_json["sources"][current_sf] = {
                    current_test_name: {
                        "functions": {},
                        "branches": {},
                        "lines": {},
                    }
-                })
+                }
                current_data = fastcov_json["sources"][current_sf][current_test_name]
            elif line.startswith("FN:"):
                line_num, function_name = line[3:].strip().split(",")
                current_data["functions"][function_name] = {}
-                current_data["functions"][function_name]["start_line"] = tryParseNumber(line_num)
+                current_data["functions"][function_name]["start_line"] = int(line_num)
            elif line.startswith("FNDA:"):
                count, function_name = line[5:].strip().split(",")
-                current_data["functions"][function_name]["execution_count"] = tryParseNumber(count)
+                current_data["functions"][function_name]["execution_count"] = int(count)
            elif line.startswith("DA:"):
                line_num, count = line[3:].strip().split(",")
-                current_data["lines"][line_num] = tryParseNumber(count)
+                current_data["lines"][line_num] = int(count)
            elif line.startswith("BRDA:"):
                branch_tokens = line[5:].strip().split(",")
                line_num, count = branch_tokens[0], branch_tokens[-1]
                if line_num not in current_data["branches"]:
                    current_data["branches"][line_num] = []
-                current_data["branches"][line_num].append(tryParseNumber(count))
+                current_data["branches"][line_num].append(int(count))

    return fastcov_json

@@ -878,9 +610,9 @@ def getGcovCoverage(args):
        coverage_files = getFilteredCoverageFiles(coverage_files, args.excludepre)
        logging.info("Found {} coverage files after filtering".format(len(coverage_files)))

-    # We "zero" the "counters" by simply deleting all gcda files
+    # We "zero" the "counters" by deleting all gcda files
    if args.zerocounters:
-        removeFiles(globCoverageFiles(args.directory, GCOV_GCDA_EXT))
+        removeFiles(coverage_files)
        logging.info("Removed {} .gcda files".format(len(coverage_files)))
        sys.exit()

@@ -894,37 +626,6 @@ def getGcovCoverage(args):

    return fastcov_json

-def formatCoveredItems(covered, total):
-    coverage = (covered * 100.0) / total if total > 0 else 100.0
-    coverage = round(coverage, 2)
-    return "{:.2f}%, {}/{}".format(coverage, covered, total)
-
-def dumpStatistic(fastcov_json):
-    total_lines = 0
-    covered_lines = 0
-    total_functions = 0
-    covered_functions = 0
-    total_files = len(fastcov_json["sources"])
-    covered_files = 0
-
-    for source_name, source in fastcov_json["sources"].items():
-        is_file_covered = False
-        for test_name, test in source.items():
-            total_lines += len(test["lines"])
-            for execution_count in test["lines"].values():
-                covered_lines += 1 if execution_count > 0 else 0
-                is_file_covered = is_file_covered or execution_count > 0
-            total_functions += len(test["functions"])
-            for function in test["functions"].values():
-                covered_functions += 1 if function['execution_count'] > 0 else 0
-                is_file_covered = is_file_covered or function['execution_count'] > 0
-        if is_file_covered:
-            covered_files = covered_files + 1
-
-    logging.info("Files Coverage: {}".format(formatCoveredItems(covered_files, total_files)))
-    logging.info("Functions Coverage: {}".format(formatCoveredItems(covered_functions, total_functions)))
-    logging.info("Lines Coverage: {}".format(formatCoveredItems(covered_lines, total_lines)))
-
 def dumpFile(fastcov_json, args):
    if args.lcov:
        dumpToLcovInfo(fastcov_json, args.output)
@@ -933,9 +634,6 @@ def dumpFile(fastcov_json, args):
        dumpToJson(fastcov_json, args.output)
        logging.info("Created fastcov json file '{}'".format(args.output))

-    if args.dump_statistic:
-        dumpStatistic(fastcov_json)
-
 def tupleToDotted(tup):
    return ".".join(map(str, tup))

@@ -957,19 +655,15 @@ def parseArgs():
    # Filtering Options
    parser.add_argument('-s', '--source-files', dest='sources',     nargs="+", metavar='', default=[], help='Filter: Specify exactly which source files should be included in the final report. Paths must be either absolute or relative to current directory.')
    parser.add_argument('-e', '--exclude',      dest='excludepost', nargs="+", metavar='', default=[], help='Filter: Exclude source files from final report if they contain one of the provided substrings (i.e. /usr/include test/, etc.)')
-    parser.add_argument('-eg', '--exclude-glob', dest='excludepost_glob', nargs="+", metavar='', default=[], help='Filter: Exclude source files by glob pattern from final report if they contain one of the provided substrings (i.e. /usr/include test/, etc.)')
    parser.add_argument('-i', '--include',      dest='includepost', nargs="+", metavar='', default=[], help='Filter: Only include source files in final report that contain one of the provided substrings (i.e. src/ etc.)')
    parser.add_argument('-f', '--gcda-files',   dest='coverage_files',  nargs="+", metavar='', default=[], help='Filter: Specify exactly which gcda or gcno files should be processed. Note that specifying gcno causes both gcno and gcda to be processed.')
    parser.add_argument('-E', '--exclude-gcda', dest='excludepre',  nargs="+", metavar='', default=[], help='Filter: Exclude gcda or gcno files from being processed via simple find matching (not regex)')
-    parser.add_argument('-u', '--diff-filter', dest='diff_file', default='', help='Unified diff file with changes which will be included into final report')
-    parser.add_argument('-ub', '--diff-base-dir', dest='diff_base_dir', default='', help='Base directory for sources in unified diff file, usually repository dir')
-    parser.add_argument('-ce', '--custom-exclusion-marker', dest='exclude_line_marker', nargs="+", metavar='', default=["LCOV_EXCL_LINE"], help='Filter: Add filter for lines that will be excluded from coverage (same behavior as "LCOV_EXCL_LINE")')

    parser.add_argument('-g', '--gcov', dest='gcov', default='gcov', help='Which gcov binary to use')

    parser.add_argument('-d', '--search-directory', dest='directory', default=".", help='Base directory to recursively search for gcda files (default: .)')
-    parser.add_argument('-c', '--compiler-directory', dest='cdirectory', default="", help='Base directory compiler was invoked from (default: . or read from gcov) \
-                                                                                            This needs to be set if invoking fastcov from somewhere other than the base compiler directory. No need to set it if gcc version > 9.1')
+    parser.add_argument('-c', '--compiler-directory', dest='cdirectory', default=".", help='Base directory compiler was invoked from (default: .) \
+                                                                                            This needs to be set if invoking fastcov from somewhere other than the base compiler directory.')

    parser.add_argument('-j', '--jobs', dest='jobs', type=int, default=multiprocessing.cpu_count(), help='Number of parallel gcov to spawn (default: {}).'.format(multiprocessing.cpu_count()))
    parser.add_argument('-m', '--minimum-chunk-size', dest='minimum_chunk', type=int, default=5,    help='Minimum number of files a thread should process (default: 5). \
@@ -978,23 +672,17 @@ def parseArgs():
    parser.add_argument('-F', '--fallback-encodings', dest='fallback_encodings', nargs="+", metavar='', default=[], help='List of encodings to try if opening a source file with the default fails (i.e. latin1, etc.). This option is not usually needed.')

    parser.add_argument('-l', '--lcov',   dest='lcov',   action="store_true",     help='Output in lcov info format instead of fastcov json')
-    parser.add_argument('-o', '--output', dest='output', default="", help='Name of output file (default: coverage.json or coverage.info, depends on --lcov option)')
+    parser.add_argument('-o', '--output', dest='output', default="coverage.json", help='Name of output file (default: coverage.json)')
    parser.add_argument('-q', '--quiet',  dest='quiet',  action="store_true",     help='Suppress output to stdout')

    parser.add_argument('-t', '--test-name',     dest='test_name', default="", help='Specify a test name for the coverage. Equivalent to lcov\'s `-t`.')
    parser.add_argument('-C', '--add-tracefile', dest='combine',   nargs="+",  help='Combine multiple coverage files into one. If this flag is specified, fastcov will do a combine operation instead invoking gcov. Equivalent to lcov\'s `-a`.')

    parser.add_argument('-V', '--verbose', dest="verbose", action="store_true", help="Print more detailed information about what fastcov is doing")
-    parser.add_argument('-w', '--validate-sources', dest="validate_sources", action="store_true", help="Check if every source file exists")
-    parser.add_argument('-p', '--dump-statistic', dest="dump_statistic", action="store_true", help="Dump total statistic at the end")
    parser.add_argument('-v', '--version', action="version", version='%(prog)s {version}'.format(version=__version__), help="Show program's version number and exit")

-    parser.add_argument('-gps', '--gcov_prefix_strip', dest="gcov_prefix_strip", action="store", default=0, type=int, help="The number of initial directory names to strip off the absolute paths in the object file.")
-    parser.add_argument('-gp', '--gcov_prefix', dest="gcov_prefix", action="store", default="", help="The prefix to add to the paths in the object file.")
-
    args = parser.parse_args()
-    if not args.output:
-        args.output = 'coverage.info' if args.lcov else 'coverage.json'
+
    return args

 def checkPythonVersion(version):
@@ -1029,12 +717,6 @@ def main():
    # Setup logging
    setupLogging(args.quiet, args.verbose)

-    if args.gcov_prefix_strip > 0:
-        os.environ["GCOV_PREFIX_STRIP"] = str(args.gcov_prefix_strip)
-
-    if len(args.gcov_prefix) > 0:
-        os.environ["GCOV_PREFIX"] = args.gcov_prefix
-
    # Get report from appropriate source
    if args.combine:
        fastcov_json = getCombineCoverage(args)
@@ -1045,16 +727,9 @@ def main():

    # Scan for exclusion markers
    if not skip_exclusion_markers:
-        processExclusionMarkers(fastcov_json, args.jobs, args.exclude_branches_sw, args.include_branches_sw, args.exclude_line_marker, args.minimum_chunk, args.fallback_encodings, args.gcov_prefix, args.gcov_prefix_strip)
+        scanExclusionMarkers(fastcov_json, args.jobs, args.exclude_branches_sw, args.include_branches_sw, args.minimum_chunk, args.fallback_encodings)
        logging.info("Scanned {} source files for exclusion markers".format(len(fastcov_json["sources"])))

-    if args.diff_file:
-        logging.info("Filtering according to {} file".format(args.diff_file))
-        DiffParser().filterByDiff(args.diff_file, args.diff_base_dir, fastcov_json, args.fallback_encodings)
-
-    if args.validate_sources:
-        validateSources(fastcov_json, args.gcov_prefix, args.gcov_prefix_strip)
-
    # Dump to desired file format
    dumpFile(fastcov_json, args)

@@ -1,120 +0,0 @@
-#!/usr/bin/env python3
-# pylint: disable=C0114,C0116,C0209,R0912,R0915
-######################################################################
-
-import argparse
-import os
-import re
-#from pprint import pprint,pformat
-
-#######################################################################
-
-
-def message_section(msg):
-    """Return sorting-section number for given commit message"""
-    if re.match(r'^Support', msg):
-        return 10
-    if re.match(r'^Add', msg):
-        return 20
-    if re.match(r'^Improve', msg):
-        return 30
-    if re.match(r'^Fix', msg):
-        return 40
-    if re.match(r'^(Internals|CI|Tests)', msg):
-        return -1
-    return 0
-
-
-def process():
-    cmd = "git log"
-
-    msgs = {}
-    with os.popen(cmd) as fh:
-        author = ""
-        lineno = 0
-        for line in fh:
-            lineno += 1
-            line = line.rstrip()
-            if re.match(r'^Date', line):
-                continue
-            if re.match(r'^commit', line):
-                continue
-            if re.search(r'Commentary: Changes update', line):
-                break
-
-            am = re.match(r'^Author: (.*) <(.*)>', line)
-            dm = re.match(r'^  +(.*)', line)
-
-            if am:
-                email = am.group(2)
-                author = am.group(1)
-                if re.search(r'antmicro', email):
-                    author += ", Antmicro Ltd."
-                if re.search(r'github action', author):
-                    author = ""
-                    continue
-
-            elif author != "" and dm:
-                msg = dm.group(1)
-                if not re.search(r'\.$', msg):
-                    msg += '.'
-                msg += ' [' + author + ']'
-
-                mid = re.search(r'\(#([0-9][0-9][0-9][0-9]+)', line)
-                if mid:
-                    bug_id = mid.group(1)
-                else:
-                    bug_id = " %d" % lineno
-
-                section = message_section(msg)
-                if section >= 0:
-                    key = "%06s_%06s_%06d" % (section, bug_id, lineno)
-                    msgs[key] = '* ' + msg
-                    # print("i [%s]  %s" % (key, msg))
-
-                author = ""
-
-    if not msgs:
-        print("No Changes need to be inserted.")
-        return
-
-    print()
-    print("Insertion-sort the following lines into 'Changes' file:")
-    print()
-
-    dedup = {}
-    for key in sorted(msgs.keys()):
-        if msgs[key] not in dedup:
-            dedup[msgs[key]] = True
-            print(msgs[key])
-
-    print()
-    print("You may now want to clean up spelling, and commit:")
-    print("  (cd docs ; make spelling)")
-    print("  git ci -am 'Commentary: Changes update'")
-    print()
-
-
-#######################################################################
-
-parser = argparse.ArgumentParser(
-    allow_abbrev=False,
-    prog="log_changes",
-    description="Create example entries for 'Changes' from parsing 'git log'",
-    epilog=
-    """Copyright 2019-2024 by Wilson Snyder. This program is free software; you
-can redistribute it and/or modify it under the terms of either the GNU
-Lesser General Public License Version 3 or the Perl Artistic License
-Version 2.0.
-
-SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0""")
-
-parser.add_argument('--debug', action='store_true', help='enable debug')
-Args = parser.parse_args()
-
-process()
-
-######################################################################
-# Local Variables:
-# compile-command: "cd .. ; nodist/log_changes"
-# End:
@@ -20,26 +20,6 @@ document pnt
  Verilator: Print AstNode NODEP's tree
 end

-# Source python-based gdb config with jshow/jdiff definitions
-# (Stored in separate file, so it can be highlighted/linted/formatted as Python)
-python
-import os
-if "VERILATOR_ROOT" in os.environ:
-  gdbinit_py = os.environ["VERILATOR_ROOT"] + "/src/.gdbinit.py"
-  gdb.execute("source" + gdbinit_py)
-end
-
-define jstash
-  call (char*) &(AstNode::dumpTreeJsonGdb($arg0)[0])
-end
-document jstash
-Verilator: Perform a JSON dump of the given AST node and save it in value history (e.g. $1) for later
-inspection using jtree. The node can be a pointer identifier or an address literal.
-end
-
-alias -a js=jstash
-alias -a jt=jtree
-
 define dtf
  call AstNode::dumpTreeFileGdb($arg0, 0)
 end
@@ -1,80 +0,0 @@
-# pylint: disable=line-too-long,invalid-name,multiple-statements,missing-function-docstring,missing-class-docstring,missing-module-docstring,no-else-return,too-few-public-methods,unused-argument
-# DESCRIPTION: Verilator: GDB startup file with useful define
-#
-# Copyright 2023 by Wilson Snyder. This program is free software; you
-# can redistribute it and/or modify the Verilator internals under the terms
-# of either the GNU Lesser General Public License Version 3 or the Perl
-# Artistic License Version 2.0.
-#
-# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
-######################################################################
-
-import tempfile
-import gdb  # pylint: disable=import-error
-
-
-def _vltgdb_get_dump(node):
-    gdb.execute(f'set $_gdb_dump_json_str = AstNode::dumpTreeJsonGdb({node})')
-    dump = gdb.execute('printf "%s", $_gdb_dump_json_str', to_string=True)
-    gdb.execute('call free($_gdb_dump_json_str)')
-    return dump
-
-
-def _vltgdb_tmpfile():
-    return tempfile.NamedTemporaryFile(mode="wt")  # write, text mode
-
-
-def _vltgdb_fwrite(file, s):
-    """Write to file and flush buffer before passing the file to astsee"""
-    file.write(s)
-    file.flush()
-
-
-class AstseeCmd(gdb.Command):
-    """Verilator: Pretty print or diff nodes using `astsee`. A node can be:
-    * an pointer identifier,
-    * an address literal,
-    * a GDB value (like `$1`) that stores a dump previously done by the `jstash` command.
-    Apart from not taking input from a file, it works exactly like `verilator_astsee`:
-    * passing one node gives you a pretty print,
-    * passing two nodes gives you a diff,
-    * for more options see `astsee` readme/help.
-    For examples see internals.rst
-    """
-
-    def __init__(self):
-        super().__init__("jtree", gdb.COMMAND_USER, gdb.COMPLETE_EXPRESSION)
-
-    def _null_check(self, old, new):
-        err = ""
-        if old == "<nullptr>\n": err += "old == <nullptr>\n"
-        if new == "<nullptr>\n": err += "new == <nullptr>"
-        if err: raise gdb.GdbError(err.strip("\n"))
-
-    def invoke(self, arg_str, from_tty):
-        from astsee import verilator_cli as astsee  # pylint: disable=import-error,import-outside-toplevel
-        # we import it here so "no module X" error would occur on typing `jtree` rather than on every gdb start
-
-        # We hack `astsee_verilator`'s arg parser to find arguments with nodes
-        # After finding them, we replace them with proper files
-        astsee_args = astsee.parser.parse_args(gdb.string_to_argv(arg_str))
-        with _vltgdb_tmpfile() as oldfile, _vltgdb_tmpfile(
-        ) as newfile, _vltgdb_tmpfile() as metafile:
-            if astsee_args.file:
-                _vltgdb_fwrite(oldfile, _vltgdb_get_dump(astsee_args.file))
-                astsee_args.file = oldfile.name
-            if astsee_args.newfile:
-                _vltgdb_fwrite(newfile, _vltgdb_get_dump(astsee_args.newfile))
-                astsee_args.newfile = newfile.name
-            if astsee_args.meta is None:
-                # pass
-                gdb.execute(
-                    f'call AstNode::dumpJsonMetaFileGdb("{metafile.name}")')
-                astsee_args.meta = metafile.name
-            try:
-                astsee.main(astsee_args)
-            except SystemExit as e:  # astsee prints nice errmsgs on exit(), so rethrow it as GdbError to suppress cryptic python trace
-                raise gdb.GdbError("astsee exited with non-zero code") from e
-
-
-AstseeCmd()
@@ -62,10 +62,8 @@ set(HEADERS
    V3DepthBlock.h
    V3Descope.h
    V3Dfg.h
-    V3DfgCache.h
    V3DfgOptimizer.h
    V3DfgPasses.h
-    V3DfgPatternStats.h
    V3DfgPeephole.h
    V3DfgVertices.h
    V3DupFinder.h
@@ -79,7 +77,6 @@ set(HEADERS
    V3EmitV.h
    V3EmitXml.h
    V3Error.h
-    V3ExecGraph.h
    V3Expand.h
    V3File.h
    V3FileLine.h
@@ -122,7 +119,6 @@ set(HEADERS
    V3OptionParser.h
    V3Options.h
    V3Order.h
-    V3OrderInternal.h
    V3OrderGraph.h
    V3OrderMoveGraph.h
    V3Os.h
@@ -131,9 +127,10 @@ set(HEADERS
    V3Parse.h
    V3ParseImp.h
    V3ParseSym.h
+    V3Partition.h
+    V3PartitionGraph.h
    V3PchAstMT.h
    V3PchAstNoMT.h
-    V3PreExpr.h
    V3PreLex.h
    V3PreProc.h
    V3PreShell.h
@@ -142,7 +139,6 @@ set(HEADERS
    V3Randomize.h
    V3Reloop.h
    V3Rtti.h
-    V3Sampled.h
    V3Sched.h
    V3Scope.h
    V3Scoreboard.h
@@ -216,13 +212,11 @@ set(COMMON_SOURCES
    V3Descope.cpp
    V3Dfg.cpp
    V3DfgAstToDfg.cpp
-    V3DfgCache.cpp
    V3DfgDecomposition.cpp
    V3DfgDfgToAst.cpp
    V3DfgOptimizer.cpp
    V3DfgPasses.cpp
    V3DfgPeephole.cpp
-    V3DfgRegularize.cpp
    V3DupFinder.cpp
    V3Timing.cpp
    V3EmitCBase.cpp
@@ -240,7 +234,6 @@ set(COMMON_SOURCES
    V3EmitV.cpp
    V3EmitXml.cpp
    V3Error.cpp
-    V3ExecGraph.cpp
    V3Expand.cpp
    V3File.cpp
    V3FileLine.cpp
@@ -277,19 +270,14 @@ set(COMMON_SOURCES
    V3OptionParser.cpp
    V3Options.cpp
    V3Order.cpp
-    V3OrderGraphBuilder.cpp
-    V3OrderMoveGraph.cpp
-    V3OrderParallel.cpp
-    V3OrderProcessDomains.cpp
-    V3OrderSerial.cpp
    V3Os.cpp
    V3Param.cpp
+    V3Partition.cpp
    V3PreShell.cpp
    V3Premit.cpp
    V3ProtectLib.cpp
    V3Randomize.cpp
    V3Reloop.cpp
-    V3Sampled.cpp
    V3Sched.cpp
    V3SchedAcyclic.cpp
    V3SchedPartition.cpp
@@ -482,7 +470,6 @@ set_target_properties(${verilator} PROPERTIES
    MSVC_RUNTIME_LIBRARY  MultiThreaded$<IF:$<CONFIG:Release>,,DebugDLL>
    #JOB_POOL_LINK         one_job      # Linking takes lots of resources
    INTERPROCEDURAL_OPTIMIZATION_RELEASE  $<IF:MINGW,FALSE,TRUE>
-    INCLUDE_DIRECTORIES ${FLEX_INCLUDE_DIR}
 )

 add_dependencies(${verilator}
@@ -490,8 +477,6 @@ add_dependencies(${verilator}
    V3PreLex_yy_cpp${CMAKE_BUILD_TYPE}
 )

-target_link_libraries(${verilator} PRIVATE Threads::Threads)
-
 # verilated_cov_key.h is only regenerated in a single-configuration environment.
 # This limitation can be lifted when `add_dependencies` will support generator
 # expressions. See https://gitlab.kitware.com/cmake/cmake/issues/19467
@@ -56,7 +56,6 @@ pkgdatadir = @pkgdatadir@
 # Compile options
 CFG_WITH_CCWARN = @CFG_WITH_CCWARN@
 CFG_WITH_DEFENV = @CFG_WITH_DEFENV@
-CFG_WITH_SOLVER = @CFG_WITH_SOLVER@
 CPPFLAGS += @CPPFLAGS@
 CFLAGS += @CFLAGS@
 CXXFLAGS += @CXXFLAGS@
@@ -126,13 +125,6 @@ ifeq ($(CFG_WITH_DEFENV),yes)
 else
  CPPFLAGS += -DDEFENV_VERILATOR_ROOT=\"$(VERILATOR_ROOT)\"
 endif
- ifneq ($(CFG_WITH_SOLVER),no)
-  CPPFLAGS += -DDEFENV_VERILATOR_SOLVER='"$(CFG_WITH_SOLVER)"'
- else
-  ifneq ($(VERILATOR_SOLVER),)
-   CPPFLAGS += -DDEFENV_VERILATOR_SOLVER='"$(VERILATOR_SOLVER)"'
-  endif
- endif
 endif

 HEADERS = $(wildcard V*.h v*.h)
@@ -236,13 +228,11 @@ RAW_OBJS_PCH_ASTNOMT = \
 	V3Descope.o \
 	V3Dfg.o \
 	V3DfgAstToDfg.o \
-	V3DfgCache.o \
 	V3DfgDecomposition.o \
 	V3DfgDfgToAst.o \
 	V3DfgOptimizer.o \
 	V3DfgPasses.o \
 	V3DfgPeephole.o \
-	V3DfgRegularize.o \
 	V3DupFinder.o \
 	V3EmitCMain.o \
 	V3EmitCMake.o \
@@ -250,7 +240,6 @@ RAW_OBJS_PCH_ASTNOMT = \
 	V3EmitCSyms.o \
 	V3EmitMk.o \
 	V3EmitXml.o \
-	V3ExecGraph.o \
 	V3Expand.o \
 	V3Force.o \
 	V3Fork.o \
@@ -274,17 +263,12 @@ RAW_OBJS_PCH_ASTNOMT = \
 	V3MergeCond.o \
 	V3Name.o \
 	V3Order.o \
-	V3OrderGraphBuilder.o \
-	V3OrderMoveGraph.o \
-	V3OrderParallel.o \
-	V3OrderProcessDomains.o \
-	V3OrderSerial.o \
 	V3Param.o \
+	V3Partition.o \
 	V3Premit.o \
 	V3ProtectLib.o \
 	V3Randomize.o \
 	V3Reloop.o \
-	V3Sampled.o \
 	V3Sched.o \
 	V3SchedAcyclic.o \
 	V3SchedPartition.o \
@@ -97,8 +97,8 @@ protected:
            result = vertexp->user();
            break;
        case LatchDetectGraphVertex::VT_BLOCK:  // (OR of potentially many siblings)
-            for (V3GraphEdge& edge : vertexp->outEdges()) {
-                if (latchCheckInternal(castVertexp(edge.top()))) {
+            for (V3GraphEdge* edgep = vertexp->outBeginp(); edgep; edgep = edgep->outNextp()) {
+                if (latchCheckInternal(castVertexp(edgep->top()))) {
                    result = true;
                    break;
                }
@@ -106,8 +106,9 @@ protected:
            break;
        case LatchDetectGraphVertex::VT_BRANCH:  // (AND of both sibling)
                                                 // A BRANCH vertex always has exactly 2 siblings
-            LatchDetectGraphVertex* const ifp = castVertexp(vertexp->outEdges().frontp()->top());
-            LatchDetectGraphVertex* const elsp = castVertexp(vertexp->outEdges().backp()->top());
+            LatchDetectGraphVertex* const ifp = castVertexp(vertexp->outBeginp()->top());
+            LatchDetectGraphVertex* const elsp
+                = castVertexp(vertexp->outBeginp()->outNextp()->top());
            result = latchCheckInternal(ifp) && latchCheckInternal(elsp);
            break;
        }
@@ -169,7 +170,7 @@ public:
        for (const auto& vrp : m_outputs) {
            LatchDetectGraphVertex* const vertp = castVertexp(vrp->varp()->user1p());
            vertp->user(true);  // Identify the output vertex we are checking paths _to_
-            if (!latchCheckInternal(castVertexp(vertices().frontp()))) latch_detected = true;
+            if (!latchCheckInternal(castVertexp(verticesBeginp()))) latch_detected = true;
            if (latch_detected && !latch_expected) {
                nodep->v3warn(
                    LATCH,
@@ -68,7 +68,7 @@ class ActiveTopVisitor final : public VNVisitor {
        UINFO(4, "   ACTIVE " << nodep << endl);
        // Remove duplicate clocks and such; sensesp() may change!
        V3Const::constifyExpensiveEdit(nodep);
-        AstSenTree* sensesp = nodep->sensesp();
+        AstSenTree* const sensesp = nodep->sensesp();
        UASSERT_OBJ(sensesp, nodep, "nullptr");
        if (sensesp->sensesp() && sensesp->sensesp()->isNever()) {
            // Never executing.  Kill it.
@@ -77,21 +77,6 @@ class ActiveTopVisitor final : public VNVisitor {
            VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
            return;
        }
-
-        // Delete empty procedures
-        for (AstNode *stmtp = nodep->stmtsp(), *nextp; stmtp; stmtp = nextp) {
-            nextp = stmtp->nextp();
-            if (AstNodeProcedure* const procp = VN_CAST(stmtp, NodeProcedure)) {
-                if (!procp->stmtsp()) VL_DO_DANGLING(pushDeletep(procp->unlinkFrBack()), stmtp);
-            }
-        }
-
-        // Delete empty actives
-        if (!nodep->stmtsp()) {
-            VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
-            return;
-        }
-
        // Move the SENTREE for each active up to the global level.
        // This way we'll easily see what clock domains are identical
        AstSenTree* const wantp = m_finder.getSenTree(sensesp);
@@ -106,7 +91,7 @@ class ActiveTopVisitor final : public VNVisitor {
                // There may be other references to same sense tree,
                // we'll be removing all references when we get to them,
                // but don't dangle our pointer yet!
-                VL_DO_DANGLING(pushDeletep(sensesp), sensesp);
+                pushDeletep(sensesp);
            }
            nodep->sensesp(wantp);
        }
@@ -26,10 +26,13 @@ VL_DEFINE_DEBUG_FUNCTIONS;
 // Assert class functions

 class AssertVisitor final : public VNVisitor {
-    // CONSTANTS
-    static constexpr uint8_t ALL_ASSERT_TYPES
-        = std::numeric_limits<std::underlying_type<VAssertType::en>::type>::max();
-
+    // TYPES
+    enum assertType_e : uint8_t {
+        ASSERT_TYPE_INTRINSIC,  // AstNodeAssertIntrinsinc
+        ASSERT_TYPE_SVA,  // SVA, PSL
+        ASSERT_TYPE_CASE,  // unique/unique0/priority case related checks
+        ASSERT_TYPE_IF  // unique/unique0/priority if related checks
+    };
    // NODE STATE/TYPES
    // Cleared on netlist
    //  AstNode::user()         -> bool.  True if processed
@@ -51,82 +54,24 @@ class AssertVisitor final : public VNVisitor {
    bool m_inSampled = false;  // True inside a sampled expression

    // METHODS
-    static AstNodeExpr* assertOnCond(FileLine* fl, VAssertType type,
-                                     VAssertDirectiveType directiveType) {
-        switch (directiveType) {
-        case VAssertDirectiveType::INTRINSIC: return new AstConst{fl, AstConst::BitTrue{}};
-        case VAssertDirectiveType::VIOLATION_CASE: {
-            if (v3Global.opt.assertCaseOn()) {
-                return new AstCExpr{fl, "vlSymsp->_vm_contextp__->assertOn()", 1};
-            }
-            // If assertions are off, have constant propagation rip them out later
-            // This allows syntax errors and such to be detected normally.
-            return new AstConst{fl, AstConst::BitFalse{}};
-        }
-        case VAssertDirectiveType::ASSERT:
-        case VAssertDirectiveType::COVER:
-        case VAssertDirectiveType::ASSUME: {
-            if (v3Global.opt.assertOn()) {
-                return new AstCExpr{fl,
-                                    "vlSymsp->_vm_contextp__->assertOnGet("s + std::to_string(type)
-                                        + ", "s + std::to_string(directiveType) + ")"s,
-                                    1};
-            }
-            return new AstConst{fl, AstConst::BitFalse{}};
-        }
-        case VAssertDirectiveType::INTERNAL:
-        case VAssertDirectiveType::VIOLATION_IF:
-        case VAssertDirectiveType::RESTRICT: {
-            if (v3Global.opt.assertOn()) {
-                return new AstCExpr{fl, "vlSymsp->_vm_contextp__->assertOn()", 1};
-            }
-            return new AstConst{fl, AstConst::BitFalse{}};
-        }
-        }
-        VL_UNREACHABLE;
+    static bool assertTypeOn(assertType_e assertType) {
+        if (assertType == ASSERT_TYPE_INTRINSIC) return true;
+        if (v3Global.opt.assertOn()) return true;
+        if (assertType == ASSERT_TYPE_CASE && v3Global.opt.assertCaseOn()) return true;
+        return false;
    }
    string assertDisplayMessage(AstNode* nodep, const string& prefix, const string& message,
                                VDisplayType severity) {
        if (severity == VDisplayType::DT_ERROR || severity == VDisplayType::DT_FATAL) {
-            return ("[%0t] "s + prefix + ": " + nodep->fileline()->filebasename() + ":"
+            return (string{"[%0t] " + prefix + ": "} + nodep->fileline()->filebasename() + ":"
                    + cvtToStr(nodep->fileline()->lineno()) + ": Assertion failed in %m"
                    + ((message != "") ? ": " : "") + message + "\n");
        } else {
-            return ("[%0t] "s + prefix + ": " + nodep->fileline()->filebasename() + ":"
+            return (string{"[%0t] " + prefix + ": "} + nodep->fileline()->filebasename() + ":"
                    + cvtToStr(nodep->fileline()->lineno()) + ": %m"
                    + ((message != "") ? ": " : "") + message + "\n");
        }
    }
-    static bool resolveAssertType(AstAssertCtl* nodep) {
-        if (!nodep->assertTypesp()) {
-            nodep->ctlAssertTypes(VAssertType{ALL_ASSERT_TYPES});
-            return true;
-        }
-        if (const AstConst* const assertTypesp = VN_CAST(nodep->assertTypesp(), Const)) {
-            nodep->ctlAssertTypes(VAssertType{assertTypesp->toSInt()});
-            return true;
-        }
-        return false;
-    }
-    static bool resolveControlType(AstAssertCtl* nodep) {
-        if (const AstConst* const constp = VN_CAST(nodep->controlTypep(), Const)) {
-            nodep->ctlType(constp->toSInt());
-            return true;
-        }
-        return false;
-    }
-    static bool resolveDirectiveType(AstAssertCtl* nodep) {
-        if (!nodep->directiveTypesp()) {
-            nodep->ctlDirectiveTypes(VAssertDirectiveType::ASSERT | VAssertDirectiveType::ASSUME
-                                     | VAssertDirectiveType::COVER);
-            return true;
-        }
-        if (const AstConst* const directiveTypesp = VN_CAST(nodep->directiveTypesp(), Const)) {
-            nodep->ctlDirectiveTypes(VAssertDirectiveType{directiveTypesp->toSInt()});
-            return true;
-        }
-        return false;
-    }
    void replaceDisplay(AstDisplay* nodep, const string& prefix) {
        nodep->fmtp()->text(
            assertDisplayMessage(nodep, prefix, nodep->fmtp()->text(), nodep->displayType()));
@@ -167,37 +112,43 @@ class AssertVisitor final : public VNVisitor {
        varrefp->classOrPackagep(v3Global.rootp()->dollarUnitPkgAddp());
        return varrefp;
    }
-    static AstNodeStmt* newIfAssertOn(AstNode* bodyp, VAssertDirectiveType directiveType,
-                                      VAssertType type = VAssertType::INTERNAL) {
+    AstNode* newIfAssertOn(AstNode* nodep, assertType_e assertType) {
        // Add a internal if to check assertions are on.
        // Don't make this a AND term, as it's unlikely to need to test this.
-        FileLine* const fl = bodyp->fileline();
+        FileLine* const fl = nodep->fileline();

-        AstNodeExpr* const condp = assertOnCond(fl, type, directiveType);
-        AstNodeIf* const newp = new AstIf{fl, condp, bodyp};
+        // If assertions are off, have constant propagation rip them out later
+        // This allows syntax errors and such to be detected normally.
+        AstNodeExpr* const condp
+            = assertType == ASSERT_TYPE_INTRINSIC
+                  ? static_cast<AstNodeExpr*>(new AstConst{fl, AstConst::BitTrue{}})
+              : assertTypeOn(assertType)
+                  ? static_cast<AstNodeExpr*>(
+                      new AstCExpr{fl, "vlSymsp->_vm_contextp__->assertOn()", 1})
+                  : static_cast<AstNodeExpr*>(new AstConst{fl, AstConst::BitFalse{}});
+        AstNodeIf* const newp = new AstIf{fl, condp, nodep};
        newp->isBoundsCheck(true);  // To avoid LATCH warning
        newp->user1(true);  // Don't assert/cover this if
        return newp;
    }

-    AstNodeStmt* newFireAssertUnchecked(AstNodeStmt* nodep, const string& message,
-                                        AstNodeExpr* exprsp = nullptr) {
+    AstNode* newFireAssertUnchecked(AstNode* nodep, const string& message,
+                                    AstNodeExpr* exprsp = nullptr) {
        // Like newFireAssert() but omits the asserts-on check
        AstDisplay* const dispp
            = new AstDisplay{nodep->fileline(), VDisplayType::DT_ERROR, message, nullptr, nullptr};
        dispp->fmtp()->timeunit(m_modp->timeunit());
-        AstNodeStmt* const bodysp = dispp;
+        AstNode* const bodysp = dispp;
        replaceDisplay(dispp, "%%Error");  // Convert to standard DISPLAY format
        if (exprsp) dispp->fmtp()->exprsp()->addNext(exprsp);
        if (v3Global.opt.stopFail()) bodysp->addNext(new AstStop{nodep->fileline(), true});
        return bodysp;
    }

-    AstNodeStmt* newFireAssert(AstNodeStmt* nodep, VAssertDirectiveType directiveType,
-                               VAssertType assertType, const string& message,
-                               AstNodeExpr* exprsp = nullptr) {
-        AstNodeStmt* bodysp = newFireAssertUnchecked(nodep, message, exprsp);
-        bodysp = newIfAssertOn(bodysp, directiveType, assertType);
+    AstNode* newFireAssert(AstNode* nodep, assertType_e assertType, const string& message,
+                           AstNodeExpr* exprsp = nullptr) {
+        AstNode* bodysp = newFireAssertUnchecked(nodep, message, exprsp);
+        bodysp = newIfAssertOn(bodysp, assertType);
        return bodysp;
    }

@@ -219,7 +170,7 @@ class AssertVisitor final : public VNVisitor {
            if (m_procedurep) {
                // To support this need queue of asserts to activate
                nodep->v3error("Unsupported: Procedural concurrent assertion with"
-                               " clocking event inside always (IEEE 1800-2023 16.14.6)");
+                               " clocking event inside always (IEEE 1800-2017 16.14.6)");
            }
        }
        //
@@ -240,7 +191,6 @@ class AssertVisitor final : public VNVisitor {
            }

            if (bodysp && passsp) bodysp = bodysp->addNext(passsp);
-            if (bodysp) bodysp = newIfAssertOn(bodysp, nodep->directive(), nodep->type());
            ifp = new AstIf{nodep->fileline(), propp, bodysp};
            ifp->isBoundsCheck(true);  // To avoid LATCH warning
            bodysp = ifp;
@@ -250,13 +200,17 @@ class AssertVisitor final : public VNVisitor {
            } else {
                ++m_statAsNotImm;
            }
+            const assertType_e assertType
+                = VN_IS(nodep, AssertIntrinsic) ? ASSERT_TYPE_INTRINSIC : ASSERT_TYPE_SVA;
+            if (passsp) passsp = newIfAssertOn(passsp, assertType);
+            if (failsp) failsp = newIfAssertOn(failsp, assertType);
            if (!passsp && !failsp) failsp = newFireAssertUnchecked(nodep, "'assert' failed.");
            ifp = new AstIf{nodep->fileline(), propp, passsp, failsp};
            ifp->isBoundsCheck(true);  // To avoid LATCH warning
            // It's more LIKELY that we'll take the nullptr if clause
            // than the sim-killing else clause:
            ifp->branchPred(VBranchPred::BP_LIKELY);
-            bodysp = newIfAssertOn(ifp, nodep->directive(), nodep->type());
+            bodysp = newIfAssertOn(ifp, assertType);
        } else {
            nodep->v3fatalSrc("Unknown node type");
        }
@@ -327,17 +281,13 @@ class AssertVisitor final : public VNVisitor {
                = ((allow_none || hasDefaultElse)
                       ? static_cast<AstNodeExpr*>(new AstOneHot0{nodep->fileline(), propp})
                       : static_cast<AstNodeExpr*>(new AstOneHot{nodep->fileline(), propp}));
-            const VAssertType assertType
-                = nodep->uniquePragma() ? VAssertType::UNIQUE : VAssertType::UNIQUE0;
-            AstIf* const checkifp
-                = new AstIf{nodep->fileline(), new AstLogNot{nodep->fileline(), ohot},
-                            newFireAssert(nodep, VAssertDirectiveType::VIOLATION_IF, assertType,
-                                          "'unique if' statement violated"),
-                            newifp};
+            AstIf* const checkifp = new AstIf{
+                nodep->fileline(), new AstLogNot{nodep->fileline(), ohot},
+                newFireAssert(nodep, ASSERT_TYPE_IF, "'unique if' statement violated"), newifp};
            checkifp->isBoundsCheck(true);  // To avoid LATCH warning
            checkifp->branchPred(VBranchPred::BP_UNLIKELY);
            nodep->replaceWith(checkifp);
-            VL_DO_DANGLING(pushDeletep(nodep), nodep);
+            pushDeletep(nodep);
        } else {
            iterateChildren(nodep);
        }
@@ -353,16 +303,6 @@ class AssertVisitor final : public VNVisitor {
                if (itemp->isDefault()) has_default = true;
            }
            const AstNodeDType* exprDtypep = nodep->exprp()->dtypep()->skipRefp();
-
-            VAssertType assertType = VAssertType::INTERNAL;
-            if (nodep->priorityPragma()) {
-                assertType = VAssertType::PRIORITY;
-            } else if (nodep->uniquePragma()) {
-                assertType = VAssertType::UNIQUE;
-            } else if (nodep->unique0Pragma()) {
-                assertType = VAssertType::UNIQUE0;
-            }
-
            string valFmt;
            if (exprDtypep->isIntegralOrPacked())
                valFmt = " for '" + cvtToStr(exprDtypep->widthMin()) + "'h%X'";
@@ -372,7 +312,7 @@ class AssertVisitor final : public VNVisitor {
                if (!has_default) {
                    nodep->addItemsp(new AstCaseItem{
                        nodep->fileline(), nullptr /*DEFAULT*/,
-                        newFireAssert(nodep, VAssertDirectiveType::VIOLATION_CASE, assertType,
+                        newFireAssert(nodep, ASSERT_TYPE_CASE,
                                      nodep->pragmaString() + ", but non-match found" + valFmt,
                                      valFmt.empty() ? nullptr
                                                     : nodep->exprp()->cloneTreePure(false))});
@@ -420,22 +360,19 @@ class AssertVisitor final : public VNVisitor {
                    //     else $error("multiple match");
                    // end
                    AstNodeExpr* const ohot = new AstOneHot{nodep->fileline(), propp};
-                    AstConst* const zero = new AstConst{
-                        nodep->fileline(), AstConst::WidthedValue{}, propp->width(), 0};
                    AstIf* const ohotIfp
                        = new AstIf{nodep->fileline(), new AstLogNot{nodep->fileline(), ohot}};
-                    AstIf* const zeroIfp = new AstIf{
-                        nodep->fileline(),
-                        new AstEq{nodep->fileline(), propp->cloneTreePure(false), zero}};
+                    AstIf* const zeroIfp
+                        = new AstIf{nodep->fileline(),
+                                    new AstLogNot{nodep->fileline(), propp->cloneTreePure(false)}};
                    AstNodeExpr* const exprp = nodep->exprp();
                    const string pragmaStr = nodep->pragmaString();
                    if (!allow_none)
-                        zeroIfp->addThensp(
-                            newFireAssert(nodep, VAssertDirectiveType::VIOLATION_CASE, assertType,
-                                          pragmaStr + ", but none matched" + valFmt,
-                                          valFmt.empty() ? nullptr : exprp->cloneTreePure(false)));
+                        zeroIfp->addThensp(newFireAssert(
+                            nodep, ASSERT_TYPE_CASE, pragmaStr + ", but none matched" + valFmt,
+                            valFmt.empty() ? nullptr : exprp->cloneTreePure(false)));
                    zeroIfp->addElsesp(
-                        newFireAssert(nodep, VAssertDirectiveType::VIOLATION_CASE, assertType,
+                        newFireAssert(nodep, ASSERT_TYPE_CASE,
                                      pragmaStr + ", but multiple matches found" + valFmt,
                                      valFmt.empty() ? nullptr : exprp->cloneTreePure(false)));
                    ohotIfp->addThensp(zeroIfp);
@@ -503,7 +440,6 @@ class AssertVisitor final : public VNVisitor {
                AstSampled* const newp = newSampledExpr(nodep);
                relinkHandle.relink(newp);
                newp->user1(1);
-                v3Global.setHasSampled();
            }
        }
    }
@@ -531,22 +467,6 @@ class AssertVisitor final : public VNVisitor {
        } else if (nodep->displayType() == VDisplayType::DT_MONITOR) {
            nodep->displayType(VDisplayType::DT_DISPLAY);
            const auto fl = nodep->fileline();
-            AstNode* monExprsp = nodep->fmtp()->exprsp();
-            AstSenItem* monSenItemsp = nullptr;
-            while (monExprsp) {
-                if (AstNodeVarRef* varrefp = VN_CAST(monExprsp, NodeVarRef)) {
-                    AstSenItem* const senItemp
-                        = new AstSenItem(fl, VEdgeType::ET_CHANGED,
-                                         new AstVarRef{fl, varrefp->varp(), VAccess::READ});
-                    if (!monSenItemsp) {
-                        monSenItemsp = senItemp;
-                    } else {
-                        monSenItemsp->addNext(senItemp);
-                    }
-                }
-                monExprsp = monExprsp->nextp();
-            }
-            AstSenTree* const monSenTree = new AstSenTree{fl, monSenItemsp};
            const auto monNum = ++m_monitorNum;
            // Where $monitor was we do "__VmonitorNum = N;"
            const auto newsetp = new AstAssign{fl, newMonitorNumVarRefp(nodep, VAccess::WRITE),
@@ -562,7 +482,7 @@ class AssertVisitor final : public VNVisitor {
                stmtsp};
            ifp->isBoundsCheck(true);  // To avoid LATCH warning
            ifp->branchPred(VBranchPred::BP_UNLIKELY);
-            AstNode* const newp = new AstAlways{fl, VAlwaysKwd::ALWAYS, monSenTree, ifp};
+            AstNode* const newp = new AstAlways{fl, VAlwaysKwd::ALWAYS, nullptr, ifp};
            m_modp->addStmtsp(newp);
        } else if (nodep->displayType() == VDisplayType::DT_STROBE) {
            nodep->displayType(VDisplayType::DT_DISPLAY);
@@ -598,81 +518,6 @@ class AssertVisitor final : public VNVisitor {
        iterateChildren(nodep);
        newPslAssertion(nodep, nodep->failsp());
    }
-    void visit(AstAssertCtl* nodep) override {
-        if (VN_IS(m_modp, Class) || VN_IS(m_modp, Iface)) {
-            nodep->v3warn(E_UNSUPPORTED, "Unsupported: assertcontrols in classes or interfaces");
-            VL_DO_DANGLING(pushDeletep(nodep->unlinkFrBack()), nodep);
-            return;
-        }
-
-        iterateChildren(nodep);
-
-        if (!resolveAssertType(nodep)) {
-            nodep->v3warn(E_UNSUPPORTED,
-                          "Unsupported: non-constant assert assertion-type expression");
-            VL_DO_DANGLING(pushDeletep(nodep->unlinkFrBack()), nodep);
-            return;
-        }
-        if (nodep->ctlAssertTypes() != ALL_ASSERT_TYPES
-            && nodep->ctlAssertTypes().containsAny(VAssertType::EXPECT | VAssertType::UNIQUE
-                                                   | VAssertType::UNIQUE0
-                                                   | VAssertType::PRIORITY)) {
-            nodep->v3warn(E_UNSUPPORTED, "Unsupported: assert control assertion_type");
-            VL_DO_DANGLING(pushDeletep(nodep->unlinkFrBack()), nodep);
-            return;
-        }
-        if (!resolveControlType(nodep)) {
-            nodep->v3warn(E_UNSUPPORTED, "Unsupported: non-const assert control type expression");
-            VL_DO_DANGLING(pushDeletep(nodep->unlinkFrBack()), nodep);
-            return;
-        }
-        if (!resolveDirectiveType(nodep)) {
-            nodep->v3warn(E_UNSUPPORTED,
-                          "Unsupported: non-const assert directive type expression");
-            VL_DO_DANGLING(pushDeletep(nodep->unlinkFrBack()), nodep);
-            return;
-        }
-
-        FileLine* const fl = nodep->fileline();
-        switch (nodep->ctlType()) {
-        case VAssertCtlType::ON:
-            UINFO(9, "Generating assertctl for a module: " << m_modp << endl);
-            nodep->replaceWith(new AstCExpr{
-                fl,
-                "vlSymsp->_vm_contextp__->assertOnSet("s + std::to_string(nodep->ctlAssertTypes())
-                    + ", "s + std::to_string(nodep->ctlDirectiveTypes()) + ");\n"s,
-                1});
-            break;
-        case VAssertCtlType::OFF:
-        case VAssertCtlType::KILL: {
-            UINFO(9, "Generating assertctl for a module: " << m_modp << endl);
-            nodep->replaceWith(new AstCExpr{fl,
-                                            "vlSymsp->_vm_contextp__->assertOnClear("s
-                                                + std::to_string(nodep->ctlAssertTypes()) + " ,"s
-                                                + std::to_string(nodep->ctlDirectiveTypes())
-                                                + ");\n"s,
-                                            1});
-            break;
-        }
-        case VAssertCtlType::LOCK:
-        case VAssertCtlType::UNLOCK:
-        case VAssertCtlType::PASS_ON:
-        case VAssertCtlType::PASS_OFF:
-        case VAssertCtlType::FAIL_ON:
-        case VAssertCtlType::FAIL_OFF:
-        case VAssertCtlType::NONVACUOUS_ON:
-        case VAssertCtlType::VACUOUS_OFF: {
-            nodep->unlinkFrBack();
-            nodep->v3warn(E_UNSUPPORTED, "Unsupported assertcontrol control_type");
-            break;
-        }
-        default: {
-            nodep->unlinkFrBack();
-            nodep->v3warn(EC_ERROR, "Bad assertcontrol control_type (IEEE 1800-2023 Table 20-5)");
-        }
-        }
-        VL_DO_DANGLING(pushDeletep(nodep), nodep);
-    }
    void visit(AstAssertIntrinsic* nodep) override {
        iterateChildren(nodep);
        newPslAssertion(nodep, nodep->failsp());
@@ -57,7 +57,6 @@ private:
    bool m_inAssign = false;  // True if in an AssignNode
    bool m_inAssignDlyLhs = false;  // True if in AssignDly's LHS
    bool m_inSynchDrive = false;  // True if in synchronous drive
-    std::vector<AstVarXRef*> m_xrefsp;  // list of xrefs that need name fixup

    // METHODS

@@ -116,9 +115,8 @@ private:
                    AstArg* const argp = tconnect.second;
                    AstNode* const pinp = argp->exprp()->unlinkFrBack();
                    replaceVarRefsWithExprRecurse(propExprp, portp, pinp);
-                    VL_DO_DANGLING(pushDeletep(pinp), pinp);
                }
-                // Handle case with 2 disable iff statement (IEEE 1800-2023 16.12.1)
+                // Handle case with 2 disable iff statement (IEEE 1800-2017 16.12.1)
                if (nodep->disablep() && propExprp->disablep()) {
                    nodep->v3error("disable iff expression before property call and in its "
                                   "body is not legal");
@@ -157,72 +155,35 @@ private:
        m_clockingp = nodep;
        UINFO(8, "   CLOCKING" << nodep << endl);
        iterateChildren(nodep);
-        if (nodep->eventp()) nodep->addNextHere(nodep->eventp()->unlinkFrBack());
-        VL_DO_DANGLING(pushDeletep(nodep->unlinkFrBack()), nodep);
    }
    void visit(AstClockingItem* const nodep) override {
-        // Get a ref to the sampled/driven variable
-        AstVar* const varp = nodep->varp();
-        if (!varp) {
-            // Unused item
-            pushDeletep(nodep->unlinkFrBack());
-            return;
-        }
        FileLine* const flp = nodep->fileline();
        V3Const::constifyEdit(nodep->skewp());
        if (!VN_IS(nodep->skewp(), Const)) {
-            nodep->skewp()->v3error("Skew must be constant (IEEE 1800-2023 14.4)");
+            nodep->skewp()->v3error("Skew must be constant (IEEE 1800-2017 14.4)");
            VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
            return;
        }
        AstConst* const skewp = VN_AS(nodep->skewp(), Const);
        if (skewp->num().isNegative()) skewp->v3error("Skew cannot be negative");
        AstNodeExpr* const exprp = nodep->exprp();
-        varp->name(m_clockingp->name() + "__DOT__" + varp->name());
-        m_clockingp->addNextHere(varp->unlinkFrBack());
+        // Get a ref to the sampled/driven variable
+        AstVar* const varp = nodep->varp()->unlinkFrBack();
+        m_clockingp->addVarsp(varp);
        varp->user1p(nodep);
        if (nodep->direction() == VDirection::OUTPUT) {
-            exprp->foreach([](AstNodeVarRef* varrefp) {
-                // Prevent confusing BLKANDNBLK warnings on clockvars due to generated assignments
-                varrefp->fileline()->warnOff(V3ErrorCode::BLKANDNBLK, true);
-            });
-            AstVarRef* const skewedReadRefp = new AstVarRef{flp, varp, VAccess::READ};
-            skewedReadRefp->user1(true);
-            // Initialize the clockvar
-            AstVarRef* const skewedWriteRefp = new AstVarRef{flp, varp, VAccess::WRITE};
-            skewedWriteRefp->user1(true);
-            AstInitialStatic* const initClockvarp = new AstInitialStatic{
-                flp, new AstAssign{flp, skewedWriteRefp, exprp->cloneTreePure(false)}};
-            m_modp->addStmtsp(initClockvarp);
-            // A var to keep the previous value of the clockvar
-            AstVar* const prevVarp = new AstVar{
-                flp, VVarType::MODULETEMP, "__Vclocking_prev__" + varp->name(), exprp->dtypep()};
-            prevVarp->lifetime(VLifetime::STATIC);
-            AstInitialStatic* const initPrevClockvarp = new AstInitialStatic{
-                flp, new AstAssign{flp, new AstVarRef{flp, prevVarp, VAccess::WRITE},
-                                   skewedReadRefp->cloneTreePure(false)}};
-            m_modp->addStmtsp(prevVarp);
-            m_modp->addStmtsp(initPrevClockvarp);
-            // Assign the clockvar to the actual var; only do it if the clockvar's value has
-            // changed
-            AstAssign* const assignp
-                = new AstAssign{flp, exprp->cloneTreePure(false), skewedReadRefp};
-            AstIf* const ifp
-                = new AstIf{flp,
-                            new AstNeq{flp, new AstVarRef{flp, prevVarp, VAccess::READ},
-                                       skewedReadRefp->cloneTreePure(false)},
-                            assignp};
-            ifp->addThensp(new AstAssign{flp, new AstVarRef{flp, prevVarp, VAccess::WRITE},
-                                         skewedReadRefp->cloneTree(false)});
+            AstVarRef* const skewedRefp = new AstVarRef{flp, varp, VAccess::READ};
+            skewedRefp->user1(true);
+            AstAssign* const assignp = new AstAssign{flp, exprp->cloneTreePure(false), skewedRefp};
            if (skewp->isZero()) {
-                // Drive the var in Re-NBA (IEEE 1800-2023 14.16)
+                // Drive the var in Re-NBA (IEEE 1800-2017 14.16)
                m_clockingp->addNextHere(new AstAlwaysReactive{
-                    flp, new AstSenTree{flp, m_clockingp->sensesp()->cloneTree(false)}, ifp});
+                    flp, new AstSenTree{flp, m_clockingp->sensesp()->cloneTree(false)}, assignp});
            } else if (skewp->fileline()->timingOn()) {
                // Create a fork so that this AlwaysObserved can be retriggered before the
                // assignment happens. Also then it can be combo, avoiding the need for creating
                // new triggers.
-                AstFork* const forkp = new AstFork{flp, "", ifp};
+                AstFork* const forkp = new AstFork{flp, "", assignp};
                forkp->joinType(VJoinType::JOIN_NONE);
                // Use Observed for this to make sure we do not miss the event
                m_clockingp->addNextHere(new AstAlwaysObserved{
@@ -245,12 +206,12 @@ private:
            AstVarRef* const refp = new AstVarRef{flp, varp, VAccess::WRITE};
            refp->user1(true);
            if (skewp->num().is1Step()) {
-                // Assign the sampled expression to the clockvar (IEEE 1800-2023 14.13)
+                // Assign the sampled expression to the clockvar (IEEE 1800-2017 14.13)
                AstSampled* const sampledp = new AstSampled{flp, exprp->cloneTreePure(false)};
                sampledp->dtypeFrom(exprp);
                m_clockingp->addNextHere(new AstAssignW{flp, refp, sampledp});
            } else if (skewp->isZero()) {
-                // #0 means the var has to be sampled in Observed (IEEE 1800-2023 14.13)
+                // #0 means the var has to be sampled in Observed (IEEE 1800-2017 14.13)
                AstAssign* const assignp = new AstAssign{flp, refp, exprp->cloneTreePure(false)};
                m_clockingp->addNextHere(new AstAlwaysObserved{
                    flp, new AstSenTree{flp, m_clockingp->sensesp()->cloneTree(false)}, assignp});
@@ -259,9 +220,9 @@ private:
                AstSampleQueueDType* const queueDtp
                    = new AstSampleQueueDType{flp, exprp->dtypep()};
                m_netlistp->typeTablep()->addTypesp(queueDtp);
-                AstVar* const queueVarp
-                    = new AstVar{flp, VVarType::MODULETEMP, "__Vqueue__" + varp->name(), queueDtp};
-                queueVarp->lifetime(VLifetime::STATIC);
+                AstVar* const queueVarp = new AstVar{
+                    flp, VVarType::MODULETEMP,
+                    "__Vqueue__" + m_clockingp->name() + "__DOT__" + varp->name(), queueDtp};
                m_clockingp->addNextHere(queueVarp);
                // Create a process like this:
                //     always queue.push(<sampled var>);
@@ -273,7 +234,7 @@ private:
                m_clockingp->addNextHere(
                    new AstAlways{flp, VAlwaysKwd::ALWAYS, nullptr, pushp->makeStmt()});
                // Create a process like this:
-                //     always @<clocking event> queue.pop(<skew>, /*out*/<skewed var>);
+                //     always @<clocking event> queue.pop(<skew>, /*out*/<skewed var>});
                AstCMethodHard* const popp = new AstCMethodHard{
                    flp, new AstVarRef{flp, queueVarp, VAccess::READWRITE}, "pop",
                    new AstTime{nodep->fileline(), m_modp->timeunit()}};
@@ -288,21 +249,20 @@ private:
        } else {
            nodep->v3fatal("Invalid direction");
        }
-        VL_DO_DANGLING(pushDeletep(nodep->unlinkFrBack()), nodep);
+        pushDeletep(nodep->unlinkFrBack());
    }
    void visit(AstDelay* nodep) override {
        // Only cycle delays are relevant in this stage; also only process once
        if (!nodep->isCycleDelay()) {
            if (m_inSynchDrive) {
                nodep->v3error("Only cycle delays can be used in synchronous drives"
-                               " (IEEE 1800-2023 14.16)");
+                               " (IEEE 1800-2017 14.16)");
            }
-            iterateChildren(nodep);
            return;
        }
        if (m_inAssign && !m_inSynchDrive) {
            nodep->v3error("Cycle delays not allowed as intra-assignment delays"
-                           " (IEEE 1800-2023 14.11)");
+                           " (IEEE 1800-2017 14.11)");
            VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
            return;
        }
@@ -313,14 +273,12 @@ private:
        if (constp->isZero()) {
            nodep->v3warn(E_UNSUPPORTED, "Unsupported: ##0 delays");
            VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
-            VL_DO_DANGLING(valuep->deleteTree(), valuep);
            return;
        }
        if (!m_defaultClockingp) {
            nodep->v3error("Usage of cycle delays requires default clocking"
-                           " (IEEE 1800-2023 14.11)");
+                           " (IEEE 1800-2017 14.11)");
            VL_DO_DANGLING(nodep->unlinkFrBack()->deleteTree(), nodep);
-            VL_DO_DANGLING(valuep->deleteTree(), valuep);
            return;
        }
        AstEventControl* const controlp = new AstEventControl{
@@ -329,8 +287,6 @@ private:
        const std::string delayName = m_cycleDlyNames.get(nodep);
        AstVar* const cntVarp = new AstVar{flp, VVarType::BLOCKTEMP, delayName + "__counter",
                                           nodep->findBasicDType(VBasicDTypeKwd::UINT32)};
-        cntVarp->lifetime(VLifetime::AUTOMATIC);
-        cntVarp->funcLocal(true);
        AstBegin* const beginp = new AstBegin{flp, delayName + "__block", cntVarp, false, true};
        beginp->addStmtsp(new AstAssign{flp, new AstVarRef{flp, cntVarp, VAccess::WRITE}, valuep});
        beginp->addStmtsp(new AstWhile{
@@ -346,62 +302,24 @@ private:
    void visit(AstSenTree* nodep) override {
        if (m_inSynchDrive) {
            nodep->v3error("Event controls cannot be used in "
-                           "synchronous drives (IEEE 1800-2023 14.16)");
+                           "synchronous drives (IEEE 1800-2017 14.16)");
        }
    }
    void visit(AstNodeVarRef* nodep) override {
-        UINFO(8, " -varref:  " << nodep << endl);
-        UINFO(8, " -varref-var-back:  " << nodep->varp()->backp() << endl);
-        UINFO(8, " -varref-var-user1:  " << nodep->varp()->user1p() << endl);
-        if (AstClockingItem* const itemp = VN_CAST(
-                nodep->varp()->user1p() ? nodep->varp()->user1p() : nodep->varp()->firstAbovep(),
-                ClockingItem)) {
-            if (nodep->user1()) return;
-
-            // ensure linking still works, this has to be done only once
-            if (AstVarXRef* xrefp = VN_CAST(nodep, VarXRef)) {
-                UINFO(8, " -clockvarxref-in:  " << xrefp << endl);
-                string dotted = xrefp->dotted();
-                const size_t dotPos = dotted.rfind('.');
-                dotted.erase(dotPos, string::npos);
-                xrefp->dotted(dotted);
-                UINFO(8, " -clockvarxref-out: " << xrefp << endl);
-                m_xrefsp.emplace_back(xrefp);
-            }
-
-            if (nodep->access().isReadOrRW() && itemp->direction() == VDirection::OUTPUT) {
-                nodep->v3error("Cannot read from output clockvar (IEEE 1800-2023 14.3)");
+        if (AstClockingItem* const itemp = VN_CAST(nodep->varp()->user1p(), ClockingItem)) {
+            if (nodep->access().isReadOrRW() && !nodep->user1()
+                && itemp->direction() == VDirection::OUTPUT) {
+                nodep->v3error("Cannot read from output clockvar (IEEE 1800-2017 14.3)");
            }
            if (nodep->access().isWriteOrRW()) {
                if (itemp->direction() == VDirection::OUTPUT) {
                    if (!m_inAssignDlyLhs) {
                        nodep->v3error("Only non-blocking assignments can write "
-                                       "to clockvars (IEEE 1800-2023 14.16)");
+                                       "to clockvars (IEEE 1800-2017 14.16)");
                    }
                    if (m_inAssign) m_inSynchDrive = true;
-                } else if (itemp->direction() == VDirection::INPUT) {
-                    nodep->v3error("Cannot write to input clockvar (IEEE 1800-2023 14.3)");
-                }
-            }
-            nodep->user1(true);
-        }
-    }
-    void visit(AstMemberSel* nodep) override {
-        if (AstClockingItem* const itemp = VN_CAST(
-                nodep->varp()->user1p() ? nodep->varp()->user1p() : nodep->varp()->firstAbovep(),
-                ClockingItem)) {
-            if (nodep->access().isReadOrRW() && itemp->direction() == VDirection::OUTPUT) {
-                nodep->v3error("Cannot read from output clockvar (IEEE 1800-2023 14.3)");
-            }
-            if (nodep->access().isWriteOrRW()) {
-                if (itemp->direction() == VDirection::OUTPUT) {
-                    if (!m_inAssignDlyLhs) {
-                        nodep->v3error("Only non-blocking assignments can write "
-                                       "to clockvars (IEEE 1800-2023 14.16)");
-                    }
-                    if (m_inAssign) m_inSynchDrive = true;
-                } else if (itemp->direction() == VDirection::INPUT) {
-                    nodep->v3error("Cannot write to input clockvar (IEEE 1800-2023 14.3)");
+                } else if (!nodep->user1() && itemp->direction() == VDirection::INPUT) {
+                    nodep->v3error("Cannot write to input clockvar (IEEE 1800-2017 14.3)");
                }
            }
        }
@@ -545,7 +463,7 @@ private:
            if (clockingp->isDefault()) {
                if (m_defaultClockingp) {
                    clockingp->v3error("Only one default clocking block allowed per module"
-                                       " (IEEE 1800-2023 14.12)");
+                                       " (IEEE 1800-2017 14.12)");
                }
                m_defaultClockingp = clockingp;
            }
@@ -567,8 +485,6 @@ public:
        clearAssertInfo();
        // Process
        iterate(nodep);
-        // Fix up varref names
-        for (AstVarXRef* xrefp : m_xrefsp) xrefp->name(xrefp->varp()->name());
    }
    ~AssertPreVisitor() override = default;
 };
@@ -17,6 +17,7 @@
 #include "V3PchAstMT.h"

 #include "V3Broken.h"
+#include "V3EmitV.h"
 #include "V3File.h"

 #include <iomanip>
@@ -801,6 +802,7 @@ AstNode* AstNode::cloneTreeIter(bool needPure) {
                         << this->warnMore()
                         << "... Suggest use a temporary variable in place of this expression");
        // this->v3fatalSrc("cloneTreePure debug backtrace");  // Comment in to debug where caused
+        // it
    }
    AstNode* const newp = this->clone();
    if (this->m_op1p) newp->op1p(this->m_op1p->cloneTreeIterList(needPure));
@@ -1169,50 +1171,8 @@ void AstNode::checkTreeIter(const AstNode* prevBackp) const VL_MT_STABLE {
        default: this->v3fatalSrc("Bad case"); break;
        }
    }
-    if (v3Global.opt.debugWidth() && v3Global.widthMinUsage() == VWidthMinUsage::VERILOG_WIDTH) {
-        if (const AstNodeExpr* const exprp = VN_CAST(this, NodeExpr)) {
-            const char* const whyp = exprp->widthMismatch();
-            if (whyp) {
-                auto dtypeStr = [](const AstNodeExpr* exprp) VL_MT_STABLE {
-                    std::ostringstream ss;
-                    exprp->dtypep()->dumpSmall(ss);
-                    return ss.str();
-                };
-                if (const AstNodeUniop* const uniopp = VN_CAST(exprp, NodeUniop)) {
-                    UASSERT_OBJ(!whyp, uniopp,
-                                "widthMismatch detected " << whyp << "OUT:" << dtypeStr(uniopp)
-                                                          << " LHS:" << dtypeStr(uniopp->lhsp()));
-                } else if (const AstNodeBiop* const biopp = VN_CAST(exprp, NodeBiop)) {
-                    UASSERT_OBJ(!whyp, biopp,
-                                "widthMismatch detected " << whyp << "OUT:" << dtypeStr(biopp)
-                                                          << " LHS:" << dtypeStr(biopp->lhsp())
-                                                          << " RHS:" << dtypeStr(biopp->rhsp()));
-                } else {
-                    UASSERT_OBJ(false, exprp,
-                                "widthMismatch detected " << whyp << " in an unexpected type");
-                }
-            }
-        }
-    }
 }

-// cppcheck-suppress unusedFunction  // Debug only
-char* AstNode::dumpTreeJsonGdb(const AstNode* nodep) {
-    if (!nodep) return strdup("{\"addr\":\"NULL\"}\n");
-    std::stringstream nodepStream;
-    nodep->dumpTreeJson(nodepStream);
-    const std::string str = nodepStream.rdbuf()->str();
-    return strdup(str.c_str());
-}
-// cppcheck-suppress unusedFunction  // Debug only
-// identity func to allow for passing already done dumps to jtree
-char* AstNode::dumpTreeJsonGdb(const char* str) { return strdup(str); }
-// cppcheck-suppress unusedFunction  // Debug only
-// allow for passing pointer literals like 0x42.. without manual cast
-char* AstNode::dumpTreeJsonGdb(intptr_t nodep) {
-    if (!nodep) return strdup("{\"addr\":\"NULL\"}\n");
-    return dumpTreeJsonGdb((const AstNode*)nodep);
-}
 // cppcheck-suppress unusedFunction  // Debug only
 void AstNode::dumpGdb(const AstNode* nodep) {  // For GDB only  // LCOV_EXCL_LINE
    if (!nodep) {
@@ -1316,7 +1276,7 @@ void AstNode::dumpTreeAndNext(std::ostream& os, const string& indent, int maxDep
    }
 }

-void AstNode::dumpTreeFile(const string& filename, bool doDump) {
+void AstNode::dumpTreeFile(const string& filename, bool doDump, bool doCheck) {
    // Not const function as calls checkTree
    if (doDump) {
        {  // Write log & close
@@ -1334,6 +1294,14 @@ void AstNode::dumpTreeFile(const string& filename, bool doDump) {
            }
        }
    }
+    if (doDump && v3Global.opt.debugEmitV()) V3EmitV::debugEmitV(filename + ".v");
+    if (doCheck && (v3Global.opt.debugCheck() || ::dumpTreeLevel())) {
+        // Error check
+        checkTree();
+        // Broken isn't part of check tree because it can munge iterp's
+        // set by other steps if it is called in the middle of other operations
+        if (AstNetlist* const netp = VN_CAST(this, Netlist)) V3Broken::brokenAll(netp);
+    }
 }

 static void drawChildren(std::ostream& os, const AstNode* thisp, const AstNode* childp,
@@ -1372,11 +1340,10 @@ void AstNode::dumpTreeJsonFile(const string& filename, bool doDump) {
    *treejsonp << '\n';
 }

-void AstNode::dumpJsonMetaFileGdb(const char* filename) { dumpJsonMetaFile(filename); }
 void AstNode::dumpJsonMetaFile(const string& filename) {
    UINFO(2, "Dumping " << filename << endl);
    const std::unique_ptr<std::ofstream> treejsonp{V3File::new_ofstream(filename)};
-    if (treejsonp->fail()) v3fatalStatic("Can't write " << filename);
+    if (treejsonp->fail()) v3fatal("Can't write " << filename);
    *treejsonp << '{';
    FileLine::fileNameNumMapDumpJson(*treejsonp);
    *treejsonp << ',';
@@ -1563,7 +1530,8 @@ static VCastable computeCastableImp(const AstNodeDType* toDtp, const AstNodeDTyp
            return VCastable::ENUM_IMPLICIT;
        if (fromNumericable) return VCastable::ENUM_EXPLICIT;
    } else if (VN_IS(toDtp, ClassRefDType) && VN_IS(fromConstp, Const)) {
-        if (fromConstp->isNull()) return VCastable::COMPATIBLE;
+        if (VN_IS(fromConstp, Const) && VN_AS(fromConstp, Const)->num().isNull())
+            return VCastable::COMPATIBLE;
    } else if (VN_IS(toDtp, ClassRefDType) && VN_IS(fromDtp, ClassRefDType)) {
        const auto toClassp = VN_AS(toDtp, ClassRefDType)->classp();
        const auto fromClassp = VN_AS(fromDtp, ClassRefDType)->classp();
@@ -1585,30 +1553,30 @@ VCastable AstNode::computeCastable(const AstNodeDType* toDtp, const AstNodeDType
    const auto castable = computeCastableImp(toDtp, fromDtp, fromConstp);
    UINFO(9, "  castable=" << castable << "  for " << toDtp << endl);
    UINFO(9, "     =?= " << fromDtp << endl);
-    if (fromConstp) UINFO(9, "     const= " << fromConstp << endl);
+    UINFO(9, "     const= " << fromConstp << endl);
    return castable;
 }

-AstNodeDType* AstNode::getCommonClassTypep(AstNode* node1p, AstNode* node2p) {
-    // Return the class type that both node1p and node2p are castable to.
+AstNodeDType* AstNode::getCommonClassTypep(AstNode* nodep1, AstNode* nodep2) {
+    // Return the class type that both nodep1 and nodep2 are castable to.
    // If both are null, return the type of null constant.
    // If one is a class and one is null, return AstClassRefDType that points to that class.
    // If no common class type exists, return nullptr.

    // First handle cases with null values and when one class is a super class of the other.
-    if (VN_IS(node1p, Const)) std::swap(node1p, node2p);
+    if (VN_IS(nodep1, Const)) std::swap(nodep1, nodep2);
    {
-        const VCastable castable = computeCastable(node1p->dtypep(), node2p->dtypep(), node2p);
+        const VCastable castable = computeCastable(nodep1->dtypep(), nodep2->dtypep(), nodep2);
        if (castable == VCastable::SAMEISH || castable == VCastable::COMPATIBLE) {
-            return node1p->dtypep();
+            return nodep1->dtypep();
        } else if (castable == VCastable::DYNAMIC_CLASS) {
-            return node2p->dtypep();
+            return nodep2->dtypep();
        }
    }

-    AstClassRefDType* classDtypep1 = VN_CAST(node1p->dtypep(), ClassRefDType);
+    AstClassRefDType* classDtypep1 = VN_CAST(nodep1->dtypep(), ClassRefDType);
    while (classDtypep1) {
-        const VCastable castable = computeCastable(classDtypep1, node2p->dtypep(), node2p);
+        const VCastable castable = computeCastable(classDtypep1, nodep2->dtypep(), nodep2);
        if (castable == VCastable::COMPATIBLE) return classDtypep1;
        AstClassExtends* const extendsp = classDtypep1->classp()->extendsp();
        classDtypep1 = extendsp ? VN_AS(extendsp->dtypep(), ClassRefDType) : nullptr;
@@ -49,6 +49,9 @@ class VFlagLogicPacked {};
 class VFlagBitPacked {};
 class VFlagChildDType {};  // Used by parser.y to select constructor that sets childDType

+// Used as key for another map, needs operator<, hence not an unordered_set
+using MTaskIdSet = std::set<int>;  // Set of mtaskIds for Var sorting
+
 //######################################################################

 // For broken() function, return error string if have a match
@@ -242,51 +245,6 @@ inline std::ostream& operator<<(std::ostream& os, const VAccess& rhs) { return o

 // ######################################################################

-class VBaseOverride final {
-    bool m_extends : 1;
-    bool m_final : 1;
-    bool m_initial : 1;
-
-public:
-    VBaseOverride()
-        : m_extends{false}
-        , m_final{false}
-        , m_initial{false} {}
-    class Extends {};
-    explicit VBaseOverride(Extends)
-        : m_extends{true}
-        , m_final{false}
-        , m_initial{false} {}
-    class Final {};
-    explicit VBaseOverride(Final)
-        : m_extends{false}
-        , m_final{true}
-        , m_initial{false} {}
-    class Initial {};
-    explicit VBaseOverride(Initial)
-        : m_extends{false}
-        , m_final{false}
-        , m_initial{true} {}
-    void combine(const VBaseOverride& other) {
-        m_extends |= other.m_extends;
-        m_final |= other.m_final;
-        m_initial |= other.m_initial;
-    }
-    bool isAny() const { return m_extends | m_final | m_initial; }
-    bool isExtends() const { return m_extends; }
-    bool isFinal() const { return m_final; }
-    bool isInitial() const { return m_initial; }
-    string ascii() const {
-        string out;
-        if (m_initial) out = VString::dot(out, " ", "initial");
-        if (m_extends) out = VString::dot(out, " ", "extends");
-        if (m_final) out = VString::dot(out, " ", "final");
-        return out;
-    }
-};
-
-// ######################################################################
-
 class VSigning final {
 public:
    enum en : uint8_t {
@@ -330,7 +288,6 @@ public:
        ILLEGAL,
        COVERAGE_BLOCK_OFF,
        HIER_BLOCK,
-        HIER_PARAMS,
        INLINE_MODULE,
        NO_INLINE_MODULE,
        NO_INLINE_TASK,
@@ -366,6 +323,7 @@ public:
    enum en : uint8_t {
        // These must be in general -> most specific order, as we sort by it
        // in V3Const::visit AstSenTree
+        ET_ILLEGAL,
        // Involving a variable
        ET_CHANGED,  // Value changed
        ET_BOTHEDGE,  // POSEDGE | NEGEDGE (i.e.: 'edge' in Verilog)
@@ -385,6 +343,8 @@ public:
    enum en m_e;
    bool clockedStmt() const {
        static const bool clocked[] = {
+            false,  // ET_ILLEGAL
+
            true,  // ET_CHANGED
            true,  // ET_BOTHEDGE
            true,  // ET_POSEDGE
@@ -408,19 +368,20 @@ public:
        case ET_BOTHEDGE: return ET_BOTHEDGE;
        case ET_POSEDGE: return ET_NEGEDGE;
        case ET_NEGEDGE: return ET_POSEDGE;
-        default: UASSERT_STATIC(0, "Inverting bad edgeType()"); return ET_NEGEDGE;
+        default: UASSERT_STATIC(0, "Inverting bad edgeType()");
        }
+        return VEdgeType::ET_ILLEGAL;
    }
    const char* ascii() const {
        static const char* const names[]
-            = {"CHANGED", "BOTH",   "POS",    "NEG",     "EVENT", "TRUE",
-               "COMBO",   "HYBRID", "STATIC", "INITIAL", "FINAL", "NEVER"};
+            = {"%E-edge", "CHANGED", "BOTH",   "POS",     "NEG",   "EVENT", "TRUE",
+               "COMBO",   "HYBRID",  "STATIC", "INITIAL", "FINAL", "NEVER"};
        return names[m_e];
    }
    const char* verilogKwd() const {
        static const char* const names[]
-            = {"[changed]", "edge",     "posedge",  "negedge",   "[event]", "[true]",
-               "*",         "[hybrid]", "[static]", "[initial]", "[final]", "[never]"};
+            = {"%E-edge", "[changed]", "edge",     "posedge",   "negedge", "[event]", "[true]",
+               "*",       "[hybrid]",  "[static]", "[initial]", "[final]", "[never]"};
        return names[m_e];
    }
    // Return true iff this and the other have mutually exclusive transitions
@@ -436,6 +397,8 @@ public:
        }
        return false;
    }
+    VEdgeType()
+        : m_e{ET_ILLEGAL} {}
    // cppcheck-suppress noExplicitConstructor
    constexpr VEdgeType(en _e)
        : m_e{_e} {}
@@ -560,7 +523,6 @@ public:
        DYNAMIC_TRIGGER_SCHEDULER,
        FORK_SYNC,
        PROCESS_REFERENCE,
-        RANDOM_GENERATOR,
        // Unsigned and two state; fundamental types
        UINT32,
        UINT64,
@@ -594,7 +556,6 @@ public:
                                            "VlDynamicTriggerScheduler",
                                            "VlFork",
                                            "VlProcessRef",
-                                            "VlRandomizer",
                                            "IData",
                                            "QData",
                                            "LOGIC_IMPLICIT",
@@ -602,13 +563,20 @@ public:
        return names[m_e];
    }
    const char* dpiType() const {
-        static const char* const names[]
-            = {"%E-unk",       "svBit",           "char",          "void*",        "char",
-               "int",          "%E-integer",      "svLogic",       "long long",    "double",
-               "short",        "%E-time",         "const char*",   "%E-untyped",   "dpiScope",
-               "const char*",  "%E-mtaskstate",   "%E-triggervec", "%E-dly-sched", "%E-trig-sched",
-               "%E-dyn-sched", "%E-fork",         "%E-proc-ref",   "%E-rand-gen",  "IData",
-               "QData",        "%E-logic-implct", " MAX"};
+        static const char* const names[] = {"%E-unk",        "svBit",
+                                            "char",          "void*",
+                                            "char",          "int",
+                                            "%E-integer",    "svLogic",
+                                            "long long",     "double",
+                                            "short",         "%E-time",
+                                            "const char*",   "%E-untyped",
+                                            "dpiScope",      "const char*",
+                                            "%E-mtaskstate", "%E-triggervec",
+                                            "%E-dly-sched",  "%E-trig-sched",
+                                            "%E-dyn-sched",  "%E-fork",
+                                            "%E-proc-ref",   "IData",
+                                            "QData",         "%E-logic-implct",
+                                            " MAX"};
        return names[m_e];
    }
    static void selfTest() {
@@ -648,7 +616,6 @@ public:
        case DYNAMIC_TRIGGER_SCHEDULER: return 0;  // opaque
        case FORK_SYNC: return 0;  // opaque
        case PROCESS_REFERENCE: return 0;  // opaque
-        case RANDOM_GENERATOR: return 0;  // opaque
        case UINT32: return 32;
        case UINT64: return 64;
        default: return 0;
@@ -688,8 +655,7 @@ public:
        return (m_e == EVENT || m_e == STRING || m_e == SCOPEPTR || m_e == CHARPTR
                || m_e == MTASKSTATE || m_e == TRIGGERVEC || m_e == DELAY_SCHEDULER
                || m_e == TRIGGER_SCHEDULER || m_e == DYNAMIC_TRIGGER_SCHEDULER || m_e == FORK_SYNC
-                || m_e == PROCESS_REFERENCE || m_e == RANDOM_GENERATOR || m_e == DOUBLE
-                || m_e == UNTYPED);
+                || m_e == PROCESS_REFERENCE || m_e == DOUBLE || m_e == UNTYPED);
    }
    bool isDouble() const VL_MT_SAFE { return m_e == DOUBLE; }
    bool isEvent() const { return m_e == EVENT; }
@@ -788,7 +754,6 @@ public:
    bool isAny() const { return m_e != NONE; }
    // Looks like inout - "ish" because not identical to being an INOUT
    bool isInoutish() const { return m_e == INOUT; }
-    bool isInput() const { return m_e == INPUT; }
    bool isNonOutput() const {
        return m_e == INPUT || m_e == INOUT || m_e == REF || m_e == CONSTREF;
    }
@@ -902,7 +867,7 @@ public:
        TRIWIRE,
        TRI0,
        TRI1,
-        PORT,  // Used in parser and V3Fork to recognize ports
+        PORT,  // Temp type used in parser only
        BLOCKTEMP,
        MODULETEMP,
        STMTTEMP,
@@ -1101,156 +1066,6 @@ constexpr bool operator==(VAlwaysKwd::en lhs, const VAlwaysKwd& rhs) { return lh

 // ######################################################################

-class VAssertCtlType final {
-public:
-    // IEEE 1800-2023 Table 20-5
-    enum en : uint8_t {
-        _TO_BE_EVALUATED = 0,
-        LOCK = 1,
-        UNLOCK = 2,
-        ON = 3,
-        OFF = 4,
-        KILL = 5,
-        PASS_ON = 6,
-        PASS_OFF = 7,
-        FAIL_ON = 8,
-        FAIL_OFF = 9,
-        NONVACUOUS_ON = 10,
-        VACUOUS_OFF = 11
-    };
-    enum en m_e;
-    VAssertCtlType()
-        : m_e{_TO_BE_EVALUATED} {}
-    // cppcheck-suppress noExplicitConstructor
-    constexpr VAssertCtlType(en _e)
-        : m_e{_e} {}
-    explicit VAssertCtlType(int _e)
-        : m_e(static_cast<en>(_e)) {}  // Need () or GCC 4.8 false warning
-    constexpr operator en() const { return m_e; }
-    const char* ascii() const {
-        // IEEE 1800-2023 20.11
-        static const char* const names[] = {"",
-                                            "",
-                                            "",
-                                            "$asserton",
-                                            "$assertoff",
-                                            "$assertkill",
-                                            "$assertpasson",
-                                            "$assertpassoff",
-                                            "$assertfailon",
-                                            "$assertfailoff",
-                                            "$assertnonvacuouson",
-                                            "$assertvacuousoff"};
-        return names[m_e];
-    }
-};
-constexpr bool operator==(const VAssertCtlType& lhs, const VAssertCtlType& rhs) {
-    return lhs.m_e == rhs.m_e;
-}
-constexpr bool operator==(const VAssertCtlType& lhs, VAssertCtlType::en rhs) {
-    return lhs.m_e == rhs;
-}
-constexpr bool operator==(VAssertCtlType::en lhs, const VAssertCtlType& rhs) {
-    return lhs == rhs.m_e;
-}
-
-// ######################################################################
-
-class VAssertDirectiveType final {
-public:
-    // IEEE 1800-2023 Table 20-7
-    enum en : uint8_t {
-        INTERNAL = 0,  // Non IEEE type, for directives to be evaluated from expression.
-        ASSERT = (1 << 0),
-        COVER = (1 << 1),
-        ASSUME = (1 << 2),
-        VIOLATION_CASE = (1 << 3),  // Non IEEE type, for case constructs
-                                    // with unique, unique0 or priority pragmas.
-        VIOLATION_IF = (1 << 4),  // Non IEEE type, for if constructs
-                                  // with unique, unique0 or priority pragmas.
-        INTRINSIC = (1 << 5),  // Non IEEE type, for intrinsic assertions.
-        RESTRICT = (1 << 6),  // Non IEEE type, for ignored restrict assertions.
-    };
-    enum en m_e;
-    VAssertDirectiveType()
-        : m_e{ASSERT} {}
-    // cppcheck-suppress noExplicitConstructor
-    constexpr VAssertDirectiveType(en _e)
-        : m_e{_e} {}
-    explicit VAssertDirectiveType(int _e)
-        : m_e(static_cast<en>(_e)) {}  // Need () or GCC 4.8 false warning
-    const char* ascii() const {
-        static const char* const names[]
-            = {"INTERNAL",       "ASSERT",       "COVER",     "ASSUME",
-               "VIOLATION_CASE", "VIOLATION_IF", "INTRINSIC", "RESTRICT"};
-        return names[m_e];
-    }
-    constexpr operator en() const { return m_e; }
-};
-constexpr bool operator==(const VAssertDirectiveType& lhs, const VAssertDirectiveType& rhs) {
-    return lhs.m_e == rhs.m_e;
-}
-constexpr bool operator==(const VAssertDirectiveType& lhs, VAssertDirectiveType::en rhs) {
-    return lhs.m_e == rhs;
-}
-constexpr bool operator==(VAssertDirectiveType::en lhs, const VAssertDirectiveType& rhs) {
-    return lhs == rhs.m_e;
-}
-constexpr VAssertDirectiveType::en operator|(VAssertDirectiveType::en lhs,
-                                             VAssertDirectiveType::en rhs) {
-    return VAssertDirectiveType::en(static_cast<uint8_t>(lhs) | static_cast<uint8_t>(rhs));
-}
-
-// ######################################################################
-
-class VAssertType final {
-public:
-    // IEEE 1800-2023 Table 20-6
-    enum en : uint8_t {
-        INTERNAL = 0,  // Non IEEE type, for assertions that should not be controlled.
-        CONCURRENT = (1 << 0),
-        SIMPLE_IMMEDIATE = (1 << 1),
-        OBSERVED_DEFERRED_IMMEDIATE = (1 << 2),
-        FINAL_DEFERRED_IMMEDIATE = (1 << 3),
-        EXPECT = (1 << 4),
-        UNIQUE = (1 << 5),
-        UNIQUE0 = (1 << 6),
-        PRIORITY = (1 << 7),
-    };
-    enum en m_e;
-    VAssertType()
-        : m_e{INTERNAL} {}
-    // cppcheck-suppress noExplicitConstructor
-    constexpr VAssertType(en _e)
-        : m_e{_e} {}
-    explicit VAssertType(int _e)
-        : m_e(static_cast<en>(_e)) {}  // Need () or GCC 4.8 false warning
-    bool containsAny(VAssertType other) const { return m_e & other.m_e; }
-    const char* ascii() const {
-        static const char* const names[] = {"INTERNAL",
-                                            "CONCURRENT",
-                                            "SIMPLE_IMMEDIATE",
-                                            "OBSERVED_DEFERRED_IMMEDIATE",
-                                            "FINAL_DEFERRED_IMMEDIATE",
-                                            "EXPECT",
-                                            "UNIQUE",
-                                            "UNIQUE0",
-                                            "PRIORITY"};
-        return names[m_e];
-    }
-    constexpr operator en() const { return m_e; }
-};
-constexpr bool operator==(const VAssertType& lhs, const VAssertType& rhs) {
-    return lhs.m_e == rhs.m_e;
-}
-constexpr bool operator==(const VAssertType& lhs, VAssertType::en rhs) { return lhs.m_e == rhs; }
-constexpr bool operator==(VAssertType::en lhs, const VAssertType& rhs) { return lhs == rhs.m_e; }
-constexpr VAssertType::en operator|(VAssertType::en lhs, VAssertType::en rhs) {
-    return VAssertType::en(static_cast<uint8_t>(lhs) | static_cast<uint8_t>(rhs));
-}
-
-// ######################################################################
-
 class VCaseType final {
 public:
    enum en : uint8_t { CT_CASE, CT_CASEX, CT_CASEZ, CT_CASEINSIDE };
@@ -1590,7 +1405,6 @@ public:
               "ENUM_IMPLICIT", "DYNAMIC_CLASS", "INCOMPATIBLE"};
        return names[m_e];
    }
-    bool isAssignable() const { return m_e != UNSUPPORTED && m_e != INCOMPATIBLE; }
    VCastable()
        : m_e{UNSUPPORTED} {}
    // cppcheck-suppress noExplicitConstructor
@@ -1682,36 +1496,6 @@ public:
    bool operator==(const VSelfPointerText& other) const { return *m_strp == *other.m_strp; }
 };

-// ######################################################################
-// Defines what kind of randomization is done on a variable
-
-class VRandAttr final {
-public:
-    enum en : uint8_t {
-        NONE,  // Not randomizable
-        RAND,  // Has a rand modifier
-        RAND_CYCLIC,  // Has a randc modifier
-        RAND_INLINE  // Not rand/randc, but used in inline random variable control
-    };
-    enum en m_e;
-    const char* ascii() const {
-        static const char* const names[] = {"NONE", "RAND", "RANDC", "RAND-INLINE"};
-        return names[m_e];
-    }
-    VRandAttr()
-        : m_e{NONE} {}
-    // cppcheck-suppress noExplicitConstructor
-    constexpr VRandAttr(en _e)
-        : m_e{_e} {}
-    constexpr operator en() const { return m_e; }
-    bool isRandomizable() const { return m_e != NONE; }
-    bool isRand() const { return m_e == RAND || m_e == RAND_CYCLIC; }
-    bool isRandC() const { return m_e == RAND_CYCLIC; }
-};
-inline std::ostream& operator<<(std::ostream& os, const VRandAttr& rhs) {
-    return os << rhs.ascii();
-}
-
 //######################################################################
 // AstNUser - Generic base class for AST User nodes.
 //          - Also used to allow parameter passing up/down iterate calls
@@ -2204,8 +1988,8 @@ public:
    void fileline(FileLine* fl) { m_fileline = fl; }
    inline bool width1() const;
    inline int widthInstrs() const;
-    bool didWidth() const { return m_flags.didWidth; }
    void didWidth(bool flag) { m_flags.didWidth = flag; }
+    bool didWidth() const { return m_flags.didWidth; }
    bool didWidthAndSet() {
        if (didWidth()) return true;
        didWidth(true);
@@ -2218,7 +2002,7 @@ public:

    // TODO stomp these width functions out, and call via dtypep() instead
    inline int width() const VL_MT_STABLE;
-    inline int widthMin() const VL_MT_STABLE;
+    inline int widthMin() const;
    int widthMinV() const {
        return v3Global.widthMinUsage() == VWidthMinUsage::VERILOG_WIDTH ? widthMin() : width();
    }
@@ -2304,7 +2088,6 @@ public:
    // ACCESSORS for specific types
    // Alas these can't be virtual or they break when passed a nullptr
    inline bool isClassHandleValue() const;
-    inline bool isNull() const;
    inline bool isZero() const;
    inline bool isOne() const;
    inline bool isNeqZero() const;
@@ -2383,9 +2166,6 @@ public:
    string warnOther() const VL_REQUIRES(V3Error::s().m_mutex) { return fileline()->warnOther(); }

    virtual void dump(std::ostream& str = std::cout) const;
-    static char* dumpTreeJsonGdb(const AstNode* nodep);  // For GDB only, free()d by caller
-    static char* dumpTreeJsonGdb(const char* str);  // For GDB only, free()d by caller
-    static char* dumpTreeJsonGdb(intptr_t nodep);  // For GDB only, free()d by caller
    static void dumpGdb(const AstNode* nodep);  // For GDB only
    void dumpGdbHeader() const;

@@ -2436,7 +2216,7 @@ public:
    static void dumpTreeGdb(const AstNode* nodep);  // For GDB only
    void dumpTreeAndNext(std::ostream& os = std::cout, const string& indent = "    ",
                         int maxDepth = 0) const;
-    void dumpTreeFile(const string& filename, bool doDump = true);
+    void dumpTreeFile(const string& filename, bool doDump = true, bool doCheck = true);
    static void dumpTreeFileGdb(const AstNode* nodep, const char* filenamep = nullptr);
    void dumpTreeDot(std::ostream& os = std::cout) const;
    void dumpTreeDotFile(const string& filename, bool doDump = true);
@@ -2447,8 +2227,7 @@ public:
    virtual void dumpTreeJsonOpGen(std::ostream& os, const string& indent) const {};
    void dumpTreeJson(std::ostream& os, const string& indent = "") const;
    void dumpTreeJsonFile(const string& filename, bool doDump = true);
-    static void dumpJsonMetaFileGdb(const char* filename);
-    static void dumpJsonMetaFile(const string& filename);
+    void dumpJsonMetaFile(const string& filename);

    // Render node address for dumps. By default this is just the address
    // printed as hex, but with --dump-tree-addrids we map addresses to short
@@ -2535,7 +2314,7 @@ protected:
    static void dumpJsonStr(std::ostream& os, const std::string& name, const std::string& val);
    static void dumpJsonPtr(std::ostream& os, const std::string& name, const AstNode* const valp);

-protected:
+private:
    void iterateListBackwardsConst(VNVisitorConst& v);

    // For internal use only.
@@ -2653,6 +2432,14 @@ private:
    template <typename T_Arg, bool Default, typename Callable>
    inline static bool predicateImpl(ConstCorrectAstNode<T_Arg>* nodep, const Callable& p);

+    template <typename T_Callable>
+    struct Arg0NoPointerNoCV final {
+        using Traits = FunctionTraits<T_Callable>;
+        using T_Arg0 = typename Traits::template arg<0>::type;
+        using T_Arg0NoPtr = typename std::remove_pointer<T_Arg0>::type;
+        using type = typename std::remove_cv<T_Arg0NoPtr>::type;
+    };
+
 public:
    // Given a callable 'f' that takes a single argument of some AstNode subtype 'T_Node', traverse
    // the tree rooted at this node, and call 'f' in pre-order on each node that is of type
@@ -2663,7 +2450,7 @@ public:
    // caches in modern CPUs, while it is basically unpredictable for VNVisitor.
    template <typename Callable>
    void foreach(Callable&& f) {
-        using T_Node = typename FunctionArgNoPointerNoCV<Callable, 0>::type;
+        using T_Node = typename Arg0NoPointerNoCV<Callable>::type;
        static_assert(vlstd::is_invocable<Callable, T_Node*>::value
                          && std::is_base_of<AstNode, T_Node>::value,
                      "Callable 'f' must have a signature compatible with 'void(T_Node*)', "
@@ -2674,7 +2461,7 @@ public:
    // Same as above, but for 'const' nodes
    template <typename Callable>
    void foreach(Callable&& f) const {
-        using T_Node = typename FunctionArgNoPointerNoCV<Callable, 0>::type;
+        using T_Node = typename Arg0NoPointerNoCV<Callable>::type;
        static_assert(vlstd::is_invocable<Callable, const T_Node*>::value
                          && std::is_base_of<AstNode, T_Node>::value,
                      "Callable 'f' must have a signature compatible with 'void(const T_Node*)', "
@@ -2685,7 +2472,7 @@ public:
    // Same as 'foreach' but also traverses 'this->nextp()' transitively
    template <typename Callable>
    void foreachAndNext(Callable&& f) {
-        using T_Node = typename FunctionArgNoPointerNoCV<Callable, 0>::type;
+        using T_Node = typename Arg0NoPointerNoCV<Callable>::type;
        static_assert(vlstd::is_invocable<Callable, T_Node*>::value
                          && std::is_base_of<AstNode, T_Node>::value,
                      "Callable 'f' must have a signature compatible with 'void(T_Node*)', "
@@ -2696,7 +2483,7 @@ public:
    // Same as above, but for 'const' nodes
    template <typename Callable>
    void foreachAndNext(Callable&& f) const {
-        using T_Node = typename FunctionArgNoPointerNoCV<Callable, 0>::type;
+        using T_Node = typename Arg0NoPointerNoCV<Callable>::type;
        static_assert(vlstd::is_invocable<Callable, const T_Node*>::value
                          && std::is_base_of<AstNode, T_Node>::value,
                      "Callable 'f' must have a signature compatible with 'void(const T_Node*)', "
@@ -2711,7 +2498,7 @@ public:
    // be determined.
    template <typename Callable>
    bool exists(Callable&& p) {
-        using T_Node = typename FunctionArgNoPointerNoCV<Callable, 0>::type;
+        using T_Node = typename Arg0NoPointerNoCV<Callable>::type;
        static_assert(vlstd::is_invocable_r<bool, Callable, T_Node*>::value
                          && std::is_base_of<AstNode, T_Node>::value,
                      "Predicate 'p' must have a signature compatible with 'bool(T_Node*)', "
@@ -2722,7 +2509,7 @@ public:
    // Same as above, but for 'const' nodes
    template <typename Callable>
    bool exists(Callable&& p) const {
-        using T_Node = typename FunctionArgNoPointerNoCV<Callable, 0>::type;
+        using T_Node = typename Arg0NoPointerNoCV<Callable>::type;
        static_assert(vlstd::is_invocable_r<bool, Callable, const T_Node*>::value
                          && std::is_base_of<AstNode, T_Node>::value,
                      "Predicate 'p' must have a signature compatible with 'bool(const T_Node*)', "
@@ -2736,7 +2523,7 @@ public:
    // in some arbitrary order and is terminated as soon as the result can be determined.
    template <typename Callable>
    bool forall(Callable&& p) {
-        using T_Node = typename FunctionArgNoPointerNoCV<Callable, 0>::type;
+        using T_Node = typename Arg0NoPointerNoCV<Callable>::type;
        static_assert(vlstd::is_invocable_r<bool, Callable, T_Node*>::value
                          && std::is_base_of<AstNode, T_Node>::value,
                      "Predicate 'p' must have a signature compatible with 'bool(T_Node*)', "
@@ -2747,7 +2534,7 @@ public:
    // Same as above, but for 'const' nodes
    template <typename Callable>
    bool forall(Callable&& p) const {
-        using T_Node = typename FunctionArgNoPointerNoCV<Callable, 0>::type;
+        using T_Node = typename Arg0NoPointerNoCV<Callable>::type;
        static_assert(vlstd::is_invocable_r<bool, Callable, const T_Node*>::value
                          && std::is_base_of<AstNode, T_Node>::value,
                      "Predicate 'p' must have a signature compatible with 'bool(const T_Node*)', "
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Wilson Snyder	2b4852048d	Commentary - update version date	2024-02-25 07:20:30 -05:00
Wilson Snyder	0144e3ebec	Merge from master for release.	2024-02-24 07:48:43 -05:00
Wilson Snyder	d410e551f8	Merge from master for release.	2024-01-01 03:45:16 -05:00
Wilson Snyder	344f87abe3	Merge from master for release.	2023-10-31 19:51:59 -04:00
Wilson Snyder	57c816f906	Merge from master for release. (update)	2023-09-16 21:44:39 -04:00
Wilson Snyder	82e1dbe162	Merge from master for release.	2023-09-16 20:43:53 -04:00
Wilson Snyder	e6b0bdd4df	Merge from master for release.	2023-08-06 14:17:13 -04:00
Wilson Snyder	4f13c4d1bb	Merge from master for release.	2023-06-13 19:37:22 -04:00
Wilson Snyder	c37ec19751	Merge from master for release.	2023-04-30 07:09:22 -04:00
Wilson Snyder	aaaf8e75af	Merge from master for release.	2023-03-04 11:29:11 -05:00
Wilson Snyder	8cc31c6cf1	Merge from master for release.	2023-01-22 11:52:52 -05:00
Wilson Snyder	8468af1a20	Merge from master for release.	2022-12-14 22:07:37 -05:00
Wilson Snyder	db39d70c75	Merge from master for release.	2022-10-29 17:52:23 -04:00
Wilson Snyder	04fff7ebd8	Merge from master for release.	2022-10-01 08:33:50 -04:00
Wilson Snyder	b154af87a1	Merge from master for release.	2022-08-31 19:47:07 -04:00
Wilson Snyder	8b7480806a	Merge from master for release.	2022-06-19 15:11:19 -04:00
Wilson Snyder	e29f5ad559	Merge from master for release.	2022-06-19 15:08:17 -04:00
Wilson Snyder	4618fd5a43	Merge from master for release.	2022-05-02 22:22:20 -04:00
Wilson Snyder	ed979c6aa1	Merge from master for release.	2022-03-12 13:14:48 -05:00
Wilson Snyder	141c5da3f9	Merge from master for release.	2021-12-05 11:15:32 -05:00
Wilson Snyder	0185ee5df3	Merge from master for release.	2021-10-17 14:46:03 -04:00
Wilson Snyder	27c08a65e1	Merge from master for release.	2021-09-01 21:02:51 -04:00
Wilson Snyder	de408a5eb7	Merge from master for release.	2021-07-07 20:48:51 -04:00
Wilson Snyder	fa3c072dd1	Merge from master for release.	2021-06-12 13:01:37 -04:00
Wilson Snyder	aac4b7090a	Merge from master for release.	2021-04-24 10:40:13 -04:00
Wilson Snyder	f0d664530d	Merge from master for release.	2021-03-12 15:48:45 -05:00
Wilson Snyder	702140bf93	Merge from master for release.	2021-02-25 21:49:42 -05:00
Wilson Snyder	2075db3db0	Merge from master for release.	2021-01-10 13:35:45 -05:00
Wilson Snyder	b7fec513cf	Merge from master for release.	2020-12-02 20:13:31 -05:00
Wilson Snyder	78e7758022	Merge from master for release.	2020-11-14 09:58:28 -05:00
Wilson Snyder	818318ddd5	Merge from master for release.	2020-10-15 08:25:44 -04:00
Wilson Snyder	39eea781bc	Merge from master for release.	2020-09-07 09:38:50 -04:00
Wilson Snyder	c4f7bd6a04	'Merge from master for release.'	2020-08-15 09:18:29 -04:00
Wilson Snyder	dd03d0f3c9	'Merge from master for release.'	2020-07-11 09:16:56 -04:00
Wilson Snyder	369ce6af2c	'Merge from master for release.'	2020-06-06 07:49:57 -04:00
Wilson Snyder	f83817510d	'Merge from master for release.'	2020-05-03 11:15:21 -04:00
Wilson Snyder	bfcd779cfb	'Merge from master for release.'	2020-04-04 08:50:02 -04:00
Wilson Snyder	e69c380205	'Merge from master for release.'	2020-03-08 08:39:29 -04:00
Wilson Snyder	61e14aa827	'Merge from master for release.'	2020-02-08 09:15:27 -05:00
Wilson Snyder	0c6c83e278	Merge from master for release.	2020-01-11 07:12:09 -05:00
Wilson Snyder	6f52208b68	Fix clang warning.	2019-12-09 18:28:56 -05:00