diff --git a/.github/workflows/rust-ci.yml b/.github/workflows/rust-ci.yml
index f9a6d5bd5..29e500370 100644
--- a/.github/workflows/rust-ci.yml
+++ b/.github/workflows/rust-ci.yml
@@ -3,7 +3,9 @@ name: Rust CI
 on:
   push:
     branches:
-      - '**'
+      - master
+      - main
+      - llvm18
   pull_request:
     branches:
       - '**'
@@ -26,6 +28,7 @@ jobs:
     - name: Setup sccache
       if: github.event_name != 'release' && github.event_name != 'workflow_dispatch'
       uses: mozilla-actions/sccache-action@v0.0.9
+
     - name: Configure sccache
       if: github.event_name != 'release' && github.event_name != 'workflow_dispatch'
       run: |
@@ -33,10 +36,13 @@ jobs:
         echo "RUSTC_WRAPPER=sccache" >> $GITHUB_ENV
 
     - uses: actions/checkout@v4
+
     - name: Install Rust toolchain
       uses: dtolnay/rust-toolchain@stable
+
     - name: Install cargo-machete
       run: cargo install cargo-machete
+
     - name: Run cargo machete
       run: cargo machete
 
@@ -45,19 +51,37 @@ jobs:
     needs: [format, machete]
     steps:
     - uses: actions/checkout@v4
+
     - name: Install Rust toolchain
       uses: dtolnay/rust-toolchain@stable
       with:
         components: clippy
         targets: x86_64-pc-windows-gnu
+
     - name: Setup sccache
       if: github.event_name != 'release' && github.event_name != 'workflow_dispatch'
       uses: mozilla-actions/sccache-action@v0.0.9
+
     - name: Configure sccache
       if: github.event_name != 'release' && github.event_name != 'workflow_dispatch'
       run: |
         echo "SCCACHE_GHA_ENABLED=true" >> $GITHUB_ENV
         echo "RUSTC_WRAPPER=sccache" >> $GITHUB_ENV
+
+    - name: "Cache cargo"
+      id: cache-cargo
+      uses: "actions/cache@v4"
+      with:
+        path: |
+          ~/.cargo/bin/
+          ~/.cargo/registry/index/
+          ~/.cargo/registry/cache/
+          ~/.cargo/git/db/
+          target/
+        save-always: true
+        key: ${{ runner.os }}-${{runner.arch}}-cargo-${{ hashFiles('**/Cargo.lock') }}
+        restore-keys: ${{ runner.os }}-${{runner.arch}}-cargo-
+
     - name: Install LLVM 18 and Windows cross-compilation tools
       run: |
         wget https://apt.llvm.org/llvm.sh
@@ -74,18 +98,22 @@ jobs:
         # Verify installation
         which llvm-lib
         llvm-lib --version
+
     - name: Set LLVM environment variables
       run: |
         echo "LLVM_SYS_181_PREFIX=/usr/lib/llvm-18" >> $GITHUB_ENV
         echo "CLANG_PATH=/usr/lib/llvm-18/bin/clang" >> $GITHUB_ENV
         echo "PATH=/usr/lib/llvm-18/bin:$PATH" >> $GITHUB_ENV
         echo "RUST_BACKTRACE=1" >> $GITHUB_ENV
+
     - name: Install build dependencies
       run: |
         sudo apt-get update
         sudo apt-get install -y build-essential
+
     - name: Build
       run: cargo build --release
+
     - name: Show sccache stats
       if: github.event_name != 'release' && github.event_name != 'workflow_dispatch'
       shell: bash
@@ -93,9 +121,13 @@ jobs:
     # someone has to fix the errors
     # - name: Run Clippy
     #   run: cargo clippy -- -D warnings
+
     - name: Run tests
       run: cargo test --release
 
+    - name: Run integration tests
+      run: cargo test --release --test integration
+
   msys2-build-test:
     strategy:
       fail-fast: false
@@ -129,19 +161,36 @@ jobs:
         mkdir -p .cargo
         echo '[net]' > .cargo/config.toml
         echo 'git-fetch-with-cli = true' >> .cargo/config.toml
+
     - name: Cache sccache
-      uses: actions/cache@v3
+      uses: actions/cache@v4
       with:
         path: ~/.cache/sccache
-        key: ${{ runner.os }}-sccache-${{ hashFiles('**/Cargo.lock') }}
+        key: ${{ runner.os }}-${{runner.arch}}-sccache-${{ hashFiles('**/Cargo.lock') }}
         restore-keys: |
-          ${{ runner.os }}-sccache-
+          ${{ runner.os }}-${{runner.arch}}-sccache-
+
     - name: Locate and configure sccache
       shell: msys2 {0}
       run: |
         # export SCCACHE_PATH=$(which sccache)
         # echo "SCCACHE_GHA_ENABLED=true" >> $GITHUB_ENV
         echo "RUSTC_WRAPPER=${SCCACHE_PATH}" >> $GITHUB_ENV
+
+    - name: "Cache cargo"
+      id: cache-cargo
+      uses: "actions/cache@v4"
+      with:
+        path: |
+          ~/.cargo/bin/
+          ~/.cargo/registry/index/
+          ~/.cargo/registry/cache/
+          ~/.cargo/git/db/
+          target/
+        save-always: true
+        key: ${{ runner.os }}-${{runner.arch}}-cargo-${{ hashFiles('**/Cargo.lock') }}
+        restore-keys: ${{ runner.os }}-${{runner.arch}}-cargo-
+
     - name: Run cargo
       shell: msys2 {0}
       run: cargo build --release
@@ -149,6 +198,7 @@ jobs:
     #  if: github.event_name != 'release' && github.event_name != 'workflow_dispatch'
     #  shell: msys2 {0}
     #  run: $SCCACHE_PATH --show-stats
+
     - name: Run tests
       shell: msys2 {0}
       run: cargo test --release
@@ -158,28 +208,56 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - arch: arm64
-            macos: 13
-          - arch: x86_64
-            macos: 13
-    runs-on: macos-${{ matrix.macos }}
+          # Intel
+          - image: macos-15-intel
+          # ARM64
+          - image: macos-15
+          - image: macos-14
+
+    runs-on: ${{ matrix.image }}
+    needs: [format, machete]
     steps:
     - name: Checkout
       uses: actions/checkout@v4
 
-    - name: Install pkg-config with Homebrew
+    - name: Install dependencies with Homebrew
+      uses: tecolicom/actions-use-homebrew-tools@v1
+      with:
+        tools: pkg-config sccache llvm@18
+        cache: yes
+
+    - name: Set LLVM environment variables
       run: |
-        brew install pkg-config mingw-w64 sccache llvm
-        echo "$(brew --prefix llvm)/bin" >> $GITHUB_PATH
+        echo "$(brew --prefix llvm@18)/bin" >> $GITHUB_PATH
+        echo "LLVM_SYS_181_PREFIX=$(brew --prefix llvm@18)" >> $GITHUB_ENV
+        echo "RUST_BACKTRACE=1" >> $GITHUB_ENV
+        echo "RUN_DEV_TESTS=1" >> $GITHUB_ENV
+
     - name: sccache setup
       run: |
         # echo "SCCACHE_GHA_ENABLED=true" >> $GITHUB_ENV
         echo "RUSTC_WRAPPER=$(which sccache)" >> $GITHUB_ENV
-    
 
+    - name: "Cache cargo"
+      id: cache-cargo
+      uses: "actions/cache@v4"
+      with:
+        path: |
+          ~/.cargo/bin/
+          ~/.cargo/registry/index/
+          ~/.cargo/registry/cache/
+          ~/.cargo/git/db/
+          target/
+        save-always: true
+        key: ${{ runner.os }}-${{runner.arch}}-cargo-${{ hashFiles('**/Cargo.lock') }}
+        restore-keys: ${{ runner.os }}-${{runner.arch}}}-cargo-
+    
     - name: Build
       run: cargo build --release
 
     - name: Run tests
       run: cargo test --release
 
+    - name: Run integration tests
+      run: cargo test --release --test integration
+
diff --git a/ARCH_SPECIFIC_VALUES.md b/ARCH_SPECIFIC_VALUES.md
new file mode 100644
index 000000000..12b84a7b2
--- /dev/null
+++ b/ARCH_SPECIFIC_VALUES.md
@@ -0,0 +1,174 @@
+# Architecture-Specific Values in OSDI Snapshots
+
+## Problem
+
+Multiple values in the OSDI descriptor snapshots are architecture-dependent because they represent memory offsets and sizes calculated by LLVM using platform-specific ABI rules.
+
+## Architecture-Dependent Values
+
+### 1. `instance size` ✓ CONFIRMED
+**Line**: `instance size 1864`
+
+**Source**: `openvaf/osdi/src/metadata.rs:376`
+```rust
+let instance_size =
+    LLVMABISizeOfType(*target_data, NonNull::from(inst_data.ty).as_ptr()) as u32;
+```
+
+**Why**: LLVM calculates struct size including padding based on platform ABI alignment rules.
+
+**Example differences**:
+- BSIM3: 4512 (x86-64) vs 4568 (ARM64) = +56 bytes
+- amplifier: 224 (x86-64) vs 240 (ARM64) = +16 bytes
+
+---
+
+### 2. `residual` offset values ✓ CONFIRMED
+**Line**: `residual 256 264 4294967295 4294967295`
+
+The four numbers are:
+1. resist_residual_off
+2. react_residual_off
+3. resist_limit_rhs_off
+4. react_limit_rhs_off
+
+**Source**: `openvaf/osdi/src/inst_data.rs:472-489`
+```rust
+pub fn residual_off(..., target_data: &LLVMTargetDataRef) -> Option<u32> {
+    let off = unsafe {
+        LLVMOffsetOfElement(*target_data, NonNull::from(self.ty).as_ptr(), elem)
+    } as u32;
+    Some(off)
+}
+```
+
+**Why**: Offsets into the instance data struct depend on field alignment.
+
+**Example differences** (diode.va):
+- Node A resist: 248 (old) → 256 (new)
+- Node A react: 256 (old) → 264 (new)
+
+---
+
+### 3. `react_ptr` values ✓ CONFIRMED
+**Line**: `jacobian (A, A) JacobianFlags(...) react_ptr = 120`
+
+**Source**: `openvaf/osdi/src/metadata.rs:265-267`
+```rust
+let mut jacobian_ptr_react_offset = unsafe {
+    LLVMOffsetOfElement(*target_data, NonNull::from(inst_data.ty).as_ptr(), JACOBIAN_PTR_REACT)
+} as u32;
+```
+
+**Why**: Offset to the reactive jacobian pointer array in the instance struct.
+
+**Note**: Often `4294967295` (u32::MAX) meaning "not present", but when present, the value is arch-specific.
+
+---
+
+### 4. `model size` ⚠️ TO VERIFY
+**Line**: `model size 120`
+
+**Source**: `openvaf/osdi/src/metadata.rs:378`
+```rust
+let model_size =
+    LLVMABISizeOfType(*target_data, NonNull::from(model_data.ty).as_ptr()) as u32;
+```
+
+**Status**: Similar to instance_size, this is likely arch-specific. Need to verify if it changes.
+
+---
+
+## Non-Architecture-Specific Values
+
+These values **should be** the same across platforms:
+
+- Parameter names, types, descriptions
+- Node names, units, is_flow flags
+- Number of terminals, parameters, states
+- Jacobian flags (which entries are const, have react, etc.)
+- Nature and discipline information
+- runits strings (units of flow/potential)
+
+## Solutions
+
+### Option 1: Remove All Arch-Specific Values from Snapshots ✅ RECOMMENDED
+
+**Implementation**:
+1. Comment out or skip these in Debug formatter:
+   - `instance size`
+   - `model size`
+   - `residual` offset numbers (but keep the field itself as marker)
+   - `react_ptr` values (but keep the field)
+
+2. Replace with markers:
+   ```
+   node "A" units = "V", runits = "A"
+   residual <arch-specific offsets>
+   jacobian (A, A) JacobianFlags(...) react_ptr = <arch-specific>
+   instance size <arch-specific>
+   model size <arch-specific>
+   ```
+
+**Pros**:
+- Clean, platform-agnostic snapshots
+- Still test the important structural information
+- Easy to maintain
+
+**Cons**:
+- Lose some regression detection for layout changes
+- Can't detect if offsets become corrupted
+
+---
+
+### Option 2: Test Field Count/Types Instead of Offsets
+
+Instead of testing exact offsets, verify:
+- Number of fields is correct
+- Field types are correct
+- Field order is correct
+
+This would require a different test approach entirely.
+
+---
+
+### Option 3: Normalize to Field Index
+
+Instead of printing byte offsets, print field indices:
+```
+residual field=12 field=13 field=MAX field=MAX
+```
+
+This would be arch-independent but still verify structure.
+
+**Pros**:
+- Still verifies layout without being arch-specific
+- Detects field ordering changes
+
+**Cons**:
+- Requires code changes to track field indices
+- Less directly readable
+
+---
+
+## Recommended Action
+
+**Go with Option 1**: Remove arch-specific numeric values from snapshots.
+
+Modified output would look like:
+```
+node "A" units = "V", runits = "A"
+residual
+jacobian (A, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+...
+0 states
+has bound_step false
+```
+
+We remove:
+- The four residual offset numbers
+- The `react_ptr = XXX` values
+- The `instance size XXX` line
+- The `model size XXX` line
+
+This preserves all the semantically important information while being platform-independent.
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 000000000..ab99298bc
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,177 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+OpenVAF-reloaded is a Verilog-A compiler written in Rust that outputs dynamic libraries compatible with the OSDI API (currently version 0.4). The compiler transforms Verilog-A compact device models into optimized native code for circuit simulators like ngspice, SPICE OPUS, and VACASK.
+
+The project is a fork of Pascal Kuthe's original OpenVAF compiler, maintained by Árpád Bűrmen since 2024, with LLVM 18 support contributed by Kreijstal.
+
+## Build Commands
+
+### Prerequisites
+- **Rust toolchain**: Install with profile "complete"
+- **LLVM 18.1.8**: Must be built from source
+- **Environment variable**: Set `LLVM_SYS_181_PREFIX` to LLVM installation directory
+
+### Building the Compiler
+```bash
+# Build release version (recommended)
+cargo build --release --bin openvaf-r
+
+# Build debug version
+cargo build --bin openvaf-r
+
+# The binaries are output to:
+# - target/release/openvaf-r (release)
+# - target/debug/openvaf-r (debug)
+```
+
+### Testing
+```bash
+# Run fast tests only (default)
+cargo test
+cargo test --release  # On release build
+
+# Run all tests including slow ones
+RUN_SLOW_TESTS=1 cargo test
+
+# Update test snapshots (when you've intentionally changed MIR/IR generation)
+UPDATE_EXPECT=1 cargo test
+```
+
+**Note**: Some expected test results are in `.snap` files in `openvaf/test_data/`, while others are hard-coded in test source files (e.g., `openvaf/mir_autodiff/src/builder/tests.rs`) and must be updated manually.
+
+### Python Bindings
+```bash
+# Build verilogae Python package
+cargo xtask verilogae build
+
+# Run verilogae tests
+cargo xtask verilogae test
+
+# Publish verilogae (with platform flags)
+cargo xtask verilogae publish --windows
+```
+
+## Architecture
+
+### Compilation Pipeline
+
+The compiler follows a multi-stage pipeline similar to rustc:
+
+1. **Lexing & Parsing** (`openvaf/lexer`, `openvaf/parser`)
+   - Tokenizes Verilog-A source files
+   - Builds concrete syntax trees using the `rowan` library
+
+2. **Preprocessing** (`openvaf/preprocessor`)
+   - Handles `include directives and macro expansion
+   - Controlled by macro flags passed via CLI
+
+3. **HIR (High-Level Intermediate Representation)** (`openvaf/hir_def`, `openvaf/hir`, `openvaf/hir_lower`, `openvaf/hir_ty`)
+   - `hir_def`: Desugars syntax into HIR definitions
+   - `hir_ty`: Type inference and checking
+   - `hir_lower`: Lowers HIR to MIR
+
+4. **MIR (Mid-Level Intermediate Representation)** (`openvaf/mir`, `openvaf/mir_build`, `openvaf/mir_opt`, `openvaf/mir_autodiff`)
+   - `mir_build`: Constructs MIR from HIR
+   - `mir_autodiff`: Automatic differentiation for Jacobian computation
+   - `mir_opt`: MIR-level optimizations
+   - `mir_reader`: Utilities for reading/debugging MIR
+
+5. **Code Generation** (`openvaf/mir_llvm`, `openvaf/linker`)
+   - `mir_llvm`: LLVM IR generation from MIR
+   - `linker`: Links generated code into `.osdi` dynamic libraries
+
+6. **OSDI Interface** (`openvaf/osdi`)
+   - Defines the OSDI 0.4 API structures
+   - Header files in `openvaf/osdi/header/`
+   - Handles module descriptors, parameters, Jacobian entries
+
+### Database Architecture
+
+Uses `salsa` for incremental compilation:
+- **BaseDB** (`openvaf/basedb`): File system, VFS, parsing, linting
+- **CompilationDB** (`openvaf/hir`): Extends BaseDB with semantic analysis
+
+### Key Components
+
+- **VFS** (`openvaf/vfs`): Virtual file system for source management
+- **Syntax** (`openvaf/syntax`): Rowan-based CST with source mapping
+- **Target** (`openvaf/target`): Platform-specific codegen configurations
+- **Sim Backend** (`openvaf/sim_back`): Simulation-specific transformations
+- **Supporting Libraries** (`lib/`):
+  - `arena`: Arena allocator for HIR/MIR nodes
+  - `bforest`: B-tree forest data structure
+  - `typed_indexmap`: Type-safe indexed collections
+  - `stdx`: Standard library extensions
+  - `paths`: Path handling utilities
+
+### Python/FFI Bindings
+
+- **verilogae** (`verilogae/`): Python package exposing OpenVAF functionality
+  - `verilogae_ffi`: C/C++ FFI layer (cbindgen/cppbindgen)
+  - `verilogae_py`: PyO3-based Python bindings
+
+## Development Workflow
+
+### Debugging in VS Code
+- Copy `.vscode/launch-openvaf-r.json` to `.vscode/launch.json`
+- Two configurations available: Linux (CodeLLDB) and Windows (C++ tools)
+- Debug builds disable rayon parallelization (`RAYON_NUM_THREADS=1`) for easier debugging
+
+### Compiler Output Options
+```bash
+# Dump unoptimized MIR
+openvaf-r --dump-unopt-mir model.va
+
+# Dump optimized MIR
+openvaf-r --dump-mir model.va
+
+# Dump unoptimized LLVM IR
+openvaf-r --dump-unopt-ir model.va
+
+# Dump optimized LLVM IR
+openvaf-r --dump-ir model.va
+```
+
+### Integration Tests
+Located in `integration_tests/` with real-world device models (BSIM, MEXTRAM, EKV, etc.). Some models have restrictive licenses and don't affect the OpenVAF binary license.
+
+Test data snapshots are in `openvaf/test_data/` organized by category:
+- `ast/`: Abstract syntax tree snapshots
+- `mir/`: MIR snapshots
+- `osdi/`: OSDI descriptor snapshots
+- `ui/`, `syn_ui/`: User-facing diagnostic snapshots
+
+## OSDI 0.4 API
+
+OpenVAF-reloaded generates models with OSDI 0.4 API, which extends 0.3 with:
+- Parameter given flags for model/instance parameters
+- Jacobian array extraction functions
+- Model input lists (node pairs)
+- Offset-based Jacobian loading (for harmonic balance)
+- Nature/discipline/unit descriptors
+- `OSDI_DESCRIPTOR_SIZE` symbol for binary compatibility
+
+The descriptor structure is backward-compatible with OSDI 0.3 when cast appropriately.
+
+## Code Organization
+
+- **openvaf/**: Main compiler crates
+- **verilogae/**: Python bindings
+- **lib/**: Shared utility libraries
+- **integration_tests/**: Real-world test models
+- **xtask/**: Build automation tasks
+- **melange/**: (Secondary component, minimal documentation)
+- **sourcegen/**: Code generation utilities
+
+## Important Notes
+
+- The project uses workspace resolver version 2
+- LLVM version is pinned to 18.1.8 (`llvm-sys = "181.1.1"`)
+- Custom salsa fork: `git = 'https://github.com/pascalkuthe/salsa'`
+- Rust edition: 2021, minimum version varies by crate
+- Release builds use `lto = "off"` and `incremental = true` for faster iteration
+- Optimized profile (`opt`) available with full LTO for production builds
diff --git a/Cargo.lock b/Cargo.lock
index ea8c91942..2fa7e599a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -166,6 +166,7 @@ dependencies = [
  "indexmap 2.10.0",
  "mini_harness",
  "parking_lot",
+ "rustc-hash 2.1.1",
  "salsa",
  "stdx",
  "syntax",
@@ -543,6 +544,7 @@ dependencies = [
  "once_cell",
  "ordered-float",
  "parking_lot",
+ "rustc-hash 2.1.1",
  "salsa",
  "stdx",
  "syntax",
@@ -564,6 +566,7 @@ dependencies = [
  "mir",
  "mir_build",
  "parking_lot",
+ "rustc-hash 2.1.1",
  "salsa",
  "stdx",
  "syntax",
@@ -823,6 +826,7 @@ dependencies = [
  "indexmap 2.10.0",
  "lasso",
  "list_pool",
+ "rustc-hash 2.1.1",
  "stdx",
  "typed-index-collections",
  "typed_indexmap",
@@ -841,6 +845,7 @@ dependencies = [
  "mir",
  "mir_interpret",
  "mir_reader",
+ "rustc-hash 2.1.1",
  "stdx",
  "typed-index-collections",
  "typed_indexmap",
@@ -891,12 +896,12 @@ dependencies = [
 name = "mir_opt"
 version = "0.0.0"
 dependencies = [
- "ahash 0.8.12",
  "bitset",
  "expect-test",
  "hashbrown 0.14.5",
  "mir",
  "mir_reader",
+ "rustc-hash 2.1.1",
  "stdx",
  "typed-index-collections",
  "workqueue",
@@ -1024,7 +1029,6 @@ dependencies = [
 name = "osdi"
 version = "0.0.0"
 dependencies = [
- "ahash 0.8.12",
  "base_n",
  "camino",
  "expect-test",
@@ -1042,6 +1046,7 @@ dependencies = [
  "mir_llvm",
  "paths",
  "rayon-core",
+ "rustc-hash 2.1.1",
  "salsa",
  "sim_back",
  "smol_str",
@@ -1228,7 +1233,7 @@ checksum = "0a542b0253fa46e632d27a1dc5cf7b930de4df8659dc6e720b647fc72147ae3d"
 dependencies = [
  "countme",
  "hashbrown 0.14.5",
- "rustc-hash",
+ "rustc-hash 1.1.0",
  "text-size",
 ]
 
@@ -1244,6 +1249,12 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
+[[package]]
+name = "rustc-hash"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
+
 [[package]]
 name = "ryu_floating_decimal"
 version = "0.1.0"
@@ -1264,7 +1275,7 @@ dependencies = [
  "log",
  "oorandom",
  "parking_lot",
- "rustc-hash",
+ "rustc-hash 1.1.0",
  "salsa-macros",
  "smallvec",
 ]
@@ -1337,6 +1348,7 @@ dependencies = [
  "mir_build",
  "mir_interpret",
  "mir_opt",
+ "rustc-hash 2.1.1",
  "smol_str",
  "stdx",
  "syntax",
@@ -1488,8 +1500,8 @@ dependencies = [
 name = "typed_indexmap"
 version = "0.0.0"
 dependencies = [
- "ahash 0.8.12",
  "indexmap 2.10.0",
+ "rustc-hash 2.1.1",
 ]
 
 [[package]]
@@ -1590,11 +1602,11 @@ checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 name = "vfs"
 version = "0.0.0"
 dependencies = [
- "ahash 0.8.12",
  "chardetng",
  "encoding_rs",
  "indexmap 2.10.0",
  "paths",
+ "rustc-hash 2.1.1",
 ]
 
 [[package]]
diff --git a/README.md b/README.md
index 1c6fbbae5..47dad3102 100644
--- a/README.md
+++ b/README.md
@@ -65,6 +65,8 @@ The version name is generated with `git --describe`. The OpenVAF-reloaded that p
 
 If the binary is named `openvaf` it comes from the `branches/osdi_0.3` branch and produces models with the OSDI 0.3 API. If the binary is named `openvaf-r` it comes from the `master` branch and produces models with the OSDI 0.4 API. 
 
+Packages named `openvaf-reloaded-llvm18-osdi_0.4*` come from the `llvm18` branch. They are linked against LLVM18. The LLVM18 version of OpenVAF produces slightly faster models. If you experience problems with these binaries, let me know. Packages named `openvaf-reloaded-osdi_0.4*` are the conservative choice. They come from the `master` branch and are linked against LLVM15.
+
 
 # Building OpenVAF-reloaded
 
@@ -114,13 +116,48 @@ ninja
 ninja install 
 ```
 
-Add the LLVM binary directory (`<LLVM install directory>\bin`) to the PATH. Set the `LLVM_SYS_181_PREFIX` environmental variable to `<LLVM install directory>`. 
+Add the LLVM binary directory (`<LLVM install directory>\bin`) to the PATH. Set the `LLVM_SYS_181_PREFIX` environmental variable to `<LLVM install directory>`.
+
+Restart command prompt. Now you are good to go.
+
+## Setting up the dependencies under macOS
+
+Install Homebrew if not already installed, then install LLVM 18:
+```bash
+brew install llvm@18
+```
+
+Install Rust if not already installed:
+```bash
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+```
+
+During installation select "Customize installation" and set profile to "complete".
 
-Restart command prompt. Now you are good to go. 
+**Option 1: Use xtask (recommended)** - No additional setup needed. The `cargo xtask cargo-build` command automatically detects LLVM via `HOMEBREW_PREFIX`.
+
+**Option 2: Manual environment setup** - set the following before building:
+```bash
+export LLVM_SYS_181_PREFIX=$(brew --prefix llvm@18)
+export PATH="$(brew --prefix llvm@18)/bin:$PATH"
+```
+
+Now you are good to go.
 
 
 ## Building
 
+### Quick Build (macOS only)
+
+On macOS, you can use the xtask command which automatically detects LLVM 18 via Homebrew:
+```bash
+cargo xtask cargo-build --release
+```
+
+This will auto-configure LLVM 18 paths and build the release version.
+
+### Manual Build
+
 To build the release version (`target/release/openvaf-r`), type
 ```
 cargo build --release --bin openvaf-r
@@ -140,7 +177,20 @@ The debug configuration disables rayon running the .osdi file build process in p
 
 # Running tests with cargo
 
-Pascal has set up a test suite for OpenVAF. To run the tests on the debug version of the binary type
+Pascal has set up a test suite for OpenVAF.
+
+## Quick Test (macOS only)
+
+On macOS, you can use the xtask command which automatically detects LLVM 18 via Homebrew:
+```bash
+cargo xtask cargo-test --release
+```
+
+This will auto-configure LLVM 18 paths and run all tests.
+
+## Manual Testing
+
+To run the tests on the debug version of the binary type
 
     cargo test
 
@@ -148,11 +198,21 @@ To run the tests on the release version type
 
     cargo test --release
 
-By default only fast tests are run. To run all tests set the `RUN_SLOW_TEST` variable to 1, e.g. 
+By default only fast tests are run. To run all tests set the `RUN_SLOW_TEST` variable to 1, e.g.
+
+    RUN_SLOW_TESTS=1 cargo test
+
+## Integration Tests
+
+Integration tests compile real-world Verilog-A models (BSIM, HiSIM, PSP, MEXTRAM, etc.) and verify the generated OSDI libraries. These tests are disabled by default but can be enabled with:
+
+    RUN_DEV_TESTS=1 cargo test --release --test integration
+
+On macOS with LLVM 18, all integration tests should pass.
 
-    RUN_SLOW_TESTS=1 cargo test 
+## Updating Expected Test Results
 
-Your changes may fail some tests although they are correct. Consider the case you changed the MIR generator. The expected test results assume MIR is generated the way Pascal did it. If you are sure your changes are correct you can update the expected values (stored in `openvaf/test_data` as files ending with .snap). To do this set the `UPDATE_EXPECT` variable 1, e.g. 
+Your changes may fail some tests although they are correct. Consider the case you changed the MIR generator. The expected test results assume MIR is generated the way Pascal did it. If you are sure your changes are correct you can update the expected values (stored in `openvaf/test_data` as files ending with .snap). To do this set the `UPDATE_EXPECT` variable 1, e.g.
 
     UPDATE_EXPECT=1 cargo test
 
diff --git a/integration_tests/MODULE_INST/module_inst.va b/integration_tests/MODULE_INST/module_inst.va
new file mode 100644
index 000000000..d628075df
--- /dev/null
+++ b/integration_tests/MODULE_INST/module_inst.va
@@ -0,0 +1,35 @@
+// Test module instantiation syntax support
+// This tests hierarchical module instantiation with parameter overrides
+
+`include "constants.vams"
+`include "disciplines.vams"
+
+// Simple resistor module that can be instantiated
+module resistor(p, n);
+    inout p, n;
+    electrical p, n;
+    parameter real r = 1.0 from (0:inf);
+
+    analog begin
+        I(p, n) <+ V(p, n) / r;
+    end
+endmodule
+
+// Module that instantiates resistors
+module module_inst(d, s);
+    inout d, s;
+    electrical d, s, mid;
+
+    parameter real rwire = 1e-3 from (0:inf);
+    parameter real rload = 1e3 from (0:inf);
+
+    // Module instantiation with parameter override
+    resistor #(.r(rwire)) r_wire (d, mid);
+    resistor #(.r(rload)) r_load (mid, s);
+
+    // Additional behavior
+    analog begin
+        // Add small leakage current
+        I(d, s) <+ V(d, s) * 1e-12;
+    end
+endmodule
diff --git a/lib/bforest/src/map.rs b/lib/bforest/src/map.rs
index a6af3bf8b..9432d3951 100644
--- a/lib/bforest/src/map.rs
+++ b/lib/bforest/src/map.rs
@@ -370,7 +370,7 @@ where
     ///
     /// If the cursor reaches the end, return `None` and leave the cursor at the off-the-end
     /// position.
-    #[cfg_attr(feature = "cargo-clippy", allow(clippy::should_implement_trait))]
+    #[allow(clippy::should_implement_trait)]
     pub fn next(&mut self) -> Option<(K, V)> {
         self.path.next(self.pool)
     }
diff --git a/lib/bforest/src/pool.rs b/lib/bforest/src/pool.rs
index 5dd6ffebb..6d40c166c 100644
--- a/lib/bforest/src/pool.rs
+++ b/lib/bforest/src/pool.rs
@@ -66,7 +66,7 @@ impl<F: Forest> NodePool<F> {
     pub fn free_tree(&mut self, node: Node) {
         if let NodeData::Inner { size, tree, .. } = self[node] {
             // Note that we have to capture `tree` by value to avoid borrow checker trouble.
-            #[cfg_attr(feature = "cargo-clippy", allow(clippy::needless_range_loop))]
+            #[allow(clippy::needless_range_loop)]
             for i in 0..usize::from(size + 1) {
                 // Recursively free sub-trees. This recursion can never be deeper than `MAX_PATH`,
                 // and since most trees have less than a handful of nodes, it is worthwhile to
diff --git a/lib/bforest/src/set.rs b/lib/bforest/src/set.rs
index bbcdb0f74..69f8822f9 100644
--- a/lib/bforest/src/set.rs
+++ b/lib/bforest/src/set.rs
@@ -235,7 +235,7 @@ where
     ///
     /// If the cursor reaches the end, return `None` and leave the cursor at the off-the-end
     /// position.
-    #[cfg_attr(feature = "cargo-clippy", allow(clippy::should_implement_trait))]
+    #[allow(clippy::should_implement_trait)]
     pub fn next(&mut self) -> Option<K> {
         self.path.next(self.pool).map(|(k, _)| k)
     }
diff --git a/lib/typed_indexmap/Cargo.toml b/lib/typed_indexmap/Cargo.toml
index 81c27b390..5759cce17 100644
--- a/lib/typed_indexmap/Cargo.toml
+++ b/lib/typed_indexmap/Cargo.toml
@@ -11,4 +11,4 @@ doctest = false
 
 [dependencies]
 indexmap = "2.0"
-ahash = "0.8"
+rustc-hash = "2.0"
diff --git a/lib/typed_indexmap/src/map.rs b/lib/typed_indexmap/src/map.rs
index 5364f92c5..cd290d788 100644
--- a/lib/typed_indexmap/src/map.rs
+++ b/lib/typed_indexmap/src/map.rs
@@ -1,11 +1,11 @@
 use std::fmt::Debug;
-use std::hash::Hash;
+use std::hash::{BuildHasherDefault, Hash};
 use std::iter;
 use std::marker::PhantomData;
 use std::ops::{Index, IndexMut};
 
-use ahash::RandomState;
 use indexmap::{Equivalent, IndexMap};
+use rustc_hash::FxHasher;
 
 pub type Iter<'a, I, K, V> = iter::Map<
     iter::Enumerate<indexmap::map::Iter<'a, K, V>>,
@@ -15,7 +15,7 @@ pub type Iter<'a, I, K, V> = iter::Map<
 #[repr(transparent)]
 pub struct TiMap<I, K, V> {
     /// raw set property
-    pub raw: IndexMap<K, V, ahash::RandomState>,
+    pub raw: IndexMap<K, V, BuildHasherDefault<FxHasher>>,
     _marker: PhantomData<fn(I) -> I>,
 }
 
@@ -38,7 +38,10 @@ impl<I, K: Clone, V: Clone> Clone for TiMap<I, K, V> {
 
 impl<I, K, V> Default for TiMap<I, K, V> {
     fn default() -> Self {
-        Self { raw: IndexMap::default(), _marker: PhantomData }
+        Self {
+            raw: IndexMap::with_hasher(BuildHasherDefault::<FxHasher>::default()),
+            _marker: PhantomData,
+        }
     }
 }
 
@@ -75,7 +78,7 @@ impl<I, K, V> TiMap<I, K, V> {
 
     pub fn with_capacity(cap: usize) -> Self {
         Self {
-            raw: IndexMap::with_capacity_and_hasher(cap, RandomState::new()),
+            raw: IndexMap::with_capacity_and_hasher(cap, BuildHasherDefault::<FxHasher>::default()),
             _marker: PhantomData,
         }
     }
@@ -177,21 +180,24 @@ where
     }
 }
 
-impl<I, K, V> From<IndexMap<K, V, ahash::RandomState>> for TiMap<I, K, V> {
-    fn from(raw: IndexMap<K, V, ahash::RandomState>) -> Self {
+impl<I, K, V> From<IndexMap<K, V, BuildHasherDefault<FxHasher>>> for TiMap<I, K, V> {
+    fn from(raw: IndexMap<K, V, BuildHasherDefault<FxHasher>>) -> Self {
         TiMap { raw, _marker: PhantomData }
     }
 }
 
 impl<I, K: Hash + Eq, V> FromIterator<(K, V)> for TiMap<I, K, V> {
     fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> Self {
-        Self { raw: iter.into_iter().collect(), _marker: PhantomData }
+        let mut map = IndexMap::with_hasher(BuildHasherDefault::<FxHasher>::default());
+        map.extend(iter);
+        Self { raw: map, _marker: PhantomData }
     }
 }
 
-impl<I, K, V> AsRef<TiMap<I, K, V>> for IndexMap<K, V, RandomState> {
+impl<I, K, V> AsRef<TiMap<I, K, V>> for IndexMap<K, V, BuildHasherDefault<FxHasher>> {
     fn as_ref(&self) -> &TiMap<I, K, V> {
-        let ptr = self as *const IndexMap<K, V, RandomState> as *const TiMap<I, K, V>;
+        let ptr =
+            self as *const IndexMap<K, V, BuildHasherDefault<FxHasher>> as *const TiMap<I, K, V>;
         // safety: this is save because of repr(transparent)
         unsafe { &*ptr }
     }
diff --git a/lib/typed_indexmap/src/set.rs b/lib/typed_indexmap/src/set.rs
index 5bacf9402..8dc24a9f3 100644
--- a/lib/typed_indexmap/src/set.rs
+++ b/lib/typed_indexmap/src/set.rs
@@ -1,17 +1,18 @@
 use std::fmt::Debug;
-use std::hash::Hash;
+use std::hash::{BuildHasherDefault, Hash};
 use std::iter;
 use std::marker::PhantomData;
 use std::ops::Index;
 
 use indexmap::{Equivalent, IndexSet};
+use rustc_hash::FxHasher;
 
 pub type Iter<'a, K, V> =
     iter::Map<iter::Enumerate<indexmap::set::Iter<'a, V>>, fn((usize, &'a V)) -> (K, &'a V)>;
 
 pub struct TiSet<K, V> {
     /// raw set property
-    pub raw: IndexSet<V, ahash::RandomState>,
+    pub raw: IndexSet<V, BuildHasherDefault<FxHasher>>,
     _marker: PhantomData<fn(K) -> K>,
 }
 
@@ -33,14 +34,17 @@ impl<K, V: Clone> Clone for TiSet<K, V> {
 
 impl<K, V> Default for TiSet<K, V> {
     fn default() -> Self {
-        Self { raw: IndexSet::default(), _marker: PhantomData }
+        Self {
+            raw: IndexSet::with_hasher(BuildHasherDefault::<FxHasher>::default()),
+            _marker: PhantomData,
+        }
     }
 }
 
 impl<K, V> TiSet<K, V> {
     pub fn with_capacity(cap: usize) -> TiSet<K, V> {
         TiSet {
-            raw: IndexSet::with_capacity_and_hasher(cap, ahash::RandomState::default()),
+            raw: IndexSet::with_capacity_and_hasher(cap, BuildHasherDefault::<FxHasher>::default()),
             _marker: PhantomData,
         }
     }
@@ -95,7 +99,7 @@ where
 }
 
 impl<K: From<usize>, V> TiSet<K, V> {
-    pub fn iter_enumerated(&self) -> Iter<K, V> {
+    pub fn iter_enumerated(&self) -> Iter<'_, K, V> {
         self.iter().enumerate().map(|(index, val)| (index.into(), val))
     }
 }
@@ -174,6 +178,8 @@ where
     V: Eq + Hash,
 {
     fn from_iter<T: IntoIterator<Item = V>>(iter: T) -> Self {
-        Self { raw: iter.into_iter().collect(), _marker: PhantomData }
+        let mut set = IndexSet::with_hasher(BuildHasherDefault::<FxHasher>::default());
+        set.extend(iter);
+        Self { raw: set, _marker: PhantomData }
     }
 }
diff --git a/melange/core/src/simulation.rs b/melange/core/src/simulation.rs
index 6a7d350bf..f834903a8 100644
--- a/melange/core/src/simulation.rs
+++ b/melange/core/src/simulation.rs
@@ -91,13 +91,13 @@ impl Circuit {
         eval_ctx: ExprEvalCtxRef,
         arena: &Arena,
         config: SimConfig,
-    ) -> Result<Simulation> {
+    ) -> Result<Simulation<'_>> {
         let mut res = self.setup_simulation(config)?;
         res.prepare_solver(eval_ctx, arena)?;
         Ok(res)
     }
 
-    pub fn setup_simulation(&self, config: SimConfig) -> Result<Simulation> {
+    pub fn setup_simulation(&self, config: SimConfig) -> Result<Simulation<'_>> {
         let model_data: Box<TiSlice<_, _>> = self
             .models()
             .map(|model| {
diff --git a/melange/core/src/veriloga.rs b/melange/core/src/veriloga.rs
index ee31ee8c1..a4a8750f7 100644
--- a/melange/core/src/veriloga.rs
+++ b/melange/core/src/veriloga.rs
@@ -9,8 +9,8 @@ use libc::c_void;
 use libloading::Library;
 use log::{debug, error, info, warn};
 use openvaf::{
-    AbsPathBuf, CompilationDestination, CompilationTermination, LLVMCodeGenOptLevel, LintLevel,
-    Target,
+    AbsPathBuf, CompilationDestination, CompilationOpts, CompilationTermination,
+    LLVMCodeGenOptLevel, LintLevel, Target,
 };
 pub(crate) use osdi_0_4::{
     ANALYSIS_AC, ANALYSIS_DC, ANALYSIS_IC, ANALYSIS_NOISE, ANALYSIS_STATIC, ANALYSIS_TRAN,
@@ -78,6 +78,7 @@ pub fn compile_va(path: &Utf8Path, opts: &Opts) -> Result<Vec<Box<dyn DeviceImpl
         dump_unopt_mir: false,
         dump_ir: false,
         dump_unopt_ir: false,
+        compilation_opts: CompilationOpts::default(),
     };
 
     let res = openvaf::compile(&openvaf_opts);
diff --git a/openvaf/basedb/Cargo.toml b/openvaf/basedb/Cargo.toml
index 2ab9505b1..4499f9561 100644
--- a/openvaf/basedb/Cargo.toml
+++ b/openvaf/basedb/Cargo.toml
@@ -35,6 +35,7 @@ typed-index-collections = "3.1"
 parking_lot = "0.12"
 indexmap = "2.0"
 ahash = "0.8"
+rustc-hash = "2.0"
 
 [dev-dependencies]
 expect-test = "1.4"
diff --git a/openvaf/basedb/src/lib.rs b/openvaf/basedb/src/lib.rs
index e83830efc..cc15d7c8f 100644
--- a/openvaf/basedb/src/lib.rs
+++ b/openvaf/basedb/src/lib.rs
@@ -5,7 +5,7 @@ mod lint_attrs;
 pub mod lints;
 
 use std::fs;
-use std::intrinsics::transmute;
+use std::mem::transmute;
 use std::sync::Arc;
 
 pub use ast_id_map::{AstId, AstIdMap, ErasedAstId};
diff --git a/openvaf/basedb/src/lints.rs b/openvaf/basedb/src/lints.rs
index 97f626912..dd776ec58 100644
--- a/openvaf/basedb/src/lints.rs
+++ b/openvaf/basedb/src/lints.rs
@@ -1,7 +1,9 @@
 use std::fmt::{self, Display, Formatter};
+use std::hash::BuildHasherDefault;
 use std::sync::Arc;
 
 use indexmap::IndexMap;
+use rustc_hash::FxHasher;
 use stdx::{impl_debug_display, impl_idx_from};
 use vfs::FileId;
 
@@ -101,7 +103,7 @@ pub struct LintData {
 /// and `str (lint name) -> LintData`
 #[derive(Debug, Default, Eq, PartialEq)]
 pub struct LintRegistry {
-    lints: IndexMap<&'static str, LintData, ahash::RandomState>,
+    lints: IndexMap<&'static str, LintData, BuildHasherDefault<FxHasher>>,
 }
 
 impl LintRegistry {
diff --git a/openvaf/hir/src/db.rs b/openvaf/hir/src/db.rs
index e92a237a9..54d7e18eb 100644
--- a/openvaf/hir/src/db.rs
+++ b/openvaf/hir/src/db.rs
@@ -1,5 +1,5 @@
-use std::intrinsics::transmute;
 use std::iter::{self, once};
+use std::mem::transmute;
 use std::ops::Deref;
 use std::sync::Arc;
 use std::{fs, io};
@@ -8,7 +8,7 @@ use anyhow::{bail, Result};
 use basedb::lints::{Lint, LintLevel};
 use basedb::{AbsPathBuf, BaseDB, BaseDatabase, FileId, Vfs, VfsPath, VfsStorage, STANDARD_FLAGS};
 use hir_def::db::{HirDefDB, HirDefDatabase, InternDatabase};
-use hir_ty::db::HirTyDatabase;
+use hir_ty::db::{HirTyDB, HirTyDatabase};
 use parking_lot::RwLock;
 use salsa::ParallelDatabase;
 use stdx::Upcast;
@@ -16,6 +16,14 @@ use typed_index_collections::TiSlice;
 
 use crate::CompilationUnit;
 
+/// Compilation options for the HIR database
+#[derive(Debug, Clone, Default)]
+pub struct CompilationOpts {
+    /// Allow analog operators (limexp, ddt, idt) in signal-dependent conditionals.
+    /// This is non-standard Verilog-A behavior required by some foundry models.
+    pub allow_analog_in_cond: bool,
+}
+
 #[salsa::database(BaseDatabase, InternDatabase, HirDefDatabase, HirTyDatabase)]
 pub struct CompilationDB {
     storage: salsa::Storage<CompilationDB>,
@@ -41,6 +49,7 @@ impl CompilationDB {
         include_dirs: &[AbsPathBuf],
         macro_flags: &[String],
         lints: &[(String, LintLevel)],
+        opts: &CompilationOpts,
     ) -> Result<Self> {
         let contents = fs::read(&root_file);
         CompilationDB::new(
@@ -49,6 +58,7 @@ impl CompilationDB {
             include_dirs.iter().map(|path| Ok(VfsPath::from(path.clone()))),
             macro_flags.iter().map(String::deref),
             lints.iter().map(|(name, lvl)| (&**name, *lvl)),
+            opts,
         )
     }
 
@@ -61,6 +71,7 @@ impl CompilationDB {
             iter::empty(),
             iter::empty(),
             iter::empty(),
+            &CompilationOpts::default(),
         )
     }
 
@@ -74,6 +85,7 @@ impl CompilationDB {
         include_dirs: impl Iterator<Item = Result<VfsPath>>,
         macro_flags: impl Iterator<Item = &'a str>,
         lints: impl Iterator<Item = (&'a str, LintLevel)>,
+        opts: &CompilationOpts,
     ) -> Result<Self> {
         let mut vfs = Vfs::default();
         vfs.insert_std_lib();
@@ -131,6 +143,7 @@ impl CompilationDB {
         };
 
         res.set_global_lint_overwrites(root_file, overwrites);
+        res.set_allow_analog_in_cond(opts.allow_analog_in_cond);
         Ok(res)
     }
 }
diff --git a/openvaf/hir/src/lib.rs b/openvaf/hir/src/lib.rs
index d446d48c1..9f729bedb 100644
--- a/openvaf/hir/src/lib.rs
+++ b/openvaf/hir/src/lib.rs
@@ -39,7 +39,7 @@ pub use crate::attributes::AstCache;
 pub use crate::body::{
     AssignmentLhs, Body, BodyRef, ContributeKind, Expr, ExprId, Ref, ResolvedFun, Stmt, StmtId,
 };
-pub use crate::db::CompilationDB;
+pub use crate::db::{CompilationDB, CompilationOpts};
 
 mod attributes;
 mod body;
diff --git a/openvaf/hir/tests/data_tests.rs b/openvaf/hir/tests/data_tests.rs
index e3c8e2228..f0e702c6c 100644
--- a/openvaf/hir/tests/data_tests.rs
+++ b/openvaf/hir/tests/data_tests.rs
@@ -2,7 +2,7 @@ use std::path::Path;
 
 use basedb::AbsPathBuf;
 use expect_test::expect_file;
-use hir::CompilationDB;
+use hir::{CompilationDB, CompilationOpts};
 use mini_harness::{harness, Result};
 use stdx::{ignore_dev_tests, ignore_never, is_va_file, openvaf_test_data, project_root};
 
@@ -10,17 +10,42 @@ fn integration_test(dir: &Path) -> Result {
     let name = dir.file_name().unwrap().to_str().unwrap().to_lowercase();
     let main_file = dir.join(format!("{name}.va"));
 
-    let db =
-        CompilationDB::new_fs(AbsPathBuf::assert(main_file.canonicalize().unwrap()), &[], &[], &[])
-            .unwrap();
+    let db = CompilationDB::new_fs(
+        AbsPathBuf::assert(main_file.canonicalize().unwrap()),
+        &[],
+        &[],
+        &[],
+        &CompilationOpts::default(),
+    )
+    .unwrap();
     expect_file![dir.join("frontend.log")].assert_eq(&db.compilation_unit().test_diagnostics(&db));
 
     Ok(())
 }
 
 fn ui_test(file: &Path) -> Result {
-    let db = CompilationDB::new_fs(AbsPathBuf::assert(file.canonicalize().unwrap()), &[], &[], &[])
-        .unwrap();
+    let db = CompilationDB::new_fs(
+        AbsPathBuf::assert(file.canonicalize().unwrap()),
+        &[],
+        &[],
+        &[],
+        &CompilationOpts::default(),
+    )
+    .unwrap();
+    let actual = db.compilation_unit().test_diagnostics(&db);
+    expect_file![file.with_extension("log")].assert_eq(&actual);
+    Ok(())
+}
+
+fn ui_allow_analog_cond_test(file: &Path) -> Result {
+    let db = CompilationDB::new_fs(
+        AbsPathBuf::assert(file.canonicalize().unwrap()),
+        &[],
+        &[],
+        &[],
+        &CompilationOpts { allow_analog_in_cond: true },
+    )
+    .unwrap();
     let actual = db.compilation_unit().test_diagnostics(&db);
     expect_file![file.with_extension("log")].assert_eq(&actual);
     Ok(())
@@ -28,5 +53,6 @@ fn ui_test(file: &Path) -> Result {
 
 harness! {
     Test::from_dir_filtered("integration", &integration_test, &Path::is_dir, &ignore_dev_tests, &project_root().join("integration_tests")),
-    Test::from_dir_filtered("ui", &ui_test, &is_va_file, &ignore_never, &openvaf_test_data("ui"))
+    Test::from_dir_filtered("ui", &ui_test, &is_va_file, &ignore_never, &openvaf_test_data("ui")),
+    Test::from_dir_filtered("ui_allow_analog_cond", &ui_allow_analog_cond_test, &is_va_file, &ignore_never, &openvaf_test_data("ui_allow_analog_cond"))
 }
diff --git a/openvaf/hir_def/Cargo.toml b/openvaf/hir_def/Cargo.toml
index b064a3dc2..cb8874444 100644
--- a/openvaf/hir_def/Cargo.toml
+++ b/openvaf/hir_def/Cargo.toml
@@ -31,6 +31,7 @@ typed-index-collections = "3.1"
 
 # Performant collections
 ahash = "0.8"
+rustc-hash = "2.0"
 indexmap = "2.0"
 
 [dev-dependencies]
diff --git a/openvaf/hir_def/src/builtin.rs b/openvaf/hir_def/src/builtin.rs
index c3a12e939..5729cfb54 100644
--- a/openvaf/hir_def/src/builtin.rs
+++ b/openvaf/hir_def/src/builtin.rs
@@ -1,7 +1,9 @@
 //! Generated by `generate_builtins`, do not edit by hand.
 
-use ahash::RandomState;
+use std::hash::BuildHasherDefault;
+
 use indexmap::IndexMap;
+use rustc_hash::FxHasher;
 use syntax::name::{kw, sysfun, Name};
 
 use crate::nameres::ScopeDefItem;
@@ -238,7 +240,7 @@ impl BuiltIn {
         }
     }
 }
-pub fn insert_builtin_scope(dst: &mut IndexMap<Name, ScopeDefItem, RandomState>) {
+pub fn insert_builtin_scope(dst: &mut IndexMap<Name, ScopeDefItem, BuildHasherDefault<FxHasher>>) {
     dst.insert(kw::abs, BuiltIn::abs.into());
     dst.insert(kw::acos, BuiltIn::acos.into());
     dst.insert(kw::acosh, BuiltIn::acosh.into());
@@ -371,7 +373,9 @@ pub fn insert_builtin_scope(dst: &mut IndexMap<Name, ScopeDefItem, RandomState>)
     dst.insert(kw::slew, BuiltIn::slew.into());
     dst.insert(kw::transition, BuiltIn::transition.into());
 }
-pub fn insert_module_builtin_scope(dst: &mut IndexMap<Name, ScopeDefItem, RandomState>) {
+pub fn insert_module_builtin_scope(
+    dst: &mut IndexMap<Name, ScopeDefItem, BuildHasherDefault<FxHasher>>,
+) {
     dst.insert(sysfun::mfactor, ParamSysFun::mfactor.into());
     dst.insert(sysfun::xposition, ParamSysFun::xposition.into());
     dst.insert(sysfun::yposition, ParamSysFun::yposition.into());
diff --git a/openvaf/hir_def/src/item_tree.rs b/openvaf/hir_def/src/item_tree.rs
index b40a07c4a..8ceb36137 100644
--- a/openvaf/hir_def/src/item_tree.rs
+++ b/openvaf/hir_def/src/item_tree.rs
@@ -73,6 +73,7 @@ impl ItemTree {
             ports,
             branches,
             functions,
+            module_insts,
         } = &mut self.data;
         modules.shrink_to_fit();
         disciplines.shrink_to_fit();
@@ -87,6 +88,7 @@ impl ItemTree {
         functions.shrink_to_fit();
         nature_attrs.shrink_to_fit();
         discipline_attrs.shrink_to_fit();
+        module_insts.shrink_to_fit();
     }
 
     pub fn block_scope(&self, block: AstId<BlockStmt>) -> &Block {
@@ -109,6 +111,7 @@ pub struct ItemTreeData {
     pub ports: Arena<Port>,
     pub branches: Arena<Branch>,
     pub functions: Arena<Function>,
+    pub module_insts: Arena<ModuleInstItem>,
 }
 
 /// Trait implemented by all item nodes in the item tree.
@@ -230,6 +233,7 @@ item_tree_nodes! {
     Function in functions -> ast::Function,
     NatureAttr in nature_attrs -> ast::NatureAttr,
     DisciplineAttr in discipline_attrs -> ast::DisciplineAttr,
+    ModuleInstItem in module_insts -> ast::ModuleInst,
 }
 
 #[derive(Debug, Eq, PartialEq, Clone)]
@@ -250,6 +254,7 @@ pub enum ModuleItem {
     Branch(ItemTreeId<Branch>),
     Node(LocalNodeId),
     Function(ItemTreeId<Function>),
+    ModuleInst(ItemTreeId<ModuleInstItem>),
 }
 
 impl_from_typed! (
@@ -259,7 +264,8 @@ impl_from_typed! (
     Variable(ItemTreeId<Var>),
     Branch(ItemTreeId<Branch>),
     Node(LocalNodeId),
-    Function(ItemTreeId<Function>) for ModuleItem
+    Function(ItemTreeId<Function>),
+    ModuleInst(ItemTreeId<ModuleInstItem>) for ModuleItem
 );
 
 #[derive(Debug, Eq, PartialEq, Clone)]
@@ -418,6 +424,22 @@ impl_from_typed! (
     FunctionArg(LocalFunctionArgId) for FunctionItem
 );
 
+/// A module instantiation (hierarchical instance)
+/// Example: `resistor #(.r(rwire)) r1 (d, de0);`
+#[derive(Debug, Eq, PartialEq, Clone)]
+pub struct ModuleInstItem {
+    /// Instance name (e.g., "r1")
+    pub name: Name,
+    /// Module type being instantiated (e.g., "resistor")
+    pub module_name: Name,
+    /// Parameter overrides (e.g., [("r", "rwire")])
+    pub param_assignments: Vec<(Name, Name)>,
+    /// Port connections (node names in order)
+    pub port_connections: Vec<Name>,
+    /// AST node reference
+    pub ast_id: AstId<ast::ModuleInst>,
+}
+
 #[derive(Debug, Eq, PartialEq, Clone)]
 pub struct FunctionArg {
     pub name: Name,
diff --git a/openvaf/hir_def/src/item_tree/lower.rs b/openvaf/hir_def/src/item_tree/lower.rs
index 05e5e6685..8456f72d6 100644
--- a/openvaf/hir_def/src/item_tree/lower.rs
+++ b/openvaf/hir_def/src/item_tree/lower.rs
@@ -11,8 +11,8 @@ use typed_index_collections::TiVec;
 
 use super::{
     Block, Branch, BranchKind, Discipline, DisciplineAttr, DisciplineAttrKind, Domain, Function,
-    FunctionArg, FunctionItem, ItemTree, ItemTreeId, Module, ModuleItem, Nature, NatureAttr,
-    NatureRef, NatureRefKind, Net, Node, Param, Port, RootItem, Var,
+    FunctionArg, FunctionItem, ItemTree, ItemTreeId, Module, ModuleInstItem, ModuleItem, Nature,
+    NatureAttr, NatureRef, NatureRefKind, Net, Node, Param, Port, RootItem, Var,
 };
 // use tracing::trace;
 use crate::db::HirDefDB;
@@ -209,7 +209,7 @@ impl Ctx {
                             attr.val().and_then(|e| e.as_literal())
                         {
                             let a = attr.val().unwrap();
-                            let b = a.as_literal();
+                            let _b = a.as_literal();
                             let s = lit.unescaped_value();
                             evaluated = Some(ConstExprValue::String(s.clone()));
                             units = Some((s, id.into()));
@@ -300,6 +300,7 @@ impl Ctx {
                 }
                 ast::ModuleItem::BranchDecl(branch) => self.lower_branch(branch, dst),
                 ast::ModuleItem::AliasParam(alias) => self.lower_alias_param(alias, dst),
+                ast::ModuleItem::ModuleInst(inst) => self.lower_module_inst(inst, dst),
             };
         }
     }
@@ -610,4 +611,62 @@ impl Ctx {
             dst.push(param.into())
         }
     }
+
+    fn lower_module_inst(&mut self, inst: ast::ModuleInst, dst: &mut Vec<ModuleItem>) {
+        let inst_name = match inst.inst_name() {
+            Some(name) => name.as_name(),
+            None => return,
+        };
+        let module_name = match inst.module_name() {
+            Some(name) => name.as_name(),
+            None => return,
+        };
+
+        // Extract parameter assignments: .param(value) -> (param_name, value_expr_as_name)
+        let param_assignments = inst
+            .param_assignments()
+            .map(|pas| {
+                pas.param_assignments()
+                    .filter_map(|pa| {
+                        let param_name = pa.param()?.as_name();
+                        // Try to extract the value as a simple name/identifier
+                        // For complex expressions, we just skip for now
+                        let value_name = pa.value().and_then(|e| e.as_ident())?;
+                        Some((param_name, value_name))
+                    })
+                    .collect()
+            })
+            .unwrap_or_default();
+
+        // Extract port connections - for positional connections, extract the node name
+        let port_connections = inst
+            .port_connections()
+            .map(|pcs| {
+                pcs.port_connections()
+                    .filter_map(|pc| {
+                        // For named connections: .port(expr) - use the connection expr
+                        // For positional connections: just expr - use the expr
+                        let expr = if pc.dot_token().is_some() {
+                            pc.connection()
+                        } else {
+                            pc.expr()
+                        };
+                        expr.and_then(|e| e.as_ident())
+                    })
+                    .collect()
+            })
+            .unwrap_or_default();
+
+        let ast_id = self.source_ast_id_map.ast_id(&inst);
+
+        let module_inst = ModuleInstItem {
+            name: inst_name,
+            module_name,
+            param_assignments,
+            port_connections,
+            ast_id,
+        };
+        let id = self.tree.data.module_insts.push_and_get_key(module_inst);
+        dst.push(id.into());
+    }
 }
diff --git a/openvaf/hir_def/src/item_tree/pretty.rs b/openvaf/hir_def/src/item_tree/pretty.rs
index 5bbc4590d..fa71dc835 100644
--- a/openvaf/hir_def/src/item_tree/pretty.rs
+++ b/openvaf/hir_def/src/item_tree/pretty.rs
@@ -124,6 +124,17 @@ impl<'a> Printer<'a> {
                     let param = &self.tree[param];
                     wln!(self, "aliasparam {} = {:?}", param.name, param.src);
                 }
+                ModuleItem::ModuleInst(inst) => {
+                    let inst = &self.tree[inst];
+                    wln!(
+                        self,
+                        "module_inst {} {} #({:?}) ({:?})",
+                        inst.module_name,
+                        inst.name,
+                        inst.param_assignments,
+                        inst.port_connections
+                    );
+                }
             }
         }
     }
diff --git a/openvaf/hir_def/src/nameres.rs b/openvaf/hir_def/src/nameres.rs
index 17b1858e4..a49591c3b 100644
--- a/openvaf/hir_def/src/nameres.rs
+++ b/openvaf/hir_def/src/nameres.rs
@@ -1,3 +1,4 @@
+use std::hash::BuildHasherDefault;
 use std::ops::{Index, IndexMut};
 use std::sync::Arc;
 
@@ -5,6 +6,7 @@ use arena::{Arena, Idx};
 use basedb::{AstIdMap, ErasedAstId, FileId};
 use indexmap::IndexMap;
 use once_cell::sync::Lazy;
+use rustc_hash::FxHasher;
 use stdx::{impl_display, impl_from, impl_from_typed};
 use syntax::name::{kw, Name};
 use syntax::{AstNode, Parse, SourceFile, TextRange};
@@ -271,18 +273,19 @@ impl_from_typed! {
     for ScopeOrigin
 }
 
-static BUILTIN_SCOPE: Lazy<IndexMap<Name, ScopeDefItem, ahash::RandomState>> = Lazy::new(|| {
-    let mut scope = IndexMap::default();
-    insert_builtin_scope(&mut scope);
-    scope
-});
+static BUILTIN_SCOPE: Lazy<IndexMap<Name, ScopeDefItem, BuildHasherDefault<FxHasher>>> =
+    Lazy::new(|| {
+        let mut scope = IndexMap::default();
+        insert_builtin_scope(&mut scope);
+        scope
+    });
 
 #[derive(PartialEq, Eq, Clone, Debug)]
 pub struct Scope {
     pub origin: ScopeOrigin,
     parent: Option<LocalScopeId>,
-    pub children: IndexMap<Name, LocalScopeId, ahash::RandomState>,
-    pub declarations: IndexMap<Name, ScopeDefItem, ahash::RandomState>,
+    pub children: IndexMap<Name, LocalScopeId, BuildHasherDefault<FxHasher>>,
+    pub declarations: IndexMap<Name, ScopeDefItem, BuildHasherDefault<FxHasher>>,
 }
 
 impl DefMap {
diff --git a/openvaf/hir_def/src/nameres/collect.rs b/openvaf/hir_def/src/nameres/collect.rs
index 320586cf2..c368c8aaf 100644
--- a/openvaf/hir_def/src/nameres/collect.rs
+++ b/openvaf/hir_def/src/nameres/collect.rs
@@ -282,6 +282,10 @@ impl DefCollector<'_> {
                 ModuleItem::AliasParameter(id) => {
                     self.insert_item_decl(scope, self.tree[id].name.clone(), id)
                 }
+                ModuleItem::ModuleInst(_) => {
+                    // Module instances are recorded but don't participate in name resolution
+                    // They will be processed later during elaboration/flattening
+                }
             }
         }
     }
diff --git a/openvaf/hir_lower/Cargo.toml b/openvaf/hir_lower/Cargo.toml
index 84c7e7454..af3fffa08 100644
--- a/openvaf/hir_lower/Cargo.toml
+++ b/openvaf/hir_lower/Cargo.toml
@@ -22,6 +22,7 @@ mir = {version = "0.0.0", path = "../mir" }
 mir_build = {version = "0.0.0", path = "../mir_build" }
 
 ahash = "0.8"
+rustc-hash = "2.0"
 typed-index-collections = "3.1"
 indexmap = "2.0"
 lasso = {version = "0.7", features = ["ahash"]}
diff --git a/openvaf/hir_lower/src/callbacks.rs b/openvaf/hir_lower/src/callbacks.rs
index 466e4149f..5b3b6bf48 100644
--- a/openvaf/hir_lower/src/callbacks.rs
+++ b/openvaf/hir_lower/src/callbacks.rs
@@ -1,5 +1,3 @@
-use std::fmt::Display;
-
 use hir::{Node, Parameter};
 use lasso::Spur;
 use mir::{FunctionSignature, Param};
diff --git a/openvaf/hir_lower/src/lib.rs b/openvaf/hir_lower/src/lib.rs
index 6dc719f01..1f54f72e6 100644
--- a/openvaf/hir_lower/src/lib.rs
+++ b/openvaf/hir_lower/src/lib.rs
@@ -1,3 +1,4 @@
+use std::hash::BuildHasherDefault;
 use std::iter::FilterMap;
 
 use ahash::{AHashMap, AHashSet};
@@ -11,6 +12,7 @@ use lasso::Rodeo;
 use mir::builder::InstBuilder;
 use mir::{DataFlowGraph, FuncRef, Function, Inst, KnownDerivatives, Param, Unknown, Value};
 use mir_build::{FunctionBuilder, FunctionBuilderContext, RetBuilder};
+use rustc_hash::FxHasher;
 use stdx::packed_option::PackedOption;
 use stdx::{impl_debug_display, impl_idx_from};
 use typed_index_collections::TiVec;
@@ -220,13 +222,13 @@ impl_debug_display! {
 
 /// A mapping between abstractions used in the MIR and the corresponding
 /// information from the HIR. This allows the MIR to remain independent of the frontend/HIR
-#[derive(Debug, PartialEq, Default, Clone)]
+#[derive(Debug, PartialEq, Clone)]
 pub struct HirInterner {
-    pub outputs: IndexMap<PlaceKind, PackedOption<Value>, ahash::RandomState>,
+    pub outputs: IndexMap<PlaceKind, PackedOption<Value>, BuildHasherDefault<FxHasher>>,
     pub params: TiMap<Param, ParamKind, Value>,
     pub callbacks: TiSet<FuncRef, CallBackKind>,
     pub callback_uses: TiVec<FuncRef, Vec<Inst>>,
-    pub tagged_reads: IndexMap<Value, Variable, ahash::RandomState>,
+    pub tagged_reads: IndexMap<Value, Variable, BuildHasherDefault<FxHasher>>,
     pub implicit_equations: TiVec<ImplicitEquation, ImplicitEquationKind>,
     pub lim_state: TiMap<LimitState, Value, Vec<(Value, bool)>>,
 }
@@ -236,6 +238,20 @@ pub type LiveParams<'a> = FilterMap<
     fn((Param, (&'a ParamKind, &'a Value))) -> Option<(Param, &'a ParamKind, Value)>,
 >;
 
+impl Default for HirInterner {
+    fn default() -> Self {
+        Self {
+            outputs: IndexMap::with_hasher(BuildHasherDefault::<FxHasher>::default()),
+            params: TiMap::default(),
+            callbacks: TiSet::default(),
+            callback_uses: TiVec::default(),
+            tagged_reads: IndexMap::with_hasher(BuildHasherDefault::<FxHasher>::default()),
+            implicit_equations: TiVec::default(),
+            lim_state: TiMap::default(),
+        }
+    }
+}
+
 impl HirInterner {
     fn contains_ddx(
         ddx_calls: &mut AHashMap<FuncRef, (HybridBitSet<Unknown>, HybridBitSet<Unknown>)>,
diff --git a/openvaf/hir_lower/tests/data_tests.rs b/openvaf/hir_lower/tests/data_tests.rs
index 3c2a9afa8..1af54c550 100644
--- a/openvaf/hir_lower/tests/data_tests.rs
+++ b/openvaf/hir_lower/tests/data_tests.rs
@@ -2,7 +2,7 @@ use std::path::Path;
 
 use basedb::AbsPathBuf;
 use expect_test::expect_file;
-use hir::CompilationDB;
+use hir::{CompilationDB, CompilationOpts};
 use hir_lower::{MirBuilder, PlaceKind};
 use lasso::Rodeo;
 use mini_harness::{harness, Result};
@@ -29,14 +29,27 @@ fn lower(db: &CompilationDB) {
 fn integration_test(dir: &Path) -> Result {
     let name = dir.file_name().unwrap().to_str().unwrap().to_lowercase();
     let main_file = dir.join(format!("{name}.va")).canonicalize().unwrap();
-    let db = CompilationDB::new_fs(AbsPathBuf::assert(main_file), &[], &[], &[]).unwrap();
+    let db = CompilationDB::new_fs(
+        AbsPathBuf::assert(main_file),
+        &[],
+        &[],
+        &[],
+        &CompilationOpts::default(),
+    )
+    .unwrap();
     lower(&db);
     Ok(())
 }
 
 fn mir_test(file: &Path) -> Result {
-    let db = CompilationDB::new_fs(AbsPathBuf::assert(file.canonicalize().unwrap()), &[], &[], &[])
-        .unwrap();
+    let db = CompilationDB::new_fs(
+        AbsPathBuf::assert(file.canonicalize().unwrap()),
+        &[],
+        &[],
+        &[],
+        &CompilationOpts::default(),
+    )
+    .unwrap();
     assert_eq!(db.compilation_unit().test_diagnostics(&db), "");
 
     let module = db.compilation_unit().modules(&db)[0];
diff --git a/openvaf/hir_ty/src/db.rs b/openvaf/hir_ty/src/db.rs
index 99178388a..6a5c93ac3 100644
--- a/openvaf/hir_ty/src/db.rs
+++ b/openvaf/hir_ty/src/db.rs
@@ -44,6 +44,9 @@ pub trait HirTyDB: HirDefDB + Upcast<dyn HirDefDB> {
 
     #[salsa::input]
     fn known_limit_functions(&self) -> Option<Arc<[LimitSignature]>>;
+
+    #[salsa::input]
+    fn allow_analog_in_cond(&self) -> bool;
 }
 
 fn nature_attr_ty(db: &dyn HirTyDB, id: NatureAttrId) -> Option<Type> {
diff --git a/openvaf/hir_ty/src/validation/body.rs b/openvaf/hir_ty/src/validation/body.rs
index 255173522..4e6a6a344 100644
--- a/openvaf/hir_ty/src/validation/body.rs
+++ b/openvaf/hir_ty/src/validation/body.rs
@@ -120,6 +120,7 @@ impl BodyValidationDiagnostic {
             non_const_dominator: Box::default(),
             non_trivial_branches: HashSet::default(),
             trivial_probes: HashMap::default(),
+            allow_analog_in_cond: db.allow_analog_in_cond(),
         };
 
         for stmt in &*body.entry_stmts {
@@ -160,8 +161,12 @@ impl BodyCtx {
         matches!(self, Self::AnalogBlock | Self::Conditional)
     }
 
-    fn allow_analog_operator(self) -> bool {
-        matches!(self, Self::AnalogBlock)
+    fn allow_analog_operator(self, allow_in_cond: bool) -> bool {
+        match self {
+            Self::AnalogBlock => true,
+            Self::Conditional if allow_in_cond => true,
+            _ => false,
+        }
     }
 
     fn allow_analysis_fun(self) -> bool {
@@ -195,6 +200,7 @@ struct BodyValidator<'a> {
     non_const_dominator: Box<[ExprId]>,
     non_trivial_branches: HashSet<BranchWrite>,
     trivial_probes: HashMap<BranchWrite, Vec<(StmtId, ExprId)>>,
+    allow_analog_in_cond: bool,
 }
 
 impl BodyValidator<'_> {
@@ -574,7 +580,7 @@ impl ExprValidator<'_, '_> {
                         non_const_dominator: sel.parent.non_const_dominator.clone(),
                     },
                     expr,
-                    self.parent.ctx.allow_analog_operator(),
+                    self.parent.ctx.allow_analog_operator(self.parent.allow_analog_in_cond),
                 )
             }
 
diff --git a/openvaf/linker/src/lib.rs b/openvaf/linker/src/lib.rs
index 7c1c1a533..332b0ad40 100644
--- a/openvaf/linker/src/lib.rs
+++ b/openvaf/linker/src/lib.rs
@@ -87,6 +87,28 @@ fn linker_with_args<'a>(
     // this environment variable too in recent versions.
     cmd.cmd().env("ZERO_AR_DATE", "1");
 
+    // When using ld64.lld on macOS, we need to add the SDK sysroot
+    if flavor == LinkerFlavor::Ld64 && target.options.is_like_osx {
+        if let Ok(llvm_prefix) = env::var("LLVM_SYS_181_PREFIX") {
+            let llvm_lld = PathBuf::from(llvm_prefix).join("bin/ld64.lld");
+            if llvm_lld.exists() {
+                // Detect SDK path using xcrun
+                if let Ok(output) =
+                    std::process::Command::new("xcrun").args(["--show-sdk-path"]).output()
+                {
+                    if output.status.success() {
+                        if let Ok(sdk_path) = String::from_utf8(output.stdout) {
+                            let sdk_path = sdk_path.trim();
+                            if !sdk_path.is_empty() {
+                                cmd.args(["-syslibroot", sdk_path]);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
     cmd.add_pre_link_args(target, flavor);
 
     add_objects(&mut *cmd);
@@ -145,6 +167,15 @@ fn get_linker<'a>(
             let path = path.unwrap_or_else(|| {
                 if is_msys2_environment() {
                     "gcc".into()
+                } else if flavor == LinkerFlavor::Ld64 {
+                    // For macOS, prefer LLVM's ld64.lld if available
+                    if let Ok(llvm_prefix) = env::var("LLVM_SYS_181_PREFIX") {
+                        let llvm_lld = PathBuf::from(llvm_prefix).join("bin/ld64.lld");
+                        if llvm_lld.exists() {
+                            return llvm_lld;
+                        }
+                    }
+                    "ld".into()
                 } else {
                     "ld".into()
                 }
diff --git a/openvaf/mir/Cargo.toml b/openvaf/mir/Cargo.toml
index 4a7d9bd84..5f066646f 100644
--- a/openvaf/mir/Cargo.toml
+++ b/openvaf/mir/Cargo.toml
@@ -16,6 +16,7 @@ list_pool = {version = "0.0.0" , path = "../../lib/list_pool"}
 typed-index-collections = "3.1"
 lasso = {version = "0.7", features = ["ahash"]}
 ahash = "0.8"
+rustc-hash = "2.0"
 bitset = {version = "0.0.0", path = "../../lib/bitset" }
 typed_indexmap = { version = "0.0.0", path = "../../lib/typed_indexmap" }
 dot = "0.1.4"
diff --git a/openvaf/mir/src/cursor.rs b/openvaf/mir/src/cursor.rs
index 1c5115e14..abf3cd956 100644
--- a/openvaf/mir/src/cursor.rs
+++ b/openvaf/mir/src/cursor.rs
@@ -559,7 +559,7 @@ impl<'f> FuncCursor<'f> {
     }
 
     /// Create an instruction builder that inserts an instruction at the current position.
-    pub fn ins(&mut self) -> InsertBuilder<&mut FuncCursor<'f>> {
+    pub fn ins(&mut self) -> InsertBuilder<'_, &mut FuncCursor<'f>> {
         InsertBuilder::new(self)
     }
 
diff --git a/openvaf/mir/src/dfg.rs b/openvaf/mir/src/dfg.rs
index 01cad5f95..7f9ccda70 100644
--- a/openvaf/mir/src/dfg.rs
+++ b/openvaf/mir/src/dfg.rs
@@ -86,7 +86,7 @@ impl DataFlowGraph {
     }
 
     /// Returns an object that displays `inst`.
-    pub fn display_inst(&self, inst: Inst) -> DisplayInst {
+    pub fn display_inst(&self, inst: Inst) -> DisplayInst<'_> {
         DisplayInst(self, inst)
     }
 
@@ -379,7 +379,7 @@ impl DataFlowGraph {
     //     self.insts.operands_mut(inst)
     // }
 
-    pub fn replace(&mut self, inst: Inst) -> ReplaceBuilder {
+    pub fn replace(&mut self, inst: Inst) -> ReplaceBuilder<'_> {
         ReplaceBuilder::new(self, inst)
     }
 }
diff --git a/openvaf/mir/src/dfg/phis.rs b/openvaf/mir/src/dfg/phis.rs
index b78b0beac..8087f573e 100644
--- a/openvaf/mir/src/dfg/phis.rs
+++ b/openvaf/mir/src/dfg/phis.rs
@@ -69,7 +69,7 @@ impl DataFlowGraph {
         }
     }
 
-    pub fn phi_edges(&self, phi: &PhiNode) -> PhiEdges {
+    pub fn phi_edges(&self, phi: &PhiNode) -> PhiEdges<'_> {
         phi.edges(&self.insts.value_lists, &self.phi_forest)
     }
 
diff --git a/openvaf/mir/src/dfg/uses.rs b/openvaf/mir/src/dfg/uses.rs
index e2a8de894..2a42b4478 100644
--- a/openvaf/mir/src/dfg/uses.rs
+++ b/openvaf/mir/src/dfg/uses.rs
@@ -243,7 +243,7 @@ impl DfgValues {
         !self.uses[use_].attached
     }
 
-    pub fn uses(&self, value: Value) -> UseIter {
+    pub fn uses(&self, value: Value) -> UseIter<'_> {
         self.uses_head_cursor(value).into_iter(self)
     }
 
@@ -319,7 +319,7 @@ impl DataFlowGraph {
         self.attach_use(use_, val);
     }
 
-    pub fn inst_uses(&self, inst: Inst) -> InstUseIter {
+    pub fn inst_uses(&self, inst: Inst) -> InstUseIter<'_> {
         let mut vals = self.inst_results(inst).iter();
         let cursor = vals.next().map(|res| self.uses_head_cursor(*res)).unwrap_or_default();
         InstUseIter { cursor, vals, dfg: &self.values }
diff --git a/openvaf/mir/src/flowgraph.rs b/openvaf/mir/src/flowgraph.rs
index a8e7ad9da..91925846e 100644
--- a/openvaf/mir/src/flowgraph.rs
+++ b/openvaf/mir/src/flowgraph.rs
@@ -374,12 +374,12 @@ impl ControlFlowGraph {
     }
 
     #[inline]
-    pub fn postorder_from(&self, start: Block) -> Postorder {
+    pub fn postorder_from(&self, start: Block) -> Postorder<'_> {
         Postorder::new(self, start)
     }
 
     #[inline]
-    pub fn postorder(&self, func: &Function) -> Postorder {
+    pub fn postorder(&self, func: &Function) -> Postorder<'_> {
         Postorder::new(self, func.layout.entry_block().unwrap())
     }
 }
diff --git a/openvaf/mir/src/instructions.rs b/openvaf/mir/src/instructions.rs
index cc30a4376..bdd509692 100644
--- a/openvaf/mir/src/instructions.rs
+++ b/openvaf/mir/src/instructions.rs
@@ -83,7 +83,7 @@ impl InstructionData {
     /// # Note
     ///
     /// It is up to the caller to ensure that uses are updates as appropriate
-    pub fn arguments_mut<'a>(&'a mut self, pool: &'a mut ValueListPool) -> &mut [Value] {
+    pub fn arguments_mut<'a>(&'a mut self, pool: &'a mut ValueListPool) -> &'a mut [Value] {
         match self {
             InstructionData::Unary { arg, .. } | InstructionData::Branch { cond: arg, .. } => {
                 core::slice::from_mut(arg)
@@ -100,7 +100,7 @@ impl InstructionData {
 
     /// Get mutable references to the value arguments to this
     /// instruction.
-    pub fn arguments<'a>(&'a self, pool: &'a ValueListPool) -> &[Value] {
+    pub fn arguments<'a>(&'a self, pool: &'a ValueListPool) -> &'a [Value] {
         match self {
             InstructionData::Unary { arg, .. } | InstructionData::Branch { cond: arg, .. } => {
                 core::slice::from_ref(arg)
diff --git a/openvaf/mir/src/layout.rs b/openvaf/mir/src/layout.rs
index 1aedb9663..4b7d65eb9 100644
--- a/openvaf/mir/src/layout.rs
+++ b/openvaf/mir/src/layout.rs
@@ -214,7 +214,7 @@ impl Layout {
     }
 
     /// Return an iterator over all blocks in layout order.
-    pub fn blocks(&self) -> Blocks {
+    pub fn blocks(&self) -> Blocks<'_> {
         Blocks { layout: self, next: self.first_block }
     }
 
@@ -458,11 +458,11 @@ impl Layout {
     }
 
     /// Iterate over the instructions in `block` in layout order.
-    pub fn block_insts(&self, block: Block) -> InstIter {
+    pub fn block_insts(&self, block: Block) -> InstIter<'_> {
         InstIter { layout: self, cursor: self.block_inst_cursor(block) }
     }
 
-    pub fn block_insts_no_term(&self, block: Block) -> InstIter {
+    pub fn block_insts_no_term(&self, block: Block) -> InstIter<'_> {
         let mut insts = self.block_insts(block);
         insts.next_back();
         insts
diff --git a/openvaf/mir/src/lib.rs b/openvaf/mir/src/lib.rs
index ecd7cb04d..101b10d12 100644
--- a/openvaf/mir/src/lib.rs
+++ b/openvaf/mir/src/lib.rs
@@ -127,7 +127,7 @@ impl Function {
         res
     }
 
-    pub fn print<'a>(&'a self, resolver: &'a dyn lasso::Resolver) -> PrintableFunction {
+    pub fn print<'a>(&'a self, resolver: &'a dyn lasso::Resolver) -> PrintableFunction<'a> {
         PrintableFunction { fun: self, resolver }
     }
 
diff --git a/openvaf/mir/src/serialize.rs b/openvaf/mir/src/serialize.rs
index 4dc09fe49..bfe158574 100644
--- a/openvaf/mir/src/serialize.rs
+++ b/openvaf/mir/src/serialize.rs
@@ -1,8 +1,9 @@
 use std::fmt::{self, Display, Write};
+use std::hash::BuildHasherDefault;
 
-use ahash::RandomState;
 use indexmap::{IndexMap, IndexSet};
 use lasso::Rodeo;
+use rustc_hash::FxHasher;
 
 use crate::{
     Block, Const, ControlFlowGraph, Function, Inst, InstructionData, Param, Value, ValueDef,
@@ -34,15 +35,15 @@ impl Function {
         mut param_name: impl FnMut(Param) -> (&'static str, String),
         outputs: impl Iterator<Item = (String, Value)>,
     ) -> String {
-        let mut inst_map = IndexSet::default();
-        let bb_map = cfg
+        let mut inst_map: IndexSet<Inst, BuildHasherDefault<FxHasher>> = IndexSet::default();
+        let bb_map: IndexSet<Block, BuildHasherDefault<FxHasher>> = cfg
             .reverse_postorder(self)
             .map(|bb| {
                 inst_map.extend(self.layout.block_insts(bb));
                 bb
             })
             .collect();
-        let mut val_map: IndexSet<Value, RandomState> = IndexSet::default();
+        let mut val_map: IndexSet<Value, BuildHasherDefault<FxHasher>> = IndexSet::default();
         for &inst in inst_map.iter() {
             if let InstructionData::PhiNode(phi) = &self.dfg.insts[inst] {
                 val_map.extend(self.dfg.phi_edges(phi).map(|(_, val)| val))
@@ -99,9 +100,9 @@ impl Function {
 struct Serializer<'a> {
     cfg: &'a ControlFlowGraph,
     func: &'a Function,
-    inst_map: &'a IndexSet<Inst, RandomState>,
-    bb_map: &'a IndexSet<Block, RandomState>,
-    val_map: &'a IndexSet<Value, RandomState>,
+    inst_map: &'a IndexSet<Inst, BuildHasherDefault<FxHasher>>,
+    bb_map: &'a IndexSet<Block, BuildHasherDefault<FxHasher>>,
+    val_map: &'a IndexSet<Value, BuildHasherDefault<FxHasher>>,
     inputs: &'a IndexMap<&'static str, Vec<(String, usize)>>,
     intern: &'a Rodeo,
     buf: String,
diff --git a/openvaf/mir_autodiff/Cargo.toml b/openvaf/mir_autodiff/Cargo.toml
index 42382dfcf..5aa8ff9fd 100644
--- a/openvaf/mir_autodiff/Cargo.toml
+++ b/openvaf/mir_autodiff/Cargo.toml
@@ -21,6 +21,7 @@ arena = { version = "0.0.0", path = "../../lib/arena" }
 indexmap = "2.0"
 typed-index-collections = "3.1"
 ahash = "0.8"
+rustc-hash = "2.0"
 
 [dev-dependencies]
 expect-test = "1.4"
diff --git a/openvaf/mir_autodiff/src/builder.rs b/openvaf/mir_autodiff/src/builder.rs
index 0d608baa5..0b4ed2fb6 100644
--- a/openvaf/mir_autodiff/src/builder.rs
+++ b/openvaf/mir_autodiff/src/builder.rs
@@ -1,3 +1,5 @@
+use std::collections::HashMap;
+use std::hash::BuildHasherDefault;
 use std::ops::Range;
 
 use ahash::AHashMap;
@@ -8,6 +10,7 @@ use mir::{
     Block, Function, Inst, InstructionData, Opcode, SourceLoc, Unknown, Value, F_LOG10_E, F_ONE,
     F_TWO, F_ZERO,
 };
+use rustc_hash::FxHasher;
 use stdx::iter::zip;
 use stdx::packed_option::{PackedOption, ReservedValue};
 
@@ -22,8 +25,8 @@ pub fn build_derivatives(
     intern: &mut DerivativeIntern,
     live_derivatives: &LiveDerivatives,
     post_order: &[Block],
-) -> AHashMap<(Value, Unknown), Value> {
-    let derivative_values: AHashMap<(Value, Unknown), Value> =
+) -> HashMap<(Value, Unknown), Value, BuildHasherDefault<FxHasher>> {
+    let derivative_values: HashMap<(Value, Unknown), Value, BuildHasherDefault<FxHasher>> =
         intern.unknowns.iter_enumerated().map(|(unknown, &val)| ((val, unknown), F_ONE)).collect();
 
     let mut known_values = BitSet::new_empty(func.dfg.num_values());
@@ -56,7 +59,7 @@ pub(crate) struct DerivativeBuilder<'a, 'u> {
     live_derivatives: &'a LiveDerivatives,
     intern: &'a mut DerivativeIntern<'u>,
 
-    derivative_values: AHashMap<(Value, Unknown), Value>,
+    derivative_values: HashMap<(Value, Unknown), Value, BuildHasherDefault<FxHasher>>,
     known_values: BitSet<Value>,
     dst: (Inst, SourceLoc),
     new_block: Option<Block>,
@@ -425,7 +428,7 @@ impl<'a, 'u> DerivativeBuilder<'a, 'u> {
             .to_owned()
     }
 
-    fn ins(&mut self) -> InsertBuilder<&mut DerivativeBuilder<'a, 'u>> {
+    fn ins(&mut self) -> InsertBuilder<'_, &mut DerivativeBuilder<'a, 'u>> {
         InsertBuilder::new(self)
     }
 
@@ -448,7 +451,7 @@ impl<'a, 'u> DerivativeBuilder<'a, 'u> {
 
     fn derivative_of_(
         intern: &DerivativeIntern,
-        derivative_values: &AHashMap<(Value, Unknown), Value>,
+        derivative_values: &HashMap<(Value, Unknown), Value, BuildHasherDefault<FxHasher>>,
         mut val: Value,
         derivative: Derivative,
     ) -> Value {
diff --git a/openvaf/mir_autodiff/src/lib.rs b/openvaf/mir_autodiff/src/lib.rs
index 1de40e026..ccd29d988 100644
--- a/openvaf/mir_autodiff/src/lib.rs
+++ b/openvaf/mir_autodiff/src/lib.rs
@@ -4,12 +4,15 @@ mod live_derivatives;
 mod postorder;
 mod subgraph;
 
-use ahash::AHashMap;
+use std::collections::HashMap;
+use std::hash::BuildHasherDefault;
+
 pub use builder::build_derivatives;
 pub use live_derivatives::LiveDerivatives;
 use mir::{
     DataFlowGraph, DominatorTree, Function, Inst, InstructionData, KnownDerivatives, Opcode, Value,
 };
+use rustc_hash::FxHasher;
 
 use crate::intern::{Derivative, DerivativeIntern};
 
@@ -18,7 +21,7 @@ pub fn auto_diff(
     dom_tree: &DominatorTree,
     derivatives: &KnownDerivatives,
     extra_derivatives: &[(Value, mir::Unknown)],
-) -> AHashMap<(Value, mir::Unknown), Value> {
+) -> HashMap<(Value, mir::Unknown), Value, BuildHasherDefault<FxHasher>> {
     let func = func.as_mut();
     let mut intern = DerivativeIntern::new(derivatives);
     let live_derivative = LiveDerivatives::build(func, &mut intern, extra_derivatives, dom_tree);
diff --git a/openvaf/mir_autodiff/src/subgraph.rs b/openvaf/mir_autodiff/src/subgraph.rs
index d94b8a47a..107b03723 100644
--- a/openvaf/mir_autodiff/src/subgraph.rs
+++ b/openvaf/mir_autodiff/src/subgraph.rs
@@ -1,8 +1,10 @@
+use std::hash::BuildHasherDefault;
 use std::mem::{replace, take};
 
 use bitset::{BitSet, HybridBitSet, SparseBitSet};
 use indexmap::IndexMap;
 use mir::{Block, DominatorTree, Function, Inst, Opcode, Unknown, Value, ValueDef};
+use rustc_hash::FxHasher;
 
 use crate::intern::{Derivative, DerivativeInfo, DerivativeIntern};
 use crate::{zero_derivative, ChainRule, LiveDerivatives};
@@ -24,7 +26,7 @@ struct SubGraphExplorer<'a, 'b> {
     saved_insts: i32,
     completed_subgraphs: Vec<HybridBitSet<Unknown>>,
 
-    derivative_map: IndexMap<Derivative, (Derivative, Derivative), ahash::RandomState>,
+    derivative_map: IndexMap<Derivative, (Derivative, Derivative), BuildHasherDefault<FxHasher>>,
 }
 
 impl<'a, 'b> SubGraphExplorer<'a, 'b> {
diff --git a/openvaf/mir_build/src/lib.rs b/openvaf/mir_build/src/lib.rs
index 7d82b3ab1..3391bcc90 100644
--- a/openvaf/mir_build/src/lib.rs
+++ b/openvaf/mir_build/src/lib.rs
@@ -471,7 +471,7 @@ impl<'a> FunctionBuilder<'a> {
     ///
     /// This can be used to insert SSA code that doesn't need to access locals and that doesn't
     /// need to know about `FunctionBuilder` at all.
-    pub fn cursor(&mut self) -> FuncCursor {
+    pub fn cursor(&mut self) -> FuncCursor<'_> {
         self.ensure_inserted_block();
         FuncCursor::new(self.func).with_srcloc(self.srcloc).at_bottom(self.position)
     }
diff --git a/openvaf/mir_interpret/src/data.rs b/openvaf/mir_interpret/src/data.rs
index 5eb626246..0c792b1fe 100644
--- a/openvaf/mir_interpret/src/data.rs
+++ b/openvaf/mir_interpret/src/data.rs
@@ -1,4 +1,4 @@
-use std::intrinsics::transmute;
+use std::mem::transmute;
 
 use lasso::Spur;
 
diff --git a/openvaf/mir_llvm/src/builder.rs b/openvaf/mir_llvm/src/builder.rs
index 6d8d3de24..27b526f43 100644
--- a/openvaf/mir_llvm/src/builder.rs
+++ b/openvaf/mir_llvm/src/builder.rs
@@ -3,10 +3,7 @@ use std::slice;
 
 use arrayvec::ArrayVec;
 use libc::c_uint;
-use llvm_sys::core::{
-    LLVMBuildExtractValue, LLVMBuildICmp, LLVMBuildLoad2, LLVMBuildStore, LLVMGetReturnType,
-    LLVMGetTypeKind, LLVMTypeOf,
-};
+use llvm_sys::core::LLVMBuildExtractValue;
 use mir::{
     Block, ControlFlowGraph, FuncRef, Function, Inst, Opcode, Param, PhiNode, Value, ValueDef,
     F_ZERO, ZERO,
diff --git a/openvaf/mir_llvm/src/intrinsics.rs b/openvaf/mir_llvm/src/intrinsics.rs
index d5cc92bb9..f04fd44af 100644
--- a/openvaf/mir_llvm/src/intrinsics.rs
+++ b/openvaf/mir_llvm/src/intrinsics.rs
@@ -97,7 +97,7 @@ impl<'a, 'll> CodegenCx<'a, 'll> {
         variadic: bool,
     ) -> (&'ll Type, &'ll Value) {
         let fn_ty =
-            if variadic { self.ty_variadic_func(&[], ret) } else { self.ty_func(args, ret) };
+            if variadic { self.ty_variadic_func(args, ret) } else { self.ty_func(args, ret) };
         let f = self.get_func_by_name(name).unwrap_or_else(|| self.declare_ext_fn(name, fn_ty));
         self.intrinsics.borrow_mut().insert(name, (fn_ty, f));
         (fn_ty, f)
diff --git a/openvaf/mir_opt/Cargo.toml b/openvaf/mir_opt/Cargo.toml
index 53c21086e..64f9fb59c 100644
--- a/openvaf/mir_opt/Cargo.toml
+++ b/openvaf/mir_opt/Cargo.toml
@@ -17,8 +17,8 @@ workqueue = {version = "0.0.0", path = "../../lib/workqueue" }
 bitset = {version = "0.0.0", path = "../../lib/bitset" }
 
 typed-index-collections = "3.1"
-ahash = "0.8"
 hashbrown = {version = "0.14", features = ["raw"]}
+rustc-hash = "2.1"
 
 [dev-dependencies]
 expect-test = "1.4"
diff --git a/openvaf/mir_opt/src/global_value_numbering.rs b/openvaf/mir_opt/src/global_value_numbering.rs
index f96fd9e85..e036c8bf6 100644
--- a/openvaf/mir_opt/src/global_value_numbering.rs
+++ b/openvaf/mir_opt/src/global_value_numbering.rs
@@ -1,15 +1,15 @@
 use std::cmp::Ordering;
-use std::hash::{BuildHasher, Hash, Hasher};
+use std::hash::{BuildHasher, BuildHasherDefault, Hash, Hasher};
 use std::mem::{swap, ManuallyDrop};
 use std::ops::{Index, IndexMut};
 
-use ahash::RandomState;
 use bitset::{BitSet, HybridBitSet};
 use hashbrown::raw::RawTable;
 use mir::{
     Block, DominatorTree, FuncRef, Function, Inst, InstructionData, Opcode, Value, ValueDef,
     ValueList,
 };
+use rustc_hash::FxHasher;
 use stdx::packed_option::PackedOption;
 use stdx::{impl_idx_from, impl_idx_math};
 use typed_index_collections::TiVec;
@@ -188,7 +188,7 @@ impl GVNExpression {
         }
     }
 
-    fn hash(&self, state: &RandomState, func: &Function) -> u64 {
+    fn hash(&self, state: &BuildHasherDefault<FxHasher>, func: &Function) -> u64 {
         let mut hasher = state.build_hasher();
         self.opcode.hash(&mut hasher);
         match self.opcode {
@@ -354,7 +354,7 @@ struct ClassMap {
     inst_class: TiVec<Inst, PackedOption<ClassId>>,
     expr_class: RawTable<ClassId>,
     classes: TiVec<ClassId, EquivalenceClass>,
-    state: RandomState,
+    state: BuildHasherDefault<FxHasher>,
 }
 
 impl ClassMap {
@@ -465,7 +465,7 @@ impl GVN {
     fn simplify_ctx<'a>(
         &'a mut self,
         func: &'a mut Function,
-    ) -> SimplifyCtx<f64, impl Fn(Value, &Function) -> Value + 'a> {
+    ) -> SimplifyCtx<'a, f64, impl Fn(Value, &Function) -> Value + 'a> {
         SimplifyCtx::new(func, |val, func| self.class_map.get_lead_val(val, func))
     }
 
diff --git a/openvaf/openvaf-driver/Cargo.toml b/openvaf/openvaf-driver/Cargo.toml
index c5a2ea9d6..efcec9396 100644
--- a/openvaf/openvaf-driver/Cargo.toml
+++ b/openvaf/openvaf-driver/Cargo.toml
@@ -5,6 +5,9 @@ authors = ["DSPOM"]
 edition = "2021"
 license = "GPL-3.0"
 
+[lints.rust]
+unexpected_cfgs = { level = "warn", check-cfg = ['cfg(feature, values("nightly"))'] }
+
 [[bin]]
 name = "openvaf-r"
 path = "src/main.rs"
diff --git a/openvaf/openvaf-driver/src/cli_def.rs b/openvaf/openvaf-driver/src/cli_def.rs
index 2547e79b7..e8122dbb7 100644
--- a/openvaf/openvaf-driver/src/cli_def.rs
+++ b/openvaf/openvaf-driver/src/cli_def.rs
@@ -39,6 +39,7 @@ pub fn main_command() -> Command {
             interface(),
             expand(),
             dump_json(),
+            allow_analog_in_cond(),
             input(),
         ])
         .subcommand_required(false)
@@ -68,6 +69,7 @@ pub const DUMP_JSON: &str = "dump-json";
 pub const ALLOW: &str = "allow";
 pub const WARN: &str = "warn";
 pub const DENY: &str = "deny";
+pub const ALLOW_ANALOG_IN_COND: &str = "allow-analog-in-cond";
 
 fn interface() -> Arg {
     Arg::new(INTERFACE)
@@ -303,6 +305,18 @@ fn dump_json() -> Arg {
     flag(DUMP_JSON, "dump-json").help("Abort after lowering and serialize MIR as json.")
 }
 
+fn allow_analog_in_cond() -> Arg {
+    flag(ALLOW_ANALOG_IN_COND, ALLOW_ANALOG_IN_COND)
+        .help("Allow analog operators in signal-dependent conditionals.")
+        .long_help(
+            "Allow analog operators (like limexp, ddt, idt) in signal-dependent conditional bodies.
+
+This is non-standard behavior but required by some commercial foundry models (e.g., GF130 PDK).
+
+By default, OpenVAF enforces strict Verilog-A semantics which only allow analog operators in unconditional code.",
+        )
+}
+
 fn def_arg() -> Arg {
     Arg::new(DEFINE)
         .short('D')
diff --git a/openvaf/openvaf-driver/src/cli_process.rs b/openvaf/openvaf-driver/src/cli_process.rs
index b617b3fae..562d01215 100644
--- a/openvaf/openvaf-driver/src/cli_process.rs
+++ b/openvaf/openvaf-driver/src/cli_process.rs
@@ -5,14 +5,15 @@ use anyhow::{bail, Context, Result};
 use camino::Utf8PathBuf;
 use clap::ArgMatches;
 use openvaf::{
-    builtin_lints, get_target_names, host_triple, AbsPathBuf, LLVMCodeGenOptLevel, LintLevel,
+    builtin_lints, get_target_names, host_triple, AbsPathBuf, CompilationOpts, LLVMCodeGenOptLevel,
+    LintLevel,
 };
 use termcolor::{Color, ColorChoice, ColorSpec, WriteColor};
 
 use crate::cli_def::{
-    ALLOW, BATCHMODE, CACHE_DIR, CODEGEN, DEFINE, DENY, DRYRUN, DUMPIR, DUMPMIR, DUMPUNOPTIR,
-    DUMPUNOPTMIR, INCLUDE, INPUT, LINTS, OPT_LVL, OUTPUT, SUPPORTED_TARGETS, TARGET, TARGET_CPU,
-    WARN,
+    ALLOW, ALLOW_ANALOG_IN_COND, BATCHMODE, CACHE_DIR, CODEGEN, DEFINE, DENY, DRYRUN, DUMPIR,
+    DUMPMIR, DUMPUNOPTIR, DUMPUNOPTMIR, INCLUDE, INPUT, LINTS, OPT_LVL, OUTPUT, SUPPORTED_TARGETS,
+    TARGET, TARGET_CPU, WARN,
 };
 use crate::{CompilationDestination, Opts};
 
@@ -122,6 +123,9 @@ pub fn matches_to_opts(matches: ArgMatches) -> Result<Opts> {
         dump_ir: matches.get_flag(DUMPIR),
         dump_unopt_ir: matches.get_flag(DUMPUNOPTIR),
         dry_run: matches.get_flag(DRYRUN),
+        compilation_opts: CompilationOpts {
+            allow_analog_in_cond: matches.get_flag(ALLOW_ANALOG_IN_COND),
+        },
     })
 }
 
diff --git a/openvaf/openvaf/src/lib.rs b/openvaf/openvaf/src/lib.rs
index bc889f38f..484dfedf2 100644
--- a/openvaf/openvaf/src/lib.rs
+++ b/openvaf/openvaf/src/lib.rs
@@ -8,6 +8,7 @@ pub use basedb::lints::{builtin as builtin_lints, LintLevel};
 use basedb::BaseDB;
 use camino::Utf8PathBuf;
 use hir::CompilationDB;
+pub use hir::CompilationOpts;
 use linker::link;
 pub use llvm_sys::target_machine::LLVMCodeGenOptLevel;
 use mir_llvm::LLVMBackend;
@@ -46,6 +47,7 @@ pub struct Opts {
     pub dump_unopt_mir: bool,
     pub dump_ir: bool,
     pub dump_unopt_ir: bool,
+    pub compilation_opts: CompilationOpts,
 }
 // pub fn dump_json(opts: &Opts) -> Result<CompilationTermination> {
 //     let input =
@@ -111,7 +113,13 @@ pub fn expand(opts: &Opts) -> Result<CompilationTermination> {
     let input =
         opts.input.canonicalize().with_context(|| format!("failed to resolve {}", opts.input))?;
     let input = AbsPathBuf::assert(input);
-    let db = CompilationDB::new_fs(input, &opts.include, &opts.defines, &opts.lints)?;
+    let db = CompilationDB::new_fs(
+        input,
+        &opts.include,
+        &opts.defines,
+        &opts.lints,
+        &opts.compilation_opts,
+    )?;
     let cu = db.compilation_unit();
 
     let preprocess = cu.preprocess(&db);
@@ -159,7 +167,13 @@ pub fn compile(opts: &Opts) -> Result<CompilationTermination> {
     let input =
         opts.input.canonicalize().with_context(|| format!("failed to resolve {}", opts.input))?;
     let input = AbsPathBuf::assert(input);
-    let db = CompilationDB::new_fs(input, &opts.include, &opts.defines, &opts.lints)?;
+    let db = CompilationDB::new_fs(
+        input,
+        &opts.include,
+        &opts.defines,
+        &opts.lints,
+        &opts.compilation_opts,
+    )?;
 
     let lib_file = match &opts.output {
         CompilationDestination::Cache { cache_dir } => {
diff --git a/openvaf/openvaf/tests/integration.rs b/openvaf/openvaf/tests/integration.rs
index 6298bf782..881273916 100644
--- a/openvaf/openvaf/tests/integration.rs
+++ b/openvaf/openvaf/tests/integration.rs
@@ -35,6 +35,7 @@ fn compile_and_load(root_file: &Utf8Path) -> &'static OsdiDescriptor {
         dump_unopt_mir: false,
         dump_ir: false,
         dump_unopt_ir: false,
+        compilation_opts: hir::CompilationOpts::default(),
     };
 
     let res = openvaf::compile(&openvaf_opts).unwrap();
diff --git a/openvaf/openvaf/tests/load/mod.rs b/openvaf/openvaf/tests/load/mod.rs
index beb398b3b..db519f78e 100644
--- a/openvaf/openvaf/tests/load/mod.rs
+++ b/openvaf/openvaf/tests/load/mod.rs
@@ -452,24 +452,19 @@ impl Debug for OsdiDescriptor {
                     osdi_str(node.units),
                     osdi_str(node.residual_units)
                 );
-                wn!(
-                    "residual {} {} {} {}",
-                    node.resist_residual_off,
-                    node.react_residual_off,
-                    node.resist_limit_rhs_off,
-                    node.react_limit_rhs_off
-                );
+                // Residual offsets are arch-specific (depend on struct alignment)
+                // so we omit them from snapshots to allow cross-platform testing
             }
             for matrix_entry in self.matrix_entries() {
                 let hi = self.nodes()[matrix_entry.nodes.node_1 as usize].name;
                 let lo = self.nodes()[matrix_entry.nodes.node_2 as usize].name;
                 wn!(
-                    "jacobian ({}, {}) {:?} react_ptr = {}",
+                    "jacobian ({}, {}) {:?}",
                     osdi_str(hi),
                     osdi_str(lo),
                     JacobianFlags::from_bits(matrix_entry.flags).unwrap(),
-                    matrix_entry.react_ptr_off,
                 );
+                // react_ptr offset is arch-specific, omitted for cross-platform testing
             }
             for OsdiNodePair { node_1, node_2 } in self.collapsible() {
                 let hi = self.nodes()[*node_1 as usize].name;
@@ -491,8 +486,8 @@ impl Debug for OsdiDescriptor {
             }
             wn!("{} states", self.num_states);
             wn!("has bound_step {}", self.bound_step_offset != u32::MAX);
-            wn!("instance size {}", self.instance_size);
-            wn!("model size {}", self.model_size);
+            // instance_size and model_size are arch-specific (depend on struct alignment)
+            // so we omit them from snapshots to allow cross-platform testing
             Ok(())
         }
     }
diff --git a/openvaf/osdi/Cargo.toml b/openvaf/osdi/Cargo.toml
index 8e59d3b8c..4b186a079 100644
--- a/openvaf/osdi/Cargo.toml
+++ b/openvaf/osdi/Cargo.toml
@@ -28,7 +28,7 @@ llvm-sys = "181.1.1"
 target = { version = "0.0.0", path = "../target"}
 
 typed-index-collections = "3.1"
-ahash = "0.8"
+rustc-hash = "2.0"
 lasso = {version = "0.7", features = ["ahash"]}
 
 salsa = "0.17.0-pre.2"
diff --git a/openvaf/osdi/build.rs b/openvaf/osdi/build.rs
index 0c609a5e9..487594a5a 100644
--- a/openvaf/osdi/build.rs
+++ b/openvaf/osdi/build.rs
@@ -22,6 +22,13 @@ fn main() {
     let osdi_dir = stdx::project_root().join("openvaf").join("osdi");
     let src_file = osdi_dir.join("stdlib.c");
 
+    // Use clang from LLVM_SYS_181_PREFIX if available
+    let clang_path = tracked_env_var_os("LLVM_SYS_181_PREFIX")
+        .map(|prefix| Path::new(&prefix).join("bin/clang"))
+        .and_then(|path| path.exists().then_some(path))
+        .map(|path| path.display().to_string())
+        .unwrap_or_else(|| "clang".to_string());
+
     sh.change_dir(osdi_dir);
     for file in sh.read_dir("header").unwrap() {
         if file.extension().map_or(true, |ext| ext != "h")
@@ -47,7 +54,7 @@ fn main() {
             } else {
                 println!("cargo:rerun-if-changed={}", file.display());
 
-                let mut cmd = cmd!(sh, "clang -emit-llvm -O3 -D{def_name} -DNO_STD -o {out_file} -c {src_file} -target {target_name}");
+                let mut cmd = cmd!(sh, "{clang_path} -emit-llvm -O3 -D{def_name} -DNO_STD -o {out_file} -c {src_file} -target {target_name}");
                 if !target.options.is_like_windows {
                     cmd = cmd.arg("-fPIC");
                 }
diff --git a/openvaf/osdi/src/compilation_unit.rs b/openvaf/osdi/src/compilation_unit.rs
index ce4c5d14a..28f0fa134 100644
--- a/openvaf/osdi/src/compilation_unit.rs
+++ b/openvaf/osdi/src/compilation_unit.rs
@@ -449,10 +449,6 @@ fn print_callback<'ll>(
                 FmtArgKind::Other => args.push(&*val),
             }
         }
-        args.extend(
-            (1..(2 + arg_tys.len()))
-                .map(|arg| &*LLVMGetParam(NonNull::from(fun).as_ptr(), arg as u32)),
-        );
         let (fun_ty, fun) = cx.intrinsic("snprintf").unwrap();
         // Convert Vec<&LLVMValue> to Vec<*mut LLVMValue>
         let mut raw_args: Vec<*mut LLVMValue> =
diff --git a/openvaf/osdi/src/eval.rs b/openvaf/osdi/src/eval.rs
index c834026d8..18a60ce92 100644
--- a/openvaf/osdi/src/eval.rs
+++ b/openvaf/osdi/src/eval.rs
@@ -9,9 +9,7 @@ use llvm_sys::core::{
 };
 use llvm_sys::LLVMIntPredicate::{LLVMIntNE, LLVMIntULT};
 use log::info;
-use mir_llvm::{
-    Builder, BuilderVal, BuiltCallbackFun, CallbackFun, InlineCallbackBuilder, MemLoc, UNNAMED,
-};
+use mir_llvm::{Builder, BuilderVal, BuiltCallbackFun, CallbackFun, MemLoc, UNNAMED};
 use sim_back::SimUnknownKind;
 use typed_index_collections::TiVec;
 
diff --git a/openvaf/osdi/src/inst_data.rs b/openvaf/osdi/src/inst_data.rs
index 189aa857a..b8fd1db3e 100644
--- a/openvaf/osdi/src/inst_data.rs
+++ b/openvaf/osdi/src/inst_data.rs
@@ -1,7 +1,7 @@
 use core::ffi::c_uint;
 use core::ptr::NonNull;
+use std::hash::BuildHasherDefault;
 
-use ahash::RandomState;
 use hir::{CompilationDB, ParamSysFun, Parameter, Variable};
 use hir_lower::{HirInterner, LimitState, ParamKind, PlaceKind};
 use indexmap::IndexMap;
@@ -21,6 +21,7 @@ use llvm_sys::target::{LLVMOffsetOfElement, LLVMTargetDataRef};
 use llvm_sys::LLVMIntPredicate;
 use mir::{strip_optbarrier, Const, Function, Param, ValueDef, F_ZERO};
 use mir_llvm::{CodegenCx, MemLoc, UNNAMED};
+use rustc_hash::FxHasher;
 use sim_back::dae::{self, MatrixEntryId, SimUnknown};
 use sim_back::init::CacheSlot;
 use stdx::packed_option::PackedOption;
@@ -212,13 +213,13 @@ pub struct OsdiInstanceData<'ll> {
     pub collapsed: &'ll llvm_sys::LLVMType,
 
     // llvm types for dynamic instance data struct fields
-    pub params: IndexMap<OsdiInstanceParam, &'ll llvm_sys::LLVMType, RandomState>,
+    pub params: IndexMap<OsdiInstanceParam, &'ll llvm_sys::LLVMType, BuildHasherDefault<FxHasher>>,
     pub eval_outputs: TiMap<EvalOutputSlot, mir::Value, &'ll llvm_sys::LLVMType>,
     pub cache_slots: TiVec<CacheSlot, &'ll llvm_sys::LLVMType>,
 
     pub residual: TiVec<SimUnknown, Residual>,
     pub noise: Vec<NoiseSource>,
-    pub opvars: IndexMap<Variable, EvalOutput, RandomState>,
+    pub opvars: IndexMap<Variable, EvalOutput, BuildHasherDefault<FxHasher>>,
     pub jacobian: TiVec<MatrixEntryId, MatrixEntry>,
     pub bound_step: Option<EvalOutputSlot>,
 }
@@ -244,21 +245,17 @@ impl<'ll> OsdiInstanceData<'ll> {
         let user_inst_params = module.info.params.iter().filter_map(|(param, info)| {
             info.is_instance.then(|| (OsdiInstanceParam::User(*param), lltype(&param.ty(db), cx)))
         });
-        let params: IndexMap<_, _, _> =
-            builtin_inst_params.chain(alias_inst_params).chain(user_inst_params).collect();
+        let mut params = IndexMap::with_hasher(BuildHasherDefault::<FxHasher>::default());
+        params.extend(builtin_inst_params.chain(alias_inst_params).chain(user_inst_params));
 
         let mut eval_outputs = TiMap::default();
-        let opvars = module
-            .info
-            .op_vars
-            .keys()
-            .map(|var| {
-                let val = module.intern.outputs[&PlaceKind::Var(*var)].unwrap_unchecked();
-                let ty = lltype(&var.ty(db), cx);
-                let pos = EvalOutput::new(module, val, &mut eval_outputs, true, ty);
-                (*var, pos)
-            })
-            .collect();
+        let mut opvars = IndexMap::with_hasher(BuildHasherDefault::<FxHasher>::default());
+        opvars.extend(module.info.op_vars.keys().map(|var| {
+            let val = module.intern.outputs[&PlaceKind::Var(*var)].unwrap_unchecked();
+            let ty = lltype(&var.ty(db), cx);
+            let pos = EvalOutput::new(module, val, &mut eval_outputs, true, ty);
+            (*var, pos)
+        }));
         let residual = module
             .dae_system
             .residual
diff --git a/openvaf/osdi/src/lib.rs b/openvaf/osdi/src/lib.rs
index 970d2ac6c..73e6a77a8 100644
--- a/openvaf/osdi/src/lib.rs
+++ b/openvaf/osdi/src/lib.rs
@@ -1,12 +1,14 @@
 use std::collections::HashMap;
 use std::ffi::CString;
+use std::hash::BuildHasherDefault;
 use std::ptr::NonNull;
 use std::sync::{Arc, Mutex};
 
+use rustc_hash::FxHasher;
+
 use base_n::CASE_INSENSITIVE;
 use camino::{Utf8Path, Utf8PathBuf};
 use hir::{CompilationDB, ParamSysFun, Type};
-use hir_def::db::HirDefDB;
 use hir_lower::{CallBackKind, HirInterner, ParamKind};
 use lasso::Rodeo;
 use llvm_sys::target::{LLVMABISizeOfType, LLVMDisposeTargetData};
@@ -115,8 +117,9 @@ pub fn compile<'a>(
 
     let main_file = dst.with_extension("o");
 
-    let unoptirs = Arc::new(Mutex::new(HashMap::new()));
-    let irs = Arc::new(Mutex::new(HashMap::new()));
+    let unoptirs =
+        Arc::new(Mutex::new(HashMap::with_hasher(BuildHasherDefault::<FxHasher>::default())));
+    let irs = Arc::new(Mutex::new(HashMap::with_hasher(BuildHasherDefault::<FxHasher>::default())));
 
     // Build natures, disciplines, and attributes vectors, intern strings in Rodeo
     let (natures_vec, disciplines_vec, attributes_vec) = nda_arrays(&*db, &mut literals);
diff --git a/openvaf/osdi/src/metadata.rs b/openvaf/osdi/src/metadata.rs
index ed5ce88e4..9ad66e9d8 100644
--- a/openvaf/osdi/src/metadata.rs
+++ b/openvaf/osdi/src/metadata.rs
@@ -3,7 +3,6 @@ use std::iter::once;
 
 use hir::{CompilationDB, ParamSysFun, Type};
 use hir_def::db::HirDefDB;
-use hir_def::ndatable::NDATable;
 use hir_lower::CurrentKind;
 use lasso::{Rodeo, Spur};
 use llvm_sys::core::{
@@ -112,7 +111,6 @@ impl osdi_0_4::OsdiAttributeValue {
                     // Fill initializer array
                     elems[0] = entry;
                 }
-                _ => panic!("Unknown attribute value union member type."),
             }
             // Construct array
             &*LLVMConstArray2(elem_ty, elems.as_mut_ptr(), len)
diff --git a/openvaf/osdi/src/model_data.rs b/openvaf/osdi/src/model_data.rs
index 0d2bc2f09..6b9b199ba 100644
--- a/openvaf/osdi/src/model_data.rs
+++ b/openvaf/osdi/src/model_data.rs
@@ -1,11 +1,12 @@
 use core::ptr::NonNull;
+use std::hash::BuildHasherDefault;
 
-use ahash::RandomState;
 use hir::{CompilationDB, Parameter};
 use indexmap::IndexMap;
 use llvm_sys::core::{LLVMBuildLoad2, LLVMBuildStore, LLVMBuildStructGEP2};
 use llvm_sys::LLVMValue as Value;
 use mir_llvm::{CodegenCx, MemLoc, UNNAMED};
+use rustc_hash::FxHasher;
 
 use crate::compilation_unit::OsdiModule;
 use crate::inst_data::{OsdiInstanceData, OsdiInstanceParam};
@@ -15,7 +16,7 @@ const NUM_CONST_FIELDS: u32 = 1;
 
 pub struct OsdiModelData<'ll> {
     pub param_given: &'ll llvm_sys::LLVMType,
-    pub params: IndexMap<Parameter, &'ll llvm_sys::LLVMType, RandomState>,
+    pub params: IndexMap<Parameter, &'ll llvm_sys::LLVMType, BuildHasherDefault<FxHasher>>,
     pub ty: &'ll llvm_sys::LLVMType,
 }
 
@@ -27,18 +28,14 @@ impl<'ll> OsdiModelData<'ll> {
         inst_data: &OsdiInstanceData<'ll>,
     ) -> Self {
         let inst_params = &inst_data.params;
-        let params: IndexMap<_, _, _> = cgunit
-            .info
-            .params
-            .keys()
-            .filter_map(|param| {
-                if inst_params.contains_key(&OsdiInstanceParam::User(*param)) {
-                    None
-                } else {
-                    Some((*param, lltype(&param.ty(db), cx)))
-                }
-            })
-            .collect();
+        let mut params = IndexMap::with_hasher(BuildHasherDefault::<FxHasher>::default());
+        params.extend(cgunit.info.params.keys().filter_map(|param| {
+            if inst_params.contains_key(&OsdiInstanceParam::User(*param)) {
+                None
+            } else {
+                Some((*param, lltype(&param.ty(db), cx)))
+            }
+        }));
 
         let param_given = bitfield::arr_ty((inst_params.len() + params.len()) as u32, cx);
 
diff --git a/openvaf/osdi/src/setup.rs b/openvaf/osdi/src/setup.rs
index fee4a5732..b6e525c97 100644
--- a/openvaf/osdi/src/setup.rs
+++ b/openvaf/osdi/src/setup.rs
@@ -7,78 +7,12 @@ use llvm_sys::core::{
 };
 use llvm_sys::LLVMIntPredicate::LLVMIntSLT;
 use mir::ControlFlowGraph;
-use mir_llvm::{
-    Builder, BuilderVal, BuiltCallbackFun, CallbackFun, CodegenCx, InlineCallbackBuilder, UNNAMED,
-};
+use mir_llvm::{Builder, BuilderVal, BuiltCallbackFun, CallbackFun, CodegenCx, UNNAMED};
 use sim_back::SimUnknownKind;
 
 use crate::compilation_unit::{general_callbacks, OsdiCompilationUnit};
 use crate::inst_data::OsdiInstanceParam;
 
-struct VoidAbortCallback;
-
-impl<'ll> InlineCallbackBuilder<'ll> for VoidAbortCallback {
-    fn build_inline(
-        &self,
-        builder: &Builder<'_, '_, 'll>, // Keep as &Builder (immutable reference)
-        state: &Box<[&'ll llvm_sys::LLVMValue]>,
-    ) -> &'ll llvm_sys::LLVMValue {
-        let cx = builder.cx; // cx is immutable and safe to access
-        unsafe {
-            // Cast &Builder to *mut Builder to allow field access
-            let builder_ptr = builder as *const Builder<'_, '_, 'll> as *mut Builder<'_, '_, 'll>;
-
-            // Access llbuilder field and cast to *mut LLVMBuilder
-            let llbuilder = (*builder_ptr).llbuilder as *mut llvm_sys::LLVMBuilder;
-
-            // state[0] .. ret_flags value
-            // state[1] .. pointer where to store it at exit
-            // state[2] .. llfunc prototype
-
-            // Store ret_flags in flags field
-            let ret_flags = builder.load(cx.ty_int(), state[0]);
-            builder.store(state[1], ret_flags);
-
-            // Create return and continue blocks
-            let ret_block = LLVMAppendBasicBlockInContext(
-                NonNull::from(cx.llcx).as_ptr(),
-                NonNull::from(state[2]).as_ptr(),
-                UNNAMED,
-            );
-            let cont_block = LLVMAppendBasicBlockInContext(
-                NonNull::from(cx.llcx).as_ptr(),
-                NonNull::from(state[2]).as_ptr(),
-                UNNAMED,
-            );
-
-            // Branch always to return block
-            let cond = cx.const_bool(true);
-            LLVMBuildCondBr(
-                llbuilder, // Use the raw pointer directly
-                NonNull::from(cond).as_ptr(),
-                ret_block,
-                cont_block,
-            );
-
-            // Add ret_void to return block
-            LLVMPositionBuilderAtEnd(llbuilder, ret_block);
-            LLVMBuildRetVoid(llbuilder); // Use raw LLVM function instead of builder.ret_void()
-
-            // Position builder at start of continue block (will be discarded after optimization)
-            LLVMPositionBuilderAtEnd(llbuilder, cont_block);
-        }
-        cx.const_int(0)
-    }
-
-    fn return_type(
-        &self,
-        builder: &Builder<'_, '_, 'll>,
-        _state: &Box<[&'ll llvm_sys::LLVMValue]>,
-    ) -> &'ll llvm_sys::LLVMType {
-        builder.cx.ty_int()
-    }
-}
-
 impl<'ll> OsdiCompilationUnit<'_, '_, 'll> {
     fn mark_collapsed(&self) -> (&'ll llvm_sys::LLVMValue, &'ll llvm_sys::LLVMType) {
         let OsdiCompilationUnit { inst_data, cx, .. } = self;
diff --git a/openvaf/osdi/tests/data_tests.rs b/openvaf/osdi/tests/data_tests.rs
index fcf8ed744..243fbc761 100644
--- a/openvaf/osdi/tests/data_tests.rs
+++ b/openvaf/osdi/tests/data_tests.rs
@@ -2,7 +2,7 @@ use std::path::Path;
 
 use camino::Utf8Path;
 use hir::diagnostics::ConsoleSink;
-use hir::CompilationDB;
+use hir::{CompilationDB, CompilationOpts};
 use llvm_sys::target_machine::LLVMCodeGenOptLevel;
 use mini_harness::{harness, Result};
 use mir_llvm::LLVMBackend;
@@ -13,7 +13,7 @@ use target::spec::Target;
 
 fn test_compile(root_file: &Path) {
     let root_file = AbsPathBuf::assert(root_file.canonicalize().unwrap());
-    let db = CompilationDB::new_fs(root_file, &[], &[], &[]).unwrap();
+    let db = CompilationDB::new_fs(root_file, &[], &[], &[], &CompilationOpts::default()).unwrap();
     let modules = collect_modules(&db, false, &mut ConsoleSink::new(&db)).unwrap();
     let target = Target::host_target().expect(
         "Failed to determine host target. This architecture may not be supported by OpenVAF. \
diff --git a/openvaf/parser/src/grammar/items/module.rs b/openvaf/parser/src/grammar/items/module.rs
index 3ca4e2304..3483a5227 100644
--- a/openvaf/parser/src/grammar/items/module.rs
+++ b/openvaf/parser/src/grammar/items/module.rs
@@ -120,7 +120,15 @@ fn module_items(p: &mut Parser) {
                 net_decl::<true>(p, m);
             }
             IDENT => {
-                net_decl::<false>(p, m);
+                // Distinguish between net declaration and module instantiation:
+                // Net declaration: `discipline name, name2;` - IDENT followed by IDENT, comma, or semicolon
+                // Module instantiation: `module_name #(params) inst_name (ports);` or `module_name inst_name (ports);`
+                // Key distinction: module inst has IDENT followed by #( or IDENT followed by IDENT then (
+                if p.nth(1) == POUND || (p.nth(1) == IDENT && p.nth(2) == L_PAREN) {
+                    module_inst(p, m);
+                } else {
+                    net_decl::<false>(p, m);
+                }
             }
             PARAMETER_KW | LOCALPARAM_KW => {
                 parameter_decl(p, m);
@@ -232,3 +240,89 @@ fn branch_decl(p: &mut Parser, m: Marker) {
     p.eat(T![;]);
     m.complete(p, BRANCH_DECL);
 }
+
+/// Parse module instantiation: `module_name #(.param(value), ...) instance_name (port1, port2, ...);`
+/// Example: `resistor #(.r(rwire)) r1 (d, de0);`
+fn module_inst(p: &mut Parser, m: Marker) {
+    // Module name (the type being instantiated)
+    name_ref_r(p, TokenSet::new(&[POUND, IDENT]));
+
+    // Optional parameter assignments: #(.param(value), ...)
+    if p.at(POUND) {
+        param_assignments(p);
+    }
+
+    // Instance name
+    name_r(p, TokenSet::new(&[T!['('], T![;]]));
+
+    // Port connections: (port1, port2, ...) or (.port(connection), ...)
+    if p.at(T!['(']) {
+        port_connections(p);
+    } else {
+        p.error(p.unexpected_token_msg(T!['(']));
+    }
+
+    p.eat(T![;]);
+    m.complete(p, MODULE_INST);
+}
+
+/// Parse parameter assignments: #(.param(value), ...)
+fn param_assignments(p: &mut Parser) {
+    let m = p.start();
+    p.bump(POUND);
+    p.expect(T!['(']);
+
+    if !p.at(T![')']) {
+        param_assignment(p);
+        while p.eat(T![,]) {
+            param_assignment(p);
+        }
+    }
+
+    p.expect(T![')']);
+    m.complete(p, PARAM_ASSIGNMENTS);
+}
+
+/// Parse a single parameter assignment: .param(value)
+fn param_assignment(p: &mut Parser) {
+    let m = p.start();
+    p.expect(T![.]);
+    name_r(p, TokenSet::new(&[T!['(']]));
+    p.expect(T!['(']);
+    expr(p);
+    p.expect(T![')']);
+    m.complete(p, PARAM_ASSIGNMENT);
+}
+
+/// Parse port connections: (expr, expr, ...) or (.port(expr), ...)
+fn port_connections(p: &mut Parser) {
+    let m = p.start();
+    p.bump(T!['(']);
+
+    if !p.at(T![')']) {
+        port_connection(p);
+        while p.eat(T![,]) {
+            port_connection(p);
+        }
+    }
+
+    p.expect(T![')']);
+    m.complete(p, PORT_CONNECTIONS);
+}
+
+/// Parse a single port connection: either positional (expr) or named (.port(expr))
+fn port_connection(p: &mut Parser) {
+    let m = p.start();
+    if p.at(T![.]) {
+        // Named port connection: .port(expr)
+        p.bump(T![.]);
+        name_r(p, TokenSet::new(&[T!['(']]));
+        p.expect(T!['(']);
+        expr(p);
+        p.expect(T![')']);
+    } else {
+        // Positional port connection: just an expression (usually a name)
+        expr(p);
+    }
+    m.complete(p, PORT_CONNECTION);
+}
diff --git a/openvaf/sim_back/Cargo.toml b/openvaf/sim_back/Cargo.toml
index 31fc5282f..ec2fda79d 100644
--- a/openvaf/sim_back/Cargo.toml
+++ b/openvaf/sim_back/Cargo.toml
@@ -24,6 +24,7 @@ mir_opt = { version = "0.0.0", path = "../mir_opt" }
 
 typed-index-collections = "3.1"
 ahash = "0.8"
+rustc-hash = "2.0"
 lasso = {version = "0.7", features = ["ahash"]}
 
 indexmap = "2.0"
diff --git a/openvaf/sim_back/src/context.rs b/openvaf/sim_back/src/context.rs
index e0d78d2a7..896901c12 100644
--- a/openvaf/sim_back/src/context.rs
+++ b/openvaf/sim_back/src/context.rs
@@ -117,7 +117,9 @@ impl<'a> Context<'a> {
                 if matches!(kind, PlaceKind::Var(var) if self.module.op_vars.contains_key(var))
                     || matches!(kind, PlaceKind::CollapseImplicitEquation(_) | PlaceKind::BoundStep)
                 {
-                    self.output_values.insert(val.unwrap_unchecked());
+                    if let Some(val) = val.expand() {
+                        self.output_values.insert(val);
+                    }
                 }
             }
         }
diff --git a/openvaf/sim_back/src/dae.rs b/openvaf/sim_back/src/dae.rs
index 57b4c7be0..2e22fd502 100644
--- a/openvaf/sim_back/src/dae.rs
+++ b/openvaf/sim_back/src/dae.rs
@@ -1,5 +1,8 @@
+use std::hash::BuildHasherDefault;
+
 use indexmap::IndexSet;
 use mir::{strip_optbarrier, Value, F_ZERO};
+use rustc_hash::FxHasher;
 use stdx::{impl_debug_display, impl_idx_from};
 use typed_index_collections::TiVec;
 use typed_indexmap::TiSet;
@@ -40,7 +43,7 @@ pub struct DaeSystem {
     pub jacobian: TiVec<MatrixEntryId, MatrixEntry>,
     /// list of parameter which are known to be small signal values (always zero during
     /// large signal simulation).
-    pub small_signal_parameters: IndexSet<Value, ahash::RandomState>,
+    pub small_signal_parameters: IndexSet<Value, BuildHasherDefault<FxHasher>>,
     /// noise
     pub noise_sources: Vec<NoiseSource>,
     /// model inputs (node pairs)
diff --git a/openvaf/sim_back/src/dae/builder.rs b/openvaf/sim_back/src/dae/builder.rs
index 2fa47016b..3c6b6d4b6 100644
--- a/openvaf/sim_back/src/dae/builder.rs
+++ b/openvaf/sim_back/src/dae/builder.rs
@@ -1,7 +1,3 @@
-use std::mem::replace;
-use std::vec;
-
-use ahash::AHashMap;
 use bitset::BitSet;
 use hir::{BranchWrite, CompilationDB, Node, ParamSysFun};
 use hir_lower::{CurrentKind, HirInterner, ImplicitEquation, ParamKind};
@@ -13,6 +9,11 @@ use mir::{
     Value, FALSE, F_ONE, F_ZERO, TRUE,
 };
 use mir_autodiff::auto_diff;
+use rustc_hash::FxHasher;
+use std::collections::HashMap;
+use std::hash::BuildHasherDefault;
+use std::mem::replace;
+use std::vec;
 use typed_index_collections::TiVec;
 
 use crate::context::Context;
@@ -122,7 +123,7 @@ impl<'a> Builder<'a> {
 
     pub(super) fn with_small_signal_network(
         mut self,
-        small_signal_parameters: IndexSet<Value, ahash::RandomState>,
+        small_signal_parameters: IndexSet<Value, BuildHasherDefault<FxHasher>>,
     ) -> Self {
         self.system.small_signal_parameters = small_signal_parameters;
         self
@@ -219,7 +220,7 @@ impl<'a> Builder<'a> {
     fn build_lim_rhs(
         &mut self,
         derivative_info: &KnownDerivatives,
-        derivatives: AHashMap<(Value, Unknown), Value>,
+        derivatives: HashMap<(Value, Unknown), Value, BuildHasherDefault<FxHasher>>,
     ) {
         for residual in &mut self.system.residual {
             for (state, (unchanged, lim_vals)) in self.intern.lim_state.iter_enumerated() {
@@ -272,7 +273,7 @@ impl<'a> Builder<'a> {
         &mut self,
         sim_unknown_reads: &[(ParamKind, Value)],
         derivative_info: &KnownDerivatives,
-        derivatives: &AHashMap<(Value, Unknown), Value>,
+        derivatives: &HashMap<(Value, Unknown), Value, BuildHasherDefault<FxHasher>>,
     ) {
         self.system.jacobian =
             TiVec::with_capacity(self.system.unknowns.len() * self.system.unknowns.len());
diff --git a/openvaf/sim_back/src/init.rs b/openvaf/sim_back/src/init.rs
index aaab86318..9c3e4254f 100644
--- a/openvaf/sim_back/src/init.rs
+++ b/openvaf/sim_back/src/init.rs
@@ -1,4 +1,6 @@
-use ahash::{AHashMap, AHashSet, RandomState};
+use std::hash::BuildHasherDefault;
+
+use ahash::{AHashMap, AHashSet};
 use bitset::{BitSet, SparseBitMatrix};
 use hir::{CompilationDB, Type};
 use hir_lower::{HirInterner, ParamKind, PlaceKind};
@@ -10,6 +12,7 @@ use mir::{
     InstructionData, Opcode, Value, FALSE,
 };
 use mir_opt::{aggressive_dead_code_elimination, simplify_cfg, simplify_cfg_init, ClassId, GVN};
+use rustc_hash::FxHasher;
 use stdx::packed_option::PackedOption;
 use stdx::{impl_debug_display, impl_idx_from};
 use typed_indexmap::TiMap;
@@ -31,7 +34,7 @@ impl_debug_display! {match CacheSlot{CacheSlot(id) => "cslot{id}";}}
 pub struct Initialization {
     pub func: Function,
     pub intern: HirInterner,
-    pub cached_vals: IndexMap<Value, CacheSlot, RandomState>,
+    pub cached_vals: IndexMap<Value, CacheSlot, BuildHasherDefault<FxHasher>>,
     pub cache_slots: TiMap<CacheSlot, (PackedOption<ClassId>, u32), hir::Type>,
 }
 
@@ -62,7 +65,7 @@ impl Initialization {
 
 struct Builder<'a> {
     init: Initialization,
-    init_cache: IndexMap<Value, Inst, RandomState>,
+    init_cache: IndexMap<Value, Inst, BuildHasherDefault<FxHasher>>,
     // inputs
     func: &'a mut Function,
     cfg: &'a mut ControlFlowGraph,
@@ -81,11 +84,17 @@ impl<'a> Builder<'a> {
         Builder {
             init: Initialization {
                 func: Function::with_name(format!("{}_init", &ctx.func.name)),
-                cached_vals: IndexMap::with_capacity_and_hasher(128, RandomState::new()),
+                cached_vals: IndexMap::with_capacity_and_hasher(
+                    128,
+                    BuildHasherDefault::<FxHasher>::default(),
+                ),
                 cache_slots: TiMap::default(),
                 intern: HirInterner::default(),
             },
-            init_cache: IndexMap::with_capacity_and_hasher(256, RandomState::default()),
+            init_cache: IndexMap::with_capacity_and_hasher(
+                256,
+                BuildHasherDefault::<FxHasher>::default(),
+            ),
             func: &mut ctx.func,
             cfg: &mut ctx.cfg,
             dom_tree: &mut ctx.dom_tree,
diff --git a/openvaf/sim_back/src/module_info.rs b/openvaf/sim_back/src/module_info.rs
index 20df49c41..2e33538b7 100644
--- a/openvaf/sim_back/src/module_info.rs
+++ b/openvaf/sim_back/src/module_info.rs
@@ -1,3 +1,5 @@
+use std::hash::BuildHasherDefault;
+
 use ahash::AHashSet;
 use hir::diagnostics::{BaseDB, ConsoleSink, Diagnostic, FileId, Label, LabelStyle, Report};
 use hir::{
@@ -5,6 +7,7 @@ use hir::{
     ResolvedAliasParameter, ScopeDef, Variable,
 };
 use indexmap::IndexMap;
+use rustc_hash::FxHasher;
 use smol_str::SmolStr;
 use syntax::ast::{self, Expr};
 use syntax::sourcemap::FileSpan;
@@ -42,9 +45,9 @@ pub fn collect_modules(
 
 pub struct ModuleInfo {
     pub module: Module,
-    pub params: IndexMap<Parameter, ParamInfo, ahash::RandomState>,
-    pub sys_fun_alias: IndexMap<ParamSysFun, Vec<SmolStr>, ahash::RandomState>,
-    pub op_vars: IndexMap<Variable, OpVar, ahash::RandomState>,
+    pub params: IndexMap<Parameter, ParamInfo, BuildHasherDefault<FxHasher>>,
+    pub sys_fun_alias: IndexMap<ParamSysFun, Vec<SmolStr>, BuildHasherDefault<FxHasher>>,
+    pub op_vars: IndexMap<Variable, OpVar, BuildHasherDefault<FxHasher>>,
 }
 
 impl ModuleInfo {
@@ -55,10 +58,12 @@ impl ModuleInfo {
         sink: &mut ConsoleSink,
         all_vars_opvars: bool,
     ) -> ModuleInfo {
-        let mut params: IndexMap<Parameter, ParamInfo, ahash::RandomState> = IndexMap::default();
-        let mut sys_fun_alias: IndexMap<ParamSysFun, Vec<SmolStr>, ahash::RandomState> =
+        let mut params: IndexMap<Parameter, ParamInfo, BuildHasherDefault<FxHasher>> =
+            IndexMap::default();
+        let mut sys_fun_alias: IndexMap<ParamSysFun, Vec<SmolStr>, BuildHasherDefault<FxHasher>> =
+            IndexMap::default();
+        let mut op_vars: IndexMap<Variable, OpVar, BuildHasherDefault<FxHasher>> =
             IndexMap::default();
-        let mut op_vars = IndexMap::default();
 
         let ast = cu.ast(db);
 
diff --git a/openvaf/sim_back/src/topology.rs b/openvaf/sim_back/src/topology.rs
index 2a31741c2..0133e1993 100644
--- a/openvaf/sim_back/src/topology.rs
+++ b/openvaf/sim_back/src/topology.rs
@@ -17,6 +17,8 @@
 //!   generation of unnecessary derivatives.
 //!
 
+use std::hash::BuildHasherDefault;
+
 use ahash::AHashMap;
 use bitset::{BitSet, SparseBitMatrix};
 use hir_lower::{CallBackKind, HirInterner, ImplicitEquation, ParamKind, PlaceKind};
@@ -25,6 +27,7 @@ use lasso::Spur;
 use mir::{strip_optbarrier, Function, Inst, Value, F_ZERO, TRUE};
 use mir_build::SSAVariableBuilder;
 use mir_opt::simplify_cfg_no_phi_merge;
+use rustc_hash::FxHasher;
 use stdx::{impl_debug_display, impl_idx_from};
 use typed_index_collections::TiVec;
 use typed_indexmap::TiMap;
@@ -150,7 +153,7 @@ impl Noise {
 pub(crate) struct Topology {
     pub(crate) branches: TiMap<BranchId, BranchWrite, BranchInfo>,
     pub(crate) implicit_equations: TiVec<ImplicitEquation, Contribution>,
-    pub(crate) small_signal_vals: IndexSet<Value, ahash::RandomState>,
+    pub(crate) small_signal_vals: IndexSet<Value, BuildHasherDefault<FxHasher>>,
     contributes: AHashMap<Value, ContributeKind>,
 }
 
@@ -284,7 +287,7 @@ impl Topology {
             implicit_equations,
             small_signal_vals: IndexSet::with_capacity_and_hasher(
                 128,
-                ahash::RandomState::default(),
+                BuildHasherDefault::<FxHasher>::default(),
             ),
         };
         let num_insts = ctx.func.dfg.num_insts();
diff --git a/openvaf/sim_back/src/topology/small_signal_network.rs b/openvaf/sim_back/src/topology/small_signal_network.rs
index 45da1a708..460c6fac3 100644
--- a/openvaf/sim_back/src/topology/small_signal_network.rs
+++ b/openvaf/sim_back/src/topology/small_signal_network.rs
@@ -1,9 +1,11 @@
+use std::hash::BuildHasherDefault;
 use std::iter::once;
 use std::mem::take;
 
 use hir::Node;
 use indexmap::IndexMap;
 use mir::{Const, InstructionData, Opcode, Value, ValueDef, FALSE, F_ZERO};
+use rustc_hash::FxHasher;
 
 use crate::topology::Builder;
 use crate::util::{add, update_optbarrier};
@@ -56,36 +58,83 @@ enum CandidateKind {
 }
 
 impl Builder<'_> {
-    /// explores all `candidates` to extract the noise network
+    /// Explores all `candidates` to extract the small-signal network using an order-independent algorithm.
+    ///
+    /// The algorithm uses fixed-point iteration with four phases per iteration:
+    /// 1. Speculatively add ALL candidate nodes to small_signal_vals
+    /// 2. Evaluate all candidates against this consistent set state
+    /// 3. Confirm nodes that are proven zero, remove those proven non-zero
+    /// 4. Restore small_signal_vals to contain only confirmed values
+    ///
+    /// This ensures order-independence: all candidates see the SAME set state (all candidate nodes)
+    /// during evaluation, regardless of iteration order or platform-specific hash ordering.
     fn solve(&mut self, candidates: &mut Vec<Candidate>) {
         loop {
             let mut changed = false;
-            candidates.retain_mut(|candidate| {
-                if let Some(node) = candidate.as_node() {
-                    self.topology.small_signal_vals.insert(node);
-                }
+            let mut confirmed_nodes = Vec::new();
+            let mut confirmed_flows = Vec::new();
+            let mut to_remove = Vec::new();
+
+            // Phase 1: Speculatively add ALL candidate nodes to small_signal_vals
+            // This creates a consistent set state for all evaluations in this iteration
+            let speculative_nodes: Vec<Value> =
+                candidates.iter().filter_map(|c| c.as_node()).collect();
+
+            for &node in &speculative_nodes {
+                self.topology.small_signal_vals.insert(node);
+            }
+
+            // Phase 2: Evaluate all candidates against the consistent set state
+            for (idx, candidate) in candidates.iter().enumerate() {
                 let mut set = FlatSet::Zero;
+
+                // Analyze resistive contributions
                 for &val in &candidate.resist {
                     set = set.min(self.analyze_value(val, RECUSE_DEPTH));
                 }
+
+                // Analyze reactive contributions
                 for &val in &candidate.react {
                     set = set.min(self.analyze_value(val, RECUSE_DEPTH));
                 }
+
                 if set == FlatSet::Zero {
+                    // Proven zero - mark for confirmation
                     match candidate.kind {
-                        CandidateKind::Node { .. } => {
+                        CandidateKind::Node { potential } => {
+                            confirmed_nodes.push(potential);
                             cov_mark::hit!(node_is_small_signal);
                         }
                         CandidateKind::Flow { flow } => {
-                            self.topology.small_signal_vals.insert(flow);
+                            confirmed_flows.push(flow);
                         }
                     }
+                    to_remove.push(idx);
                     changed = true;
-                } else if let Some(node) = candidate.as_node() {
-                    self.topology.small_signal_vals.remove(&node);
+                } else if set == FlatSet::Top {
+                    // Proven non-zero - remove from candidates
+                    to_remove.push(idx);
                 }
-                set == FlatSet::Bottom
-            });
+                // If set == FlatSet::Bottom (unknown), keep in candidates for next iteration
+            }
+
+            // Phase 3: Remove speculative nodes that weren't confirmed
+            for &node in &speculative_nodes {
+                if !confirmed_nodes.contains(&node) {
+                    self.topology.small_signal_vals.swap_remove(&node);
+                }
+            }
+
+            // Phase 4: Add confirmed flows
+            for flow in confirmed_flows {
+                self.topology.small_signal_vals.insert(flow);
+            }
+
+            // Phase 5: Remove resolved candidates (iterate backwards to preserve indices)
+            for &idx in to_remove.iter().rev() {
+                candidates.swap_remove(idx);
+            }
+
             if !changed {
                 break;
             }
@@ -305,7 +354,8 @@ impl Builder<'_> {
     }
 
     fn collect_candidates(&mut self) -> Vec<Candidate> {
-        let mut nodes = IndexMap::with_capacity_and_hasher(32, ahash::RandomState::new());
+        let mut nodes =
+            IndexMap::with_capacity_and_hasher(32, BuildHasherDefault::<FxHasher>::default());
         let mut candidates = Vec::new();
         for (_, (&branch, contributes)) in self.topology.branches() {
             let (hi, lo) = branch.nodes(self.db);
diff --git a/openvaf/syntax/src/ast/generated/nodes.rs b/openvaf/syntax/src/ast/generated/nodes.rs
index cc2f471da..a47e89fb5 100644
--- a/openvaf/syntax/src/ast/generated/nodes.rs
+++ b/openvaf/syntax/src/ast/generated/nodes.rs
@@ -459,6 +459,18 @@ impl AliasParam {
     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ModuleInst {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ast::AttrsOwner for ModuleInst {}
+impl ModuleInst {
+    pub fn module_name(&self) -> Option<NameRef> { support::child(&self.syntax) }
+    pub fn param_assignments(&self) -> Option<ParamAssignments> { support::child(&self.syntax) }
+    pub fn inst_name(&self) -> Option<Name> { support::child(&self.syntax) }
+    pub fn port_connections(&self) -> Option<PortConnections> { support::child(&self.syntax) }
+    pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct ModulePort {
     pub(crate) syntax: SyntaxNode,
 }
@@ -536,6 +548,52 @@ impl FunctionArg {
     pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ParamAssignments {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ParamAssignments {
+    pub fn pound_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![#]) }
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
+    pub fn param_assignments(&self) -> AstChildren<ParamAssignment> {
+        support::children(&self.syntax)
+    }
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct PortConnections {
+    pub(crate) syntax: SyntaxNode,
+}
+impl PortConnections {
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
+    pub fn port_connections(&self) -> AstChildren<PortConnection> {
+        support::children(&self.syntax)
+    }
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ParamAssignment {
+    pub(crate) syntax: SyntaxNode,
+}
+impl ParamAssignment {
+    pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) }
+    pub fn param(&self) -> Option<Name> { support::child(&self.syntax) }
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
+    pub fn value(&self) -> Option<Expr> { support::child(&self.syntax) }
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct PortConnection {
+    pub(crate) syntax: SyntaxNode,
+}
+impl PortConnection {
+    pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
+    pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) }
+    pub fn port(&self) -> Option<Name> { support::child(&self.syntax) }
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
+    pub fn connection(&self) -> Option<Expr> { support::child(&self.syntax) }
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
+}
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum Expr {
     PrefixExpr(PrefixExpr),
     BinExpr(BinExpr),
@@ -589,6 +647,7 @@ pub enum ModuleItem {
     VarDecl(VarDecl),
     ParamDecl(ParamDecl),
     AliasParam(AliasParam),
+    ModuleInst(ModuleInst),
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum ModulePortKind {
@@ -1092,6 +1151,17 @@ impl AstNode for AliasParam {
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
+impl AstNode for ModuleInst {
+    fn can_cast(kind: SyntaxKind) -> bool { kind == MODULE_INST }
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
 impl AstNode for ModulePort {
     fn can_cast(kind: SyntaxKind) -> bool { kind == MODULE_PORT }
     fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -1180,6 +1250,50 @@ impl AstNode for FunctionArg {
     }
     fn syntax(&self) -> &SyntaxNode { &self.syntax }
 }
+impl AstNode for ParamAssignments {
+    fn can_cast(kind: SyntaxKind) -> bool { kind == PARAM_ASSIGNMENTS }
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+impl AstNode for PortConnections {
+    fn can_cast(kind: SyntaxKind) -> bool { kind == PORT_CONNECTIONS }
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+impl AstNode for ParamAssignment {
+    fn can_cast(kind: SyntaxKind) -> bool { kind == PARAM_ASSIGNMENT }
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+impl AstNode for PortConnection {
+    fn can_cast(kind: SyntaxKind) -> bool { kind == PORT_CONNECTION }
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) {
+            Some(Self { syntax })
+        } else {
+            None
+        }
+    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
 impl From<PrefixExpr> for Expr {
     fn from(node: PrefixExpr) -> Expr { Expr::PrefixExpr(node) }
 }
@@ -1424,11 +1538,14 @@ impl From<ParamDecl> for ModuleItem {
 impl From<AliasParam> for ModuleItem {
     fn from(node: AliasParam) -> ModuleItem { ModuleItem::AliasParam(node) }
 }
+impl From<ModuleInst> for ModuleItem {
+    fn from(node: ModuleInst) -> ModuleItem { ModuleItem::ModuleInst(node) }
+}
 impl AstNode for ModuleItem {
     fn can_cast(kind: SyntaxKind) -> bool {
         match kind {
             BODY_PORT_DECL | NET_DECL | ANALOG_BEHAVIOUR | FUNCTION | BRANCH_DECL | VAR_DECL
-            | PARAM_DECL | ALIAS_PARAM => true,
+            | PARAM_DECL | ALIAS_PARAM | MODULE_INST => true,
             _ => false,
         }
     }
@@ -1442,6 +1559,7 @@ impl AstNode for ModuleItem {
             VAR_DECL => ModuleItem::VarDecl(VarDecl { syntax }),
             PARAM_DECL => ModuleItem::ParamDecl(ParamDecl { syntax }),
             ALIAS_PARAM => ModuleItem::AliasParam(AliasParam { syntax }),
+            MODULE_INST => ModuleItem::ModuleInst(ModuleInst { syntax }),
             _ => return None,
         };
         Some(res)
@@ -1456,6 +1574,7 @@ impl AstNode for ModuleItem {
             ModuleItem::VarDecl(it) => &it.syntax,
             ModuleItem::ParamDecl(it) => &it.syntax,
             ModuleItem::AliasParam(it) => &it.syntax,
+            ModuleItem::ModuleInst(it) => &it.syntax,
         }
     }
 }
@@ -1817,6 +1936,11 @@ impl std::fmt::Display for AliasParam {
         std::fmt::Display::fmt(self.syntax(), f)
     }
 }
+impl std::fmt::Display for ModuleInst {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
 impl std::fmt::Display for ModulePort {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         std::fmt::Display::fmt(self.syntax(), f)
@@ -1857,3 +1981,23 @@ impl std::fmt::Display for FunctionArg {
         std::fmt::Display::fmt(self.syntax(), f)
     }
 }
+impl std::fmt::Display for ParamAssignments {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
+impl std::fmt::Display for PortConnections {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
+impl std::fmt::Display for ParamAssignment {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
+impl std::fmt::Display for PortConnection {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
diff --git a/openvaf/syntax/veriloga.ungram b/openvaf/syntax/veriloga.ungram
index 0fccf808d..6ab9383b9 100644
--- a/openvaf/syntax/veriloga.ungram
+++ b/openvaf/syntax/veriloga.ungram
@@ -195,6 +195,7 @@ ModuleItem =
 | VarDecl
 | ParamDecl
 | AliasParam
+| ModuleInst
 
 ModulePorts = '('ports: (ModulePort (',' ModulePort)*)? ')'
 ModulePort = kind: ModulePortKind
@@ -257,3 +258,20 @@ FunctionArg =
 
 BranchDecl =
   AttrList* 'branch' ArgList (Name (',' Name)*)';'
+
+// Module instantiation: module_name #(.param(value), ...) instance_name (port1, port2, ...);
+// Example: resistor #(.r(rwire)) r1 (d, de0);
+ModuleInst =
+  AttrList* module_name:NameRef ParamAssignments? inst_name:Name PortConnections ';'
+
+ParamAssignments =
+  '#' '(' (ParamAssignment (',' ParamAssignment)*)? ')'
+
+ParamAssignment =
+  '.' param:Name '(' value:Expr ')'
+
+PortConnections =
+  '(' (PortConnection (',' PortConnection)*)? ')'
+
+PortConnection =
+  Expr | '.' port:Name '(' connection:Expr ')'
diff --git a/openvaf/target/src/spec/aarch64_apple_darwin.rs b/openvaf/target/src/spec/aarch64_apple_darwin.rs
index 6aef6a9c5..d598f24eb 100644
--- a/openvaf/target/src/spec/aarch64_apple_darwin.rs
+++ b/openvaf/target/src/spec/aarch64_apple_darwin.rs
@@ -9,11 +9,21 @@ pub fn target() -> Target {
         vec![
             "-arch".to_string(),
             "arm64".to_string(),
+            "-platform_version".to_string(),
+            "macos".to_string(),
+            "11.0".to_string(),
+            "11.0".to_string(),
             "-undefined".to_string(),
             "dynamic_lookup".to_string(),
         ],
     );
 
+    // Link against libSystem which provides dyld_stub_binder
+    base.post_link_args.insert(
+        LinkerFlavor::Ld64,
+        vec!["-lSystem".to_string()],
+    );
+
     Target {
         llvm_target: "arm64-apple-macosx11.0.0".to_owned(),
         pointer_width: 64,
diff --git a/openvaf/target/src/spec/x86_64_apple_darwin.rs b/openvaf/target/src/spec/x86_64_apple_darwin.rs
index 7a852654c..4525691b2 100644
--- a/openvaf/target/src/spec/x86_64_apple_darwin.rs
+++ b/openvaf/target/src/spec/x86_64_apple_darwin.rs
@@ -10,11 +10,21 @@ pub fn target() -> Target {
         vec![
             "-arch".to_string(),
             "x86_64".to_string(),
+            "-platform_version".to_string(),
+            "macos".to_string(),
+            "10.15".to_string(),
+            "10.15".to_string(),
             "-undefined".to_string(),
             "dynamic_lookup".to_string(),
         ],
     );
 
+    // Link against libSystem which provides dyld_stub_binder
+    base.post_link_args.insert(
+        LinkerFlavor::Ld64,
+        vec!["-lSystem".to_string()],
+    );
+
     Target {
         llvm_target: "x86_64-apple-macosx10.15.0".to_owned(),
         arch: "x86_64".to_owned(),
diff --git a/openvaf/test_data/contributions/psp103_mir.snap b/openvaf/test_data/contributions/psp103_mir.snap
index 0f9d7f7b6..f911cbdfd 100644
--- a/openvaf/test_data/contributions/psp103_mir.snap
+++ b/openvaf/test_data/contributions/psp103_mir.snap
@@ -9,21 +9,21 @@ function %(v16, v17, v20, v22, v25, v26, v34, v41, v42, v45, v47, v49, v52) {
                                 block2:
 @0005                               v18 = fdiv v16, v17
 @000c                               v21 = fdiv v3, v17
-                                    v77 = fdiv v20, v17
+                                    v74 = fdiv v20, v17
 @0012                               v23 = fmul v22, v3
-                                    v76 = fmul v22, v20
+                                    v73 = fmul v22, v20
 @0018                               v27 = sqrt v26
 @001a                               v29 = fmul v27, v28
 @001c                               v30 = fmul v29, v22
 @001f                               v31 = fmul v30, v3
-                                    v74 = fmul v30, v20
+                                    v71 = fmul v30, v20
 @0021                               v33 = fneg v3
                                     v64 = fneg v31
-                                    v75 = fneg v74
+                                    v72 = fneg v71
 @0036                               v44 = fmul v42, v27
 @0038                               v46 = fmul v44, v45
 @003b                               v48 = fmul v46, v3
-                                    v71 = fmul v46, v47
+                                    v77 = fmul v46, v47
 @0041                               v50 = fmul v26, v49
 @0043                               v51 = fmul v50, v49
 @0047                               v53 = fmul v52, v52
@@ -41,6 +41,6 @@ function %(v16, v17, v20, v22, v25, v26, v34, v41, v42, v45, v47, v49, v52) {
                                     v67 = optbarrier v64
                                     v68 = optbarrier v64
                                     v69 = optbarrier v55
-                                    v72 = optbarrier v71
+                                    v75 = optbarrier v74
                                     v78 = optbarrier v77
 }
diff --git a/openvaf/test_data/contributions/psp103_topology.snap b/openvaf/test_data/contributions/psp103_topology.snap
index b90926317..125c58ae0 100644
--- a/openvaf/test_data/contributions/psp103_topology.snap
+++ b/openvaf/test_data/contributions/psp103_topology.snap
@@ -56,7 +56,7 @@ Topology {
                     unknown: None,
                     resist: v59,
                     react: v3,
-                    resist_small_signal: v78,
+                    resist_small_signal: v75,
                     react_small_signal: v3,
                     noise: [],
                 },
@@ -163,7 +163,7 @@ Topology {
                     unknown: None,
                     resist: v63,
                     react: v3,
-                    resist_small_signal: v72,
+                    resist_small_signal: v78,
                     react_small_signal: v3,
                     noise: [
                         Noise {
@@ -180,8 +180,8 @@ Topology {
     },
     implicit_equations: {},
     small_signal_vals: {
-        v47,
         v20,
+        v47,
     },
     contributes: {},
 }
\ No newline at end of file
diff --git a/openvaf/test_data/item_tree/module_inst.def_map b/openvaf/test_data/item_tree/module_inst.def_map
new file mode 100644
index 000000000..b988341b1
--- /dev/null
+++ b/openvaf/test_data/item_tree/module_inst.def_map
@@ -0,0 +1,13 @@
+test = module;
+
+    $angle = hierarchical parameter system function;
+    $hflip = hierarchical parameter system function;
+    $mfactor = hierarchical parameter system function;
+    $vflip = hierarchical parameter system function;
+    $xposition = hierarchical parameter system function;
+    $yposition = hierarchical parameter system function;
+    a = node;
+    b = node;
+    mid = node;
+    r1 = parameter;
+    r2 = parameter;
diff --git a/openvaf/test_data/item_tree/module_inst.item_tree b/openvaf/test_data/item_tree/module_inst.item_tree
new file mode 100644
index 000000000..85dc5c860
--- /dev/null
+++ b/openvaf/test_data/item_tree/module_inst.item_tree
@@ -0,0 +1,9 @@
+module test
+
+    node a = {is_input: true, is_output:true, gnd: false , discipline Some(Name("electrical"))}
+    node b = {is_input: true, is_output:true, gnd: false , discipline Some(Name("electrical"))}
+    node mid = {is_input: false, is_output:false, gnd: false , discipline Some(Name("electrical"))}
+    param real r1
+    param real r2
+    module_inst resistor inst1 #([(Name("r"), Name("r1"))]) ([Name("a"), Name("mid")])
+    module_inst resistor inst2 #([(Name("r"), Name("r2"))]) ([Name("mid"), Name("b")])
\ No newline at end of file
diff --git a/openvaf/test_data/item_tree/module_inst.va b/openvaf/test_data/item_tree/module_inst.va
new file mode 100644
index 000000000..8660d7479
--- /dev/null
+++ b/openvaf/test_data/item_tree/module_inst.va
@@ -0,0 +1,15 @@
+// Test module instantiation parsing
+module test(a, b);
+    electrical a, b, mid;
+    inout a, b;
+
+    parameter real r1 = 100.0;
+    parameter real r2 = 200.0;
+
+    // Module instantiation with parameter override
+    resistor #(.r(r1)) inst1 (a, mid);
+
+    // Module instantiation with multiple parameters
+    resistor #(.r(r2)) inst2 (mid, b);
+
+endmodule
diff --git a/openvaf/test_data/osdi/amplifier.snap b/openvaf/test_data/osdi/amplifier.snap
index d6eeb92d5..77b7000ef 100644
--- a/openvaf/test_data/osdi/amplifier.snap
+++ b/openvaf/test_data/osdi/amplifier.snap
@@ -8,34 +8,26 @@ param "G"
 units = "", desc = "Voltage amplification factor", flags = ParameterFlags(0x0)
 
 4 terminals
-node "Inp" units = "V", runits = ""
-residual 224 4294967295 4294967295 4294967295
-node "Inm" units = "V", runits = ""
-residual 232 4294967295 4294967295 4294967295
-node "Outp" units = "V", runits = ""
-residual 240 4294967295 4294967295 4294967295
-node "Outm" units = "V", runits = ""
-residual 248 4294967295 4294967295 4294967295
-node(flow) "flow(Outp)" units = "A", runits = ""
-residual 256 4294967295 4294967295 4294967295
-node(flow) "flow(Outm)" units = "A", runits = ""
-residual 264 4294967295 4294967295 4294967295
-jacobian (Inp, Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (Inp, Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (Inm, Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (Inm, Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (Outp, Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (Outp, Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (Outp, flow(Outp)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (Outm, Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (Outm, Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (Outm, flow(Outm)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (flow(Outp), Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (flow(Outp), Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (flow(Outp), Outp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (flow(Outm), Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (flow(Outm), Outm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
+node "Inp" units = "V", runits = "A"
+node "Inm" units = "V", runits = "A"
+node "Outp" units = "V", runits = "A"
+node "Outm" units = "V", runits = "A"
+node(flow) "flow(Outp)" units = "A", runits = "V"
+node(flow) "flow(Outm)" units = "A", runits = "V"
+jacobian (Inp, Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (Inp, Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (Inm, Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (Inm, Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (Outp, Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (Outp, Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (Outp, flow(Outp)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (Outm, Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (Outm, Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (Outm, flow(Outm)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (flow(Outp), Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (flow(Outp), Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (flow(Outp), Outp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (flow(Outm), Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (flow(Outm), Outm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST)
 0 states
 has bound_step false
-instance size 272
-model size 40
diff --git a/openvaf/test_data/osdi/asmhemt.snap b/openvaf/test_data/osdi/asmhemt.snap
index 6c19688c0..be41cb64c 100644
--- a/openvaf/test_data/osdi/asmhemt.snap
+++ b/openvaf/test_data/osdi/asmhemt.snap
@@ -400,180 +400,164 @@ param "gdsmin"
 units = "S", desc = " Convergence Parameter", flags = ParameterFlags(0x0)
 
 5 terminals
-node "d" units = "V", runits = ""
-residual 2792 2800 4294967295 4294967295
-node "g" units = "V", runits = ""
-residual 2808 2816 4294967295 4294967295
-node "s" units = "V", runits = ""
-residual 2824 2832 4294967295 4294967295
-node "b" units = "V", runits = ""
-residual 4294967295 2840 4294967295 4294967295
-node "dt" units = "K", runits = ""
-residual 2848 2856 4294967295 4294967295
-node "trap1" units = "V", runits = ""
-residual 2864 2872 4294967295 4294967295
-node "trap2" units = "V", runits = ""
-residual 2880 2888 4294967295 4294967295
-node "di" units = "V", runits = ""
-residual 2896 2904 4294967295 4294967295
-node "si" units = "V", runits = ""
-residual 2912 2920 4294967295 4294967295
-node "gi" units = "V", runits = ""
-residual 2928 2936 4294967295 4294967295
-node "fp1" units = "V", runits = ""
-residual 2944 2952 4294967295 4294967295
-node "fp2" units = "V", runits = ""
-residual 2960 2968 4294967295 4294967295
-node "fp3" units = "V", runits = ""
-residual 2976 2984 4294967295 4294967295
-node "fp4" units = "V", runits = ""
-residual 2992 3000 4294967295 4294967295
-node(flow) "flow(di,si)" units = "A", runits = ""
-residual 3008 3016 4294967295 4294967295
+node "d" units = "V", runits = "A"
+node "g" units = "V", runits = "A"
+node "s" units = "V", runits = "A"
+node "b" units = "V", runits = "A"
+node "dt" units = "K", runits = "W"
+node "trap1" units = "V", runits = "A"
+node "trap2" units = "V", runits = "A"
+node "di" units = "V", runits = "A"
+node "si" units = "V", runits = "A"
+node "gi" units = "V", runits = "A"
+node "fp1" units = "V", runits = "A"
+node "fp2" units = "V", runits = "A"
+node "fp3" units = "V", runits = "A"
+node "fp4" units = "V", runits = "A"
+node(flow) "flow(di,si)" units = "A", runits = "A"
 node "implicit_equation_0" units = "", runits = ""
-residual 3024 3032 4294967295 4294967295
-jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1144
-jacobian (d, g) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1152
-jacobian (d, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1160
-jacobian (d, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1168
-jacobian (d, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1176
-jacobian (d, trap1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, trap2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, fp4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (g, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1184
-jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1192
-jacobian (g, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1200
-jacobian (g, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1208
-jacobian (g, dt) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1216
-jacobian (g, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1224
-jacobian (s, g) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1232
-jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1240
-jacobian (s, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1248
-jacobian (s, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1256
-jacobian (s, trap1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, trap2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1264
-jacobian (s, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1272
-jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1280
-jacobian (s, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1288
-jacobian (s, fp1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1296
-jacobian (s, fp2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1304
-jacobian (s, fp3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1312
-jacobian (s, fp4) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1320
-jacobian (b, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1328
-jacobian (b, g) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1336
-jacobian (b, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1344
-jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1352
-jacobian (b, dt) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1360
-jacobian (b, trap1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1368
-jacobian (b, trap2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1376
-jacobian (b, di) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1384
-jacobian (b, si) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1392
-jacobian (b, gi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1400
-jacobian (b, fp1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1408
-jacobian (b, fp2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1416
-jacobian (b, fp3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1424
-jacobian (b, fp4) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1432
-jacobian (dt, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dt, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1440
-jacobian (dt, trap1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dt, trap2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dt, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dt, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dt, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dt, fp1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dt, fp2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dt, fp3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dt, fp4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (trap1, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (trap1, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (trap1, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (trap1, trap1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1448
-jacobian (trap1, trap2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (trap1, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (trap2, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (trap2, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (trap2, trap1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (trap2, trap2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1456
-jacobian (di, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1464
-jacobian (di, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1472
-jacobian (di, trap2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1480
-jacobian (di, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1488
-jacobian (di, si) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1496
-jacobian (di, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1504
-jacobian (di, fp1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1512
-jacobian (di, flow(di,si)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (si, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1520
-jacobian (si, trap1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1528
-jacobian (si, trap2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1536
-jacobian (si, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1544
-jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1552
-jacobian (si, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1560
-jacobian (si, flow(di,si)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (gi, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (gi, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1568
-jacobian (gi, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1576
-jacobian (gi, trap1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1584
-jacobian (gi, trap2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1592
-jacobian (gi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1600
-jacobian (gi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1608
-jacobian (gi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1616
-jacobian (gi, fp1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1624
-jacobian (gi, fp2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1632
-jacobian (gi, fp3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1640
-jacobian (gi, fp4) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1648
-jacobian (fp1, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1656
-jacobian (fp1, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1664
-jacobian (fp1, trap2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1672
-jacobian (fp1, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1680
-jacobian (fp1, si) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1688
-jacobian (fp1, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1696
-jacobian (fp1, fp1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1704
-jacobian (fp1, fp2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1712
-jacobian (fp2, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1720
-jacobian (fp2, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1728
-jacobian (fp2, trap2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1736
-jacobian (fp2, di) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1744
-jacobian (fp2, si) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1752
-jacobian (fp2, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1760
-jacobian (fp2, fp1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1768
-jacobian (fp2, fp2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1776
-jacobian (fp2, fp3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1784
-jacobian (fp3, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1792
-jacobian (fp3, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1800
-jacobian (fp3, trap2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1808
-jacobian (fp3, di) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1816
-jacobian (fp3, si) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1824
-jacobian (fp3, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1832
-jacobian (fp3, fp1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1840
-jacobian (fp3, fp2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1848
-jacobian (fp3, fp3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1856
-jacobian (fp3, fp4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1864
-jacobian (fp4, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (fp4, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1872
-jacobian (fp4, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1880
-jacobian (fp4, trap1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (fp4, trap2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1888
-jacobian (fp4, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1896
-jacobian (fp4, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1904
-jacobian (fp4, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1912
-jacobian (fp4, fp1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1920
-jacobian (fp4, fp2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1928
-jacobian (fp4, fp3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1936
-jacobian (fp4, fp4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1944
-jacobian (flow(di,si), dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (flow(di,si), trap1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (flow(di,si), trap2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (flow(di,si), di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1952
-jacobian (flow(di,si), si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1960
-jacobian (flow(di,si), gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1968
-jacobian (flow(di,si), flow(di,si)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (implicit_equation_0, trap1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1976
-jacobian (implicit_equation_0, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
+jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (d, g) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (d, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (d, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (d, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (d, trap1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, trap2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, fp4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (g, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (g, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (g, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (g, dt) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (g, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (s, g) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (s, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (s, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (s, trap1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, trap2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (s, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (s, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (s, fp1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (s, fp2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (s, fp3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (s, fp4) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (b, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (b, g) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (b, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (b, dt) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (b, trap1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (b, trap2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (b, di) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (b, si) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (b, gi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (b, fp1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (b, fp2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (b, fp3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (b, fp4) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (dt, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dt, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (dt, trap1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dt, trap2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dt, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dt, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dt, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dt, fp1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dt, fp2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dt, fp3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dt, fp4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (trap1, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (trap1, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (trap1, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (trap1, trap1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (trap1, trap2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (trap1, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (trap2, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (trap2, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (trap2, trap1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (trap2, trap2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, trap2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (di, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, si) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (di, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, fp1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, flow(di,si)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (si, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, trap1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, trap2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, flow(di,si)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (gi, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (gi, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (gi, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gi, trap1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (gi, trap2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (gi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gi, fp1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (gi, fp2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (gi, fp3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (gi, fp4) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (fp1, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp1, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp1, trap2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (fp1, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp1, si) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (fp1, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp1, fp1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp1, fp2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp2, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp2, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp2, trap2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (fp2, di) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (fp2, si) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (fp2, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp2, fp1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp2, fp2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp2, fp3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp3, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp3, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp3, trap2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (fp3, di) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (fp3, si) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (fp3, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp3, fp1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (fp3, fp2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp3, fp3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp3, fp4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp4, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (fp4, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp4, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp4, trap1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (fp4, trap2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp4, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp4, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp4, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp4, fp1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (fp4, fp2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (fp4, fp3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp4, fp4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (flow(di,si), dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (flow(di,si), trap1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (flow(di,si), trap2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (flow(di,si), di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (flow(di,si), si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (flow(di,si), gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (flow(di,si), flow(di,si)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (implicit_equation_0, trap1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (implicit_equation_0, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST)
 collapsible (implicit_equation_0, gnd)
 collapsible (dt, gnd)
 collapsible (trap1, gnd)
@@ -593,5 +577,3 @@ noise "thermal" (d, fp4)
 noise "thermal" (si, s)
 0 states
 has bound_step false
-instance size 4512
-model size 1608
diff --git a/openvaf/test_data/osdi/bsim3.snap b/openvaf/test_data/osdi/bsim3.snap
index ffd3b83eb..38eaa496a 100644
--- a/openvaf/test_data/osdi/bsim3.snap
+++ b/openvaf/test_data/osdi/bsim3.snap
@@ -1450,40 +1450,34 @@ param "delvto"
 units = "", desc = "", flags = ParameterFlags(0x0)
 
 4 terminals
-node "d" units = "V", runits = ""
-residual 1904 4294967295 4294967295 4294967295
-node "g" units = "V", runits = ""
-residual 1912 1920 4294967295 4294967295
-node "s" units = "V", runits = ""
-residual 1928 4294967295 4294967295 4294967295
-node "b" units = "V", runits = ""
-residual 1936 1944 4294967295 4294967295
-node "di" units = "V", runits = ""
-residual 1952 1960 4294967295 4294967295
-node "si" units = "V", runits = ""
-residual 1968 1976 4294967295 4294967295
-jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 184
-jacobian (g, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 192
-jacobian (g, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 200
-jacobian (g, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 208
-jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (b, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 216
-jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 224
-jacobian (b, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 232
-jacobian (b, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 240
-jacobian (di, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (di, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 248
-jacobian (di, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 256
-jacobian (di, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 264
-jacobian (di, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 272
-jacobian (si, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 280
-jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (si, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 288
-jacobian (si, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 296
-jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 304
+node "d" units = "V", runits = "A"
+node "g" units = "V", runits = "A"
+node "s" units = "V", runits = "A"
+node "b" units = "V", runits = "A"
+node "di" units = "V", runits = "A"
+node "si" units = "V", runits = "A"
+jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (g, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (g, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (g, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (b, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (b, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (b, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (di, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (si, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
 collapsible (s, si)
 collapsible (d, di)
 noise "Rs" (s, si)
@@ -1492,5 +1486,3 @@ noise "flicker" (di, si)
 noise "ids" (di, si)
 0 states
 has bound_step false
-instance size 2304
-model size 5824
diff --git a/openvaf/test_data/osdi/bsim4.snap b/openvaf/test_data/osdi/bsim4.snap
index 953d9b1cd..26f7049e4 100644
--- a/openvaf/test_data/osdi/bsim4.snap
+++ b/openvaf/test_data/osdi/bsim4.snap
@@ -1796,111 +1796,95 @@ param "pdvtp5"
 units = "", desc = "", flags = ParameterFlags(0x0)
 
 4 terminals
-node "d" units = "V", runits = ""
-residual 3424 4294967295 4294967295 4294967295
-node "g" units = "V", runits = ""
-residual 3432 4294967295 4294967295 4294967295
-node "s" units = "V", runits = ""
-residual 3440 4294967295 4294967295 4294967295
-node "b" units = "V", runits = ""
-residual 3448 4294967295 4294967295 4294967295
-node "di" units = "V", runits = ""
-residual 3456 3464 4294967295 4294967295
-node "si" units = "V", runits = ""
-residual 3472 3480 4294967295 4294967295
-node "gi" units = "V", runits = ""
-residual 3488 3496 4294967295 4294967295
-node "gm" units = "V", runits = ""
-residual 3504 4294967295 4294967295 4294967295
-node "bi" units = "V", runits = ""
-residual 3512 3520 4294967295 4294967295
-node "sbulk" units = "V", runits = ""
-residual 3528 3536 4294967295 4294967295
-node "dbulk" units = "V", runits = ""
-residual 3544 3552 4294967295 4294967295
+node "d" units = "V", runits = "A"
+node "g" units = "V", runits = "A"
+node "s" units = "V", runits = "A"
+node "b" units = "V", runits = "A"
+node "di" units = "V", runits = "A"
+node "si" units = "V", runits = "A"
+node "gi" units = "V", runits = "A"
+node "gm" units = "V", runits = "A"
+node "bi" units = "V", runits = "A"
+node "sbulk" units = "V", runits = "A"
+node "dbulk" units = "V", runits = "A"
 node(flow) "flow(sbulk,bi)" units = "A", runits = ""
-residual 3560 4294967295 4294967295 4294967295
 node(flow) "flow(sbulk,b)" units = "A", runits = ""
-residual 3568 4294967295 4294967295 4294967295
 node(flow) "flow(b,bi)" units = "A", runits = ""
-residual 3576 4294967295 4294967295 4294967295
 node(flow) "flow(b,dbulk)" units = "A", runits = ""
-residual 3584 4294967295 4294967295 4294967295
 node(flow) "flow(bi,dbulk)" units = "A", runits = ""
-residual 3592 4294967295 4294967295 4294967295
-jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (g, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (b, flow(sbulk,b)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (b, flow(b,bi)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (b, flow(b,dbulk)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (di, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (di, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 592
-jacobian (di, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 600
-jacobian (di, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 608
-jacobian (di, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 616
-jacobian (di, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 624
-jacobian (di, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 632
-jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (si, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 640
-jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 648
-jacobian (si, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 656
-jacobian (si, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 664
-jacobian (si, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 672
-jacobian (si, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 680
-jacobian (gi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 688
-jacobian (gi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 696
-jacobian (gi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 704
-jacobian (gi, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 712
-jacobian (gi, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 720
-jacobian (gm, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (gm, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (gm, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (gm, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (gm, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (gm, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (bi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 728
-jacobian (bi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 736
-jacobian (bi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 744
-jacobian (bi, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 752
-jacobian (bi, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 760
-jacobian (bi, flow(sbulk,bi)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (bi, flow(b,bi)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (bi, flow(bi,dbulk)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (sbulk, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 768
-jacobian (sbulk, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 776
-jacobian (sbulk, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 784
-jacobian (sbulk, flow(sbulk,bi)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (sbulk, flow(sbulk,b)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dbulk, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 792
-jacobian (dbulk, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 800
-jacobian (dbulk, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 808
-jacobian (dbulk, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 816
-jacobian (dbulk, flow(b,dbulk)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dbulk, flow(bi,dbulk)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (flow(sbulk,bi), bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (flow(sbulk,bi), sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (flow(sbulk,bi), flow(sbulk,bi)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (flow(sbulk,b), b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (flow(sbulk,b), sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (flow(sbulk,b), flow(sbulk,b)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (flow(b,bi), b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (flow(b,bi), bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (flow(b,bi), flow(b,bi)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (flow(b,dbulk), b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (flow(b,dbulk), dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (flow(b,dbulk), flow(b,dbulk)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (flow(bi,dbulk), bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (flow(bi,dbulk), dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (flow(bi,dbulk), flow(bi,dbulk)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
+jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (g, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (b, flow(sbulk,b)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (b, flow(b,bi)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (b, flow(b,dbulk)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (di, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (di, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (di, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (si, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (si, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gi, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gi, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gm, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (gm, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (gm, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (gm, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (gm, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (gm, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (bi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bi, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (bi, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bi, flow(sbulk,bi)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (bi, flow(b,bi)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (bi, flow(bi,dbulk)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (sbulk, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (sbulk, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (sbulk, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (sbulk, flow(sbulk,bi)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (sbulk, flow(sbulk,b)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dbulk, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (dbulk, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (dbulk, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (dbulk, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (dbulk, flow(b,dbulk)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dbulk, flow(bi,dbulk)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (flow(sbulk,bi), bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (flow(sbulk,bi), sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (flow(sbulk,bi), flow(sbulk,bi)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (flow(sbulk,b), b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (flow(sbulk,b), sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (flow(sbulk,b), flow(sbulk,b)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (flow(b,bi), b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (flow(b,bi), bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (flow(b,bi), flow(b,bi)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (flow(b,dbulk), b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (flow(b,dbulk), dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (flow(b,dbulk), flow(b,dbulk)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (flow(bi,dbulk), bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (flow(bi,dbulk), dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (flow(bi,dbulk), flow(bi,dbulk)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
 collapsible (s, si)
 collapsible (d, di)
 collapsible (g, gm)
@@ -1929,5 +1913,3 @@ noise "Rbulk" (flow(bi,dbulk), gnd)
 noise "Rg" (gi, g)
 0 states
 has bound_step false
-instance size 4256
-model size 7208
diff --git a/openvaf/test_data/osdi/bsim6.snap b/openvaf/test_data/osdi/bsim6.snap
index 7c529881f..7a012a353 100644
--- a/openvaf/test_data/osdi/bsim6.snap
+++ b/openvaf/test_data/osdi/bsim6.snap
@@ -1786,115 +1786,101 @@ param "DVT2EDGE"
 units = "", desc = "Body-bias coefficient for SCE effect for Edge FET", flags = ParameterFlags(0x0)
 
 5 terminals
-node "d" units = "V", runits = ""
-residual 3376 4294967295 4294967295 4294967295
-node "g" units = "V", runits = ""
-residual 3384 4294967295 4294967295 4294967295
-node "s" units = "V", runits = ""
-residual 3392 4294967295 4294967295 4294967295
-node "b" units = "V", runits = ""
-residual 3400 4294967295 4294967295 4294967295
-node "t" units = "K", runits = ""
-residual 3408 3416 4294967295 4294967295
-node "di" units = "V", runits = ""
-residual 3424 3432 4294967295 4294967295
-node "si" units = "V", runits = ""
-residual 3440 3448 4294967295 4294967295
-node "gi" units = "V", runits = ""
-residual 3456 3464 4294967295 4294967295
-node "gm" units = "V", runits = ""
-residual 3472 3480 4294967295 4294967295
-node "bi" units = "V", runits = ""
-residual 3488 3496 4294967295 4294967295
-node "sbulk" units = "V", runits = ""
-residual 3504 3512 4294967295 4294967295
-node "dbulk" units = "V", runits = ""
-residual 3520 3528 4294967295 4294967295
-node "N1" units = "V", runits = ""
-residual 4294967295 4294967295 4294967295 4294967295
-node "N2" units = "V", runits = ""
-residual 4294967295 4294967295 4294967295 4294967295
-jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (g, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (g, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (g, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (g, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (g, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (g, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (b, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (b, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (b, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (t, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (t, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (t, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 656
-jacobian (t, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (t, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (t, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (t, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (di, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (di, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 664
-jacobian (di, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 672
-jacobian (di, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 680
-jacobian (di, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 688
-jacobian (di, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 696
-jacobian (di, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 704
-jacobian (di, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 712
-jacobian (di, N2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (si, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 720
-jacobian (si, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 728
-jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 736
-jacobian (si, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 744
-jacobian (si, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 752
-jacobian (si, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 760
-jacobian (si, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 768
-jacobian (si, N2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (gi, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 776
-jacobian (gi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 784
-jacobian (gi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 792
-jacobian (gi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 800
-jacobian (gi, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (gi, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 808
-jacobian (gm, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (gm, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 816
-jacobian (gm, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 824
-jacobian (gm, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 832
-jacobian (gm, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (gm, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 840
-jacobian (gm, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 848
-jacobian (bi, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (bi, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 856
-jacobian (bi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 864
-jacobian (bi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 872
-jacobian (bi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 880
-jacobian (bi, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 888
-jacobian (bi, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 896
-jacobian (bi, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 904
-jacobian (bi, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 912
-jacobian (sbulk, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (sbulk, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 920
-jacobian (sbulk, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 928
-jacobian (sbulk, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (sbulk, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 936
-jacobian (dbulk, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dbulk, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 944
-jacobian (dbulk, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 952
-jacobian (dbulk, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dbulk, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 960
-jacobian (N1, N1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (N1, N2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (N2, N2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
+node "d" units = "V", runits = "A"
+node "g" units = "V", runits = "A"
+node "s" units = "V", runits = "A"
+node "b" units = "V", runits = "A"
+node "t" units = "K", runits = "W"
+node "di" units = "V", runits = "A"
+node "si" units = "V", runits = "A"
+node "gi" units = "V", runits = "A"
+node "gm" units = "V", runits = "A"
+node "bi" units = "V", runits = "A"
+node "sbulk" units = "V", runits = "A"
+node "dbulk" units = "V", runits = "A"
+node "N1" units = "V", runits = "A"
+node "N2" units = "V", runits = "A"
+jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (g, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (g, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (g, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (g, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (g, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (g, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (b, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (b, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (b, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (t, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (t, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (t, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (t, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (t, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (t, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (t, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (di, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (di, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (di, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, N2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (si, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (si, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, N2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (gi, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gi, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (gi, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gm, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (gm, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gm, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gm, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gm, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (gm, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gm, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bi, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (bi, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bi, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (bi, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bi, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bi, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (sbulk, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (sbulk, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (sbulk, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (sbulk, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (sbulk, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (dbulk, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dbulk, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (dbulk, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (dbulk, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dbulk, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (N1, N1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (N1, N2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (N2, N2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST)
 collapsible (d, di)
 collapsible (s, si)
 collapsible (g, gm)
@@ -1921,5 +1907,3 @@ noise "rbdb" (b, dbulk)
 noise "rbpd" (bi, dbulk)
 0 states
 has bound_step false
-instance size 4480
-model size 7176
diff --git a/openvaf/test_data/osdi/bsimbulk.snap b/openvaf/test_data/osdi/bsimbulk.snap
index 2ae7496e9..93bf12b81 100644
--- a/openvaf/test_data/osdi/bsimbulk.snap
+++ b/openvaf/test_data/osdi/bsimbulk.snap
@@ -2094,127 +2094,113 @@ param "DELTAII"
 units = "V", desc = "Smoothing parameter", flags = ParameterFlags(0x0)
 
 5 terminals
-node "d" units = "V", runits = ""
-residual 4080 4294967295 4294967295 4294967295
-node "g" units = "V", runits = ""
-residual 4088 4294967295 4294967295 4294967295
-node "s" units = "V", runits = ""
-residual 4096 4294967295 4294967295 4294967295
-node "b" units = "V", runits = ""
-residual 4104 4294967295 4294967295 4294967295
-node "t" units = "K", runits = ""
-residual 4112 4120 4294967295 4294967295
-node "di" units = "V", runits = ""
-residual 4128 4136 4294967295 4294967295
-node "si" units = "V", runits = ""
-residual 4144 4152 4294967295 4294967295
-node "gi" units = "V", runits = ""
-residual 4160 4168 4294967295 4294967295
-node "gm" units = "V", runits = ""
-residual 4176 4184 4294967295 4294967295
-node "bi" units = "V", runits = ""
-residual 4192 4200 4294967295 4294967295
-node "sbulk" units = "V", runits = ""
-residual 4208 4216 4294967295 4294967295
-node "dbulk" units = "V", runits = ""
-residual 4224 4232 4294967295 4294967295
-node "N1" units = "V", runits = ""
-residual 4240 4248 4294967295 4294967295
-node "N2" units = "V", runits = ""
-residual 4294967295 4294967295 4294967295 4294967295
-jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (g, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (g, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (g, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (g, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (g, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (g, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (b, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (b, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (b, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (t, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (t, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (t, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 752
-jacobian (t, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (t, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (t, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (t, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (di, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (di, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 760
-jacobian (di, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 768
-jacobian (di, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 776
-jacobian (di, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 784
-jacobian (di, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 792
-jacobian (di, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 800
-jacobian (di, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 808
-jacobian (di, N1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 816
-jacobian (di, N2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (si, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (si, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 824
-jacobian (si, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 832
-jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 840
-jacobian (si, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 848
-jacobian (si, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 856
-jacobian (si, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 864
-jacobian (si, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 872
-jacobian (si, N1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 880
-jacobian (si, N2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (gi, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 888
-jacobian (gi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 896
-jacobian (gi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 904
-jacobian (gi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 912
-jacobian (gi, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (gi, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 920
-jacobian (gi, N1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 928
-jacobian (gm, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (gm, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 936
-jacobian (gm, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 944
-jacobian (gm, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 952
-jacobian (gm, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (gm, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 960
-jacobian (gm, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 968
-jacobian (bi, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (bi, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (bi, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 976
-jacobian (bi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 984
-jacobian (bi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 992
-jacobian (bi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1000
-jacobian (bi, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1008
-jacobian (bi, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1016
-jacobian (bi, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1024
-jacobian (bi, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1032
-jacobian (sbulk, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (sbulk, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1040
-jacobian (sbulk, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1048
-jacobian (sbulk, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (sbulk, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1056
-jacobian (dbulk, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dbulk, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1064
-jacobian (dbulk, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1072
-jacobian (dbulk, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dbulk, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1080
-jacobian (N1, t) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1088
-jacobian (N1, di) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1096
-jacobian (N1, si) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1104
-jacobian (N1, gi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1112
-jacobian (N1, bi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1120
-jacobian (N1, N1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1128
-jacobian (N1, N2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (N2, N2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
+node "d" units = "V", runits = "A"
+node "g" units = "V", runits = "A"
+node "s" units = "V", runits = "A"
+node "b" units = "V", runits = "A"
+node "t" units = "K", runits = "W"
+node "di" units = "V", runits = "A"
+node "si" units = "V", runits = "A"
+node "gi" units = "V", runits = "A"
+node "gm" units = "V", runits = "A"
+node "bi" units = "V", runits = "A"
+node "sbulk" units = "V", runits = "A"
+node "dbulk" units = "V", runits = "A"
+node "N1" units = "V", runits = "A"
+node "N2" units = "V", runits = "A"
+jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (g, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (g, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (g, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (g, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (g, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (g, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (b, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (b, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (b, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (t, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (t, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (t, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (t, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (t, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (t, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (t, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (di, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (di, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (di, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, N1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (di, N2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (si, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (si, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (si, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, N1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (si, N2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (gi, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gi, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (gi, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gi, N1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (gm, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (gm, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gm, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gm, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gm, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (gm, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gm, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bi, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (bi, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (bi, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bi, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (bi, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bi, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bi, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (sbulk, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (sbulk, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (sbulk, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (sbulk, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (sbulk, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (dbulk, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dbulk, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (dbulk, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (dbulk, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dbulk, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (N1, t) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (N1, di) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (N1, si) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (N1, gi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (N1, bi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (N1, N1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (N1, N2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (N2, N2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST)
 collapsible (t, gnd)
 collapsible (N1, gnd)
 collapsible (d, di)
@@ -2244,5 +2230,3 @@ noise "rbdb" (b, dbulk)
 noise "rbpd" (bi, dbulk)
 0 states
 has bound_step false
-instance size 5336
-model size 8424
diff --git a/openvaf/test_data/osdi/bsimcmg.snap b/openvaf/test_data/osdi/bsimcmg.snap
index 10f2bd8f5..babb19001 100644
--- a/openvaf/test_data/osdi/bsimcmg.snap
+++ b/openvaf/test_data/osdi/bsimcmg.snap
@@ -2130,99 +2130,88 @@ param "ALPHA_UFCM"
 units = "", desc = "Mobile charge scaling term taking QM effects into account", flags = ParameterFlags(0x0)
 
 5 terminals
-node "d" units = "V", runits = ""
-residual 4320 4328 4294967295 4294967295
-node "g" units = "V", runits = ""
-residual 4336 4294967295 4294967295 4294967295
-node "s" units = "V", runits = ""
-residual 4344 4352 4294967295 4294967295
-node "e" units = "V", runits = ""
-residual 4360 4368 4294967295 4294967295
-node "t" units = "K", runits = ""
-residual 4376 4384 4294967295 4294967295
-node "di" units = "V", runits = ""
-residual 4392 4400 4294967295 4294967295
-node "si" units = "V", runits = ""
-residual 4408 4416 4294967295 4294967295
-node "ge" units = "V", runits = ""
-residual 4424 4432 4294967295 4294967295
-node "gi" units = "V", runits = ""
-residual 4440 4448 4294967295 4294967295
-node "q" units = "V", runits = ""
-residual 4456 4464 4294967295 4294967295
-node "n" units = "V", runits = ""
-residual 4472 4294967295 4294967295 4294967295
-jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 576
-jacobian (d, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 584
-jacobian (d, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 592
-jacobian (d, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, ge) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 600
-jacobian (d, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (g, ge) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 608
-jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 616
-jacobian (s, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 624
-jacobian (s, ge) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 632
-jacobian (s, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (e, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 640
-jacobian (e, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 648
-jacobian (e, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 656
-jacobian (e, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 664
-jacobian (e, ge) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 672
-jacobian (e, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 680
-jacobian (t, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (t, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (t, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (t, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 688
-jacobian (t, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (t, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (t, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (di, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (di, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 696
-jacobian (di, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 704
-jacobian (di, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 712
-jacobian (di, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 720
-jacobian (di, ge) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 728
-jacobian (di, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 736
-jacobian (di, q) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (di, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 744
-jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (si, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 752
-jacobian (si, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 760
-jacobian (si, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 768
-jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 776
-jacobian (si, ge) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 784
-jacobian (si, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 792
-jacobian (si, q) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (si, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 800
-jacobian (ge, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 808
-jacobian (ge, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (ge, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 816
-jacobian (ge, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 824
-jacobian (ge, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 832
-jacobian (ge, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 840
-jacobian (ge, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 848
-jacobian (ge, ge) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 856
-jacobian (ge, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (gi, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 864
-jacobian (gi, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 872
-jacobian (gi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 880
-jacobian (gi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 888
-jacobian (gi, ge) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (gi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 896
-jacobian (gi, q) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (gi, n) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 904
-jacobian (q, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 912
-jacobian (q, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 920
-jacobian (q, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 928
-jacobian (q, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 936
-jacobian (q, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 944
-jacobian (q, q) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 952
-jacobian (n, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
+node "d" units = "V", runits = "A"
+node "g" units = "V", runits = "A"
+node "s" units = "V", runits = "A"
+node "e" units = "V", runits = "A"
+node "t" units = "K", runits = "W"
+node "di" units = "V", runits = "A"
+node "si" units = "V", runits = "A"
+node "ge" units = "V", runits = "A"
+node "gi" units = "V", runits = "A"
+node "q" units = "V", runits = "A"
+node "n" units = "V", runits = "A"
+jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (d, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (d, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (d, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, ge) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (d, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (g, ge) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (s, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (s, ge) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (s, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (e, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (e, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (e, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (e, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (e, ge) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (e, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (t, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (t, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (t, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (t, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (t, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (t, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (t, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (di, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (di, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, ge) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (di, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, q) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (di, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (si, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, ge) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (si, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, q) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (si, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (ge, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (ge, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (ge, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (ge, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (ge, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (ge, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (ge, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (ge, ge) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (ge, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (gi, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gi, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gi, ge) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (gi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gi, q) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (gi, n) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (q, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (q, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (q, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (q, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (q, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (q, q) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (n, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
 collapsible (d, di)
 collapsible (s, si)
 collapsible (ge, gi)
@@ -2246,5 +2235,3 @@ noise "rg" (g, ge)
 noise "corl" (n, gnd)
 0 states
 has bound_step false
-instance size 5336
-model size 8584
diff --git a/openvaf/test_data/osdi/bsimimg.snap b/openvaf/test_data/osdi/bsimimg.snap
index a5cf5e8fd..2ec36642b 100644
--- a/openvaf/test_data/osdi/bsimimg.snap
+++ b/openvaf/test_data/osdi/bsimimg.snap
@@ -1522,75 +1522,66 @@ param "PQSREF"
 units = "", desc = "P-term of QSREF", flags = ParameterFlags(0x0)
 
 5 terminals
-node "d" units = "V", runits = ""
-residual 2888 4294967295 4294967295 4294967295
-node "fg" units = "V", runits = ""
-residual 2896 4294967295 4294967295 4294967295
-node "s" units = "V", runits = ""
-residual 2904 4294967295 4294967295 4294967295
-node "bg" units = "V", runits = ""
-residual 4294967295 2912 4294967295 4294967295
-node "t" units = "K", runits = ""
-residual 2920 2928 4294967295 4294967295
-node "di" units = "V", runits = ""
-residual 2936 2944 4294967295 4294967295
-node "si" units = "V", runits = ""
-residual 2952 2960 4294967295 4294967295
-node "ge" units = "V", runits = ""
-residual 2968 2976 4294967295 4294967295
-node "gi" units = "V", runits = ""
-residual 2984 2992 4294967295 4294967295
-jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, bg) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (fg, fg) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (fg, ge) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, bg) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (bg, bg) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 416
-jacobian (bg, t) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 424
-jacobian (bg, di) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 432
-jacobian (bg, si) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 440
-jacobian (bg, gi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 448
-jacobian (t, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (t, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (t, bg) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (t, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 456
-jacobian (t, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (t, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (t, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (di, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (di, bg) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 464
-jacobian (di, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 472
-jacobian (di, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 480
-jacobian (di, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 488
-jacobian (di, ge) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 496
-jacobian (di, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 504
-jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (si, bg) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 512
-jacobian (si, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 520
-jacobian (si, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 528
-jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 536
-jacobian (si, ge) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 544
-jacobian (si, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 552
-jacobian (ge, fg) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (ge, bg) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 560
-jacobian (ge, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 568
-jacobian (ge, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 576
-jacobian (ge, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 584
-jacobian (ge, ge) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 592
-jacobian (ge, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (gi, bg) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 600
-jacobian (gi, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 608
-jacobian (gi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 616
-jacobian (gi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 624
-jacobian (gi, ge) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (gi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 632
+node "d" units = "V", runits = "A"
+node "fg" units = "V", runits = "A"
+node "s" units = "V", runits = "A"
+node "bg" units = "V", runits = "A"
+node "t" units = "K", runits = "W"
+node "di" units = "V", runits = "A"
+node "si" units = "V", runits = "A"
+node "ge" units = "V", runits = "A"
+node "gi" units = "V", runits = "A"
+jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, bg) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (fg, fg) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (fg, ge) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, bg) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (bg, bg) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (bg, t) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (bg, di) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (bg, si) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (bg, gi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (t, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (t, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (t, bg) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (t, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (t, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (t, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (t, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (di, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (di, bg) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, ge) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (di, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (si, bg) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, ge) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (si, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (ge, fg) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (ge, bg) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (ge, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (ge, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (ge, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (ge, ge) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (ge, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (gi, bg) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gi, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gi, ge) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (gi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
 collapsible (d, di)
 collapsible (s, si)
 collapsible (ge, gi)
@@ -1609,5 +1600,3 @@ noise "Rs" (s, si)
 noise "Rg" (fg, ge)
 0 states
 has bound_step false
-instance size 3648
-model size 6144
diff --git a/openvaf/test_data/osdi/bsimsoi.snap b/openvaf/test_data/osdi/bsimsoi.snap
index 782853d82..66767aabc 100644
--- a/openvaf/test_data/osdi/bsimsoi.snap
+++ b/openvaf/test_data/osdi/bsimsoi.snap
@@ -1994,128 +1994,115 @@ param "VTM00"
 units = "V", desc = "Hard coded 25 degC thermal voltage", flags = ParameterFlags(0x0)
 
 7 terminals
-node "d" units = "V", runits = ""
-residual 4664 4294967295 4294967295 4294967295
-node "g" units = "V", runits = ""
-residual 4672 4294967295 4294967295 4294967295
-node "s" units = "V", runits = ""
-residual 4680 4294967295 4294967295 4294967295
-node "e" units = "V", runits = ""
-residual 4294967295 4688 4294967295 4294967295
-node "p" units = "V", runits = ""
-residual 4696 4704 4294967295 4294967295
-node "b" units = "V", runits = ""
-residual 4712 4720 4294967295 4294967295
-node "t" units = "K", runits = ""
-residual 4728 4736 4294967295 4294967295
-node "di" units = "V", runits = ""
-residual 4744 4752 4294967295 4294967295
-node "si" units = "V", runits = ""
-residual 4760 4768 4294967295 4294967295
-node "gi" units = "V", runits = ""
-residual 4776 4784 4294967295 4294967295
-node "gm" units = "V", runits = ""
-residual 4792 4800 4294967295 4294967295
-node "sb" units = "V", runits = ""
-residual 4808 4816 4294967295 4294967295
-node "db" units = "V", runits = ""
-residual 4824 4832 4294967295 4294967295
-jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (g, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (e, e) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 776
-jacobian (e, p) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 784
-jacobian (e, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 792
-jacobian (e, t) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 800
-jacobian (e, di) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 808
-jacobian (e, si) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 816
-jacobian (e, gi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 824
-jacobian (e, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 832
-jacobian (p, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (p, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 840
-jacobian (p, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 848
-jacobian (p, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 856
-jacobian (p, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (p, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (p, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (b, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 864
-jacobian (b, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 872
-jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 880
-jacobian (b, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 888
-jacobian (b, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 896
-jacobian (b, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 904
-jacobian (b, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 912
-jacobian (b, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 920
-jacobian (b, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (b, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (t, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (t, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 928
-jacobian (t, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 936
-jacobian (t, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 944
-jacobian (t, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (t, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (t, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (di, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (di, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 952
-jacobian (di, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 960
-jacobian (di, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 968
-jacobian (di, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 976
-jacobian (di, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 984
-jacobian (di, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 992
-jacobian (di, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1000
-jacobian (di, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1008
-jacobian (di, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (di, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1016
-jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (si, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1024
-jacobian (si, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1032
-jacobian (si, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1040
-jacobian (si, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1048
-jacobian (si, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1056
-jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1064
-jacobian (si, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1072
-jacobian (si, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1080
-jacobian (si, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1088
-jacobian (si, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (gi, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1096
-jacobian (gi, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1104
-jacobian (gi, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1112
-jacobian (gi, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1120
-jacobian (gi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1128
-jacobian (gi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1136
-jacobian (gi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1144
-jacobian (gi, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1152
-jacobian (gm, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (gm, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1160
-jacobian (gm, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (gm, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (gm, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (gm, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1168
-jacobian (gm, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1176
-jacobian (gm, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1184
-jacobian (gm, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1192
-jacobian (sb, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1200
-jacobian (sb, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1208
-jacobian (sb, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1216
-jacobian (sb, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1224
-jacobian (sb, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1232
-jacobian (db, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1240
-jacobian (db, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1248
-jacobian (db, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1256
-jacobian (db, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1264
-jacobian (db, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1272
+node "d" units = "V", runits = "A"
+node "g" units = "V", runits = "A"
+node "s" units = "V", runits = "A"
+node "e" units = "V", runits = "A"
+node "p" units = "V", runits = "A"
+node "b" units = "V", runits = "A"
+node "t" units = "K", runits = "W"
+node "di" units = "V", runits = "A"
+node "si" units = "V", runits = "A"
+node "gi" units = "V", runits = "A"
+node "gm" units = "V", runits = "A"
+node "sb" units = "V", runits = "A"
+node "db" units = "V", runits = "A"
+jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (g, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (e, e) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (e, p) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (e, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (e, t) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (e, di) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (e, si) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (e, gi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (e, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (p, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (p, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (p, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (p, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (p, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (p, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (p, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (b, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (b, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (b, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (b, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (b, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (b, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (b, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (b, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (b, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (t, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (t, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (t, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (t, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (t, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (t, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (t, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (di, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (di, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (di, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (di, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (si, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (si, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (gi, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gi, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gi, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gi, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gi, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gm, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (gm, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gm, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (gm, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (gm, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (gm, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gm, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gm, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gm, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (sb, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (sb, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (sb, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (sb, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (sb, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (db, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (db, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (db, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (db, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (db, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
 collapsible (b, gnd)
 collapsible (p, gnd)
 collapsible (d, di)
@@ -2145,5 +2132,3 @@ noise "rbdb" (b, db)
 noise "rbsb" (b, sb)
 0 states
 has bound_step false
-instance size 6064
-model size 8024
diff --git a/openvaf/test_data/osdi/cccs.snap b/openvaf/test_data/osdi/cccs.snap
index 4381d66ee..24d8b67fe 100644
--- a/openvaf/test_data/osdi/cccs.snap
+++ b/openvaf/test_data/osdi/cccs.snap
@@ -8,27 +8,21 @@ param "Rout"
 units = "Ohm", desc = "output Resistance", flags = ParameterFlags(0x0)
 
 4 terminals
-node "Inp" units = "V", runits = ""
-residual 184 4294967295 4294967295 4294967295
-node "Inm" units = "V", runits = ""
-residual 192 4294967295 4294967295 4294967295
-node "Outp" units = "V", runits = ""
-residual 200 4294967295 4294967295 4294967295
-node "Outm" units = "V", runits = ""
-residual 208 4294967295 4294967295 4294967295
-node(flow) "flow(br_in)" units = "A", runits = ""
-residual 216 4294967295 4294967295 4294967295
-jacobian (Inp, flow(br_in)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (Inm, flow(br_in)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (Outp, Outp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (Outp, Outm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (Outm, Outp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (Outm, Outm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (Outm, flow(br_in)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (flow(br_in), Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (flow(br_in), Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (flow(br_in), flow(br_in)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
+node "Inp" units = "V", runits = "A"
+node "Inm" units = "V", runits = "A"
+node "Outp" units = "V", runits = "A"
+node "Outm" units = "V", runits = "A"
+node(flow) "flow(br_in)" units = "A", runits = "A"
+jacobian (Inp, flow(br_in)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (Inm, flow(br_in)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (Outp, Outp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (Outp, Outm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (Outp, flow(br_in)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (Outm, Outp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (Outm, Outm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (Outm, flow(br_in)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (flow(br_in), Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (flow(br_in), Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (flow(br_in), flow(br_in)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST)
 0 states
 has bound_step false
-instance size 224
-model size 40
diff --git a/openvaf/test_data/osdi/current_source.snap b/openvaf/test_data/osdi/current_source.snap
index 6861586b8..4a5fa09fb 100644
--- a/openvaf/test_data/osdi/current_source.snap
+++ b/openvaf/test_data/osdi/current_source.snap
@@ -6,15 +6,11 @@ param "R"
 units = "Ohm", desc = "Output Resistance", flags = ParameterFlags(0x0)
 
 2 terminals
-node "Np" units = "V", runits = ""
-residual 88 4294967295 4294967295 4294967295
-node "Nm" units = "V", runits = ""
-residual 96 4294967295 4294967295 4294967295
-jacobian (Np, Np) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (Np, Nm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (Nm, Np) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (Nm, Nm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
+node "Np" units = "V", runits = "A"
+node "Nm" units = "V", runits = "A"
+jacobian (Np, Np) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (Np, Nm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (Nm, Np) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (Nm, Nm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
 0 states
 has bound_step false
-instance size 104
-model size 32
diff --git a/openvaf/test_data/osdi/diode.snap b/openvaf/test_data/osdi/diode.snap
index e56adf83c..f71194ff1 100644
--- a/openvaf/test_data/osdi/diode.snap
+++ b/openvaf/test_data/osdi/diode.snap
@@ -28,33 +28,27 @@ param "minr"
 units = "Ohm", desc = "minr is the value below which the simulator expects elimination of resitance and it will improve simulation efficiency without significantly altering the results.", flags = ParameterFlags(0x0)
 
 3 terminals
-node "A" units = "V", runits = ""
-residual 248 256 4294967295 4294967295
-node "C" units = "V", runits = ""
-residual 264 4294967295 4294967295 4294967295
-node "dT" units = "K", runits = ""
-residual 272 4294967295 4294967295 4294967295
-node "CI" units = "V", runits = ""
-residual 280 288 4294967295 4294967295
-jacobian (A, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 120
-jacobian (A, dT) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 128
-jacobian (A, CI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 136
-jacobian (C, C) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (C, dT) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (C, CI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dT, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dT, C) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dT, dT) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dT, CI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (CI, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 144
-jacobian (CI, C) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (CI, dT) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 152
-jacobian (CI, CI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 160
+node "A" units = "V", runits = "A"
+node "C" units = "V", runits = "A"
+node "dT" units = "K", runits = "W"
+node "CI" units = "V", runits = "A"
+jacobian (A, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (A, dT) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (A, CI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (C, C) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (C, dT) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (C, CI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dT, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dT, C) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dT, dT) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dT, CI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (CI, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (CI, C) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (CI, dT) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (CI, CI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
 collapsible (CI, C)
 collapsible (dT, gnd)
 noise "unnamed0" (A, CI)
 noise "unnamed1" (CI, C)
 0 states
 has bound_step false
-instance size 456
-model size 120
diff --git a/openvaf/test_data/osdi/diode_cmc.snap b/openvaf/test_data/osdi/diode_cmc.snap
index fc4644dc2..d86e6c3cc 100644
--- a/openvaf/test_data/osdi/diode_cmc.snap
+++ b/openvaf/test_data/osdi/diode_cmc.snap
@@ -206,40 +206,34 @@ param "MULT"
 units = "", desc = "", flags = ParameterFlags(0x0)
 
 2 terminals
-node "A" units = "V", runits = ""
-residual 1616 1624 4294967295 4294967295
-node "K" units = "V", runits = ""
-residual 1632 4294967295 4294967295 4294967295
-node "AIK" units = "V", runits = ""
-residual 1640 1648 4294967295 4294967295
-node "charge_A" units = "V", runits = ""
-residual 1656 1664 4294967295 4294967295
-node "charge_K" units = "V", runits = ""
-residual 1672 1680 4294967295 4294967295
-node "depl_A" units = "V", runits = ""
-residual 1688 1696 4294967295 4294967295
-jacobian (A, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 184
-jacobian (A, AIK) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 192
-jacobian (A, charge_A) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 200
-jacobian (A, charge_K) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 208
-jacobian (A, depl_A) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 216
-jacobian (K, K) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (K, AIK) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (AIK, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 224
-jacobian (AIK, K) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (AIK, AIK) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 232
-jacobian (AIK, charge_A) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 240
-jacobian (AIK, charge_K) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 248
-jacobian (AIK, depl_A) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 256
-jacobian (charge_A, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (charge_A, AIK) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (charge_A, charge_A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 264
-jacobian (charge_K, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (charge_K, AIK) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (charge_K, charge_K) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 272
-jacobian (depl_A, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (depl_A, AIK) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (depl_A, depl_A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 280
+node "A" units = "V", runits = "A"
+node "K" units = "V", runits = "A"
+node "AIK" units = "V", runits = "A"
+node "charge_A" units = "V", runits = "A"
+node "charge_K" units = "V", runits = "A"
+node "depl_A" units = "V", runits = "A"
+jacobian (A, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (A, AIK) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (A, charge_A) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (A, charge_K) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (A, depl_A) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (K, K) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (K, AIK) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (AIK, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (AIK, K) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (AIK, AIK) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (AIK, charge_A) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (AIK, charge_K) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (AIK, depl_A) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (charge_A, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (charge_A, AIK) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (charge_A, charge_A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (charge_K, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (charge_K, AIK) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (charge_K, charge_K) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (depl_A, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (depl_A, AIK) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (depl_A, depl_A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
 collapsible (AIK, K)
 collapsible (charge_A, gnd)
 collapsible (charge_K, gnd)
@@ -249,5 +243,3 @@ noise "flicker" (A, AIK)
 noise "thermal" (AIK, K)
 0 states
 has bound_step false
-instance size 1856
-model size 840
diff --git a/openvaf/test_data/osdi/diode_lim.snap b/openvaf/test_data/osdi/diode_lim.snap
index 260bfdc38..ff1c50b3e 100644
--- a/openvaf/test_data/osdi/diode_lim.snap
+++ b/openvaf/test_data/osdi/diode_lim.snap
@@ -29,30 +29,24 @@ units = "Ohm", desc = "minr is the value below which the simulator expects elimi
 
 3 terminals
 node "A" units = "V", runits = "A"
-residual 216 224 232 240
 node "C" units = "V", runits = "A"
-residual 248 4294967295 4294967295 4294967295
 node "dT" units = "K", runits = "W"
-residual 256 4294967295 264 4294967295
 node "CI" units = "V", runits = "A"
-residual 272 280 288 296
-jacobian (A, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 120
-jacobian (A, dT) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (A, CI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 128
-jacobian (C, C) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (C, dT) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (C, CI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dT, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dT, C) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dT, dT) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dT, CI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (CI, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 136
-jacobian (CI, C) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (CI, dT) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (CI, CI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 144
+jacobian (A, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (A, dT) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (A, CI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (C, C) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (C, dT) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (C, CI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dT, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dT, C) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dT, dT) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dT, CI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (CI, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (CI, C) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (CI, dT) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (CI, CI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
 collapsible (CI, C)
 collapsible (dT, gnd)
 1 states
 has bound_step false
-instance size 400
-model size 120
diff --git a/openvaf/test_data/osdi/ekv.snap b/openvaf/test_data/osdi/ekv.snap
index 0a1553c12..de3e4397b 100644
--- a/openvaf/test_data/osdi/ekv.snap
+++ b/openvaf/test_data/osdi/ekv.snap
@@ -152,53 +152,45 @@ param "tp_njtsswg"
 units = "", desc = "", flags = ParameterFlags(0x0)
 
 4 terminals
-node "d" units = "V", runits = ""
-residual 904 912 4294967295 4294967295
-node "g" units = "V", runits = ""
-residual 4294967295 920 4294967295 4294967295
-node "s" units = "V", runits = ""
-residual 928 936 4294967295 4294967295
-node "b" units = "V", runits = ""
-residual 944 952 4294967295 4294967295
+node "d" units = "V", runits = "A"
+node "g" units = "V", runits = "A"
+node "s" units = "V", runits = "A"
+node "b" units = "V", runits = "A"
 node "implicit_equation_0" units = "", runits = ""
-residual 960 968 4294967295 4294967295
 node "implicit_equation_1" units = "", runits = ""
-residual 976 984 4294967295 4294967295
-jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 264
-jacobian (d, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 272
-jacobian (d, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, implicit_equation_1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (g, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 280
-jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 288
-jacobian (g, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 296
-jacobian (g, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 304
-jacobian (s, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 312
-jacobian (s, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 320
-jacobian (s, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, implicit_equation_1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (b, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 328
-jacobian (b, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 336
-jacobian (b, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 344
-jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 352
-jacobian (b, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (b, implicit_equation_1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (implicit_equation_0, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 360
-jacobian (implicit_equation_0, g) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 368
-jacobian (implicit_equation_0, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 376
-jacobian (implicit_equation_0, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 384
-jacobian (implicit_equation_0, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (implicit_equation_1, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 392
-jacobian (implicit_equation_1, g) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 400
-jacobian (implicit_equation_1, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 408
-jacobian (implicit_equation_1, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 416
-jacobian (implicit_equation_1, implicit_equation_1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
+jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (d, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (d, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, implicit_equation_1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (g, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (g, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (g, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (s, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (s, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (s, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, implicit_equation_1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (b, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (b, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (b, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (b, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (b, implicit_equation_1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (implicit_equation_0, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (implicit_equation_0, g) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (implicit_equation_0, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (implicit_equation_0, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (implicit_equation_0, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (implicit_equation_1, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (implicit_equation_1, g) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (implicit_equation_1, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (implicit_equation_1, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (implicit_equation_1, implicit_equation_1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST)
 noise "thermal" (d, s)
 noise "flicker" (d, s)
 0 states
 has bound_step false
-instance size 1296
-model size 616
diff --git a/openvaf/test_data/osdi/ekv_longchannel.snap b/openvaf/test_data/osdi/ekv_longchannel.snap
index b48dc9170..34ef76b48 100644
--- a/openvaf/test_data/osdi/ekv_longchannel.snap
+++ b/openvaf/test_data/osdi/ekv_longchannel.snap
@@ -16,23 +16,17 @@ param "THETA"
 units = "", desc = "", flags = ParameterFlags(0x0)
 
 4 terminals
-node "d" units = "V", runits = ""
-residual 112 4294967295 4294967295 4294967295
-node "g" units = "V", runits = ""
-residual 4294967295 4294967295 4294967295 4294967295
-node "s" units = "V", runits = ""
-residual 120 4294967295 4294967295 4294967295
-node "b" units = "V", runits = ""
-residual 4294967295 4294967295 4294967295 4294967295
-jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
+node "d" units = "V", runits = "A"
+node "g" units = "V", runits = "A"
+node "s" units = "V", runits = "A"
+node "b" units = "V", runits = "A"
+jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
 0 states
 has bound_step false
-instance size 192
-model size 72
diff --git a/openvaf/test_data/osdi/hicuml2.snap b/openvaf/test_data/osdi/hicuml2.snap
index c45bc9fff..03742c14b 100644
--- a/openvaf/test_data/osdi/hicuml2.snap
+++ b/openvaf/test_data/osdi/hicuml2.snap
@@ -274,134 +274,117 @@ param "type"
 units = "", desc = "", flags = ParameterFlags(PARA_TY_INT)
 
 5 terminals
-node "c" units = "V", runits = ""
-residual 2376 2384 4294967295 4294967295
-node "b" units = "V", runits = ""
-residual 2392 2400 4294967295 4294967295
-node "e" units = "V", runits = ""
-residual 2408 2416 4294967295 4294967295
-node "s" units = "V", runits = ""
-residual 2424 2432 4294967295 4294967295
-node "tnode" units = "V", runits = ""
-residual 2440 2448 4294967295 4294967295
-node "ci" units = "V", runits = ""
-residual 2456 2464 4294967295 4294967295
-node "ei" units = "V", runits = ""
-residual 2472 2480 4294967295 4294967295
-node "bp" units = "V", runits = ""
-residual 2488 2496 4294967295 4294967295
-node "bi" units = "V", runits = ""
-residual 2504 2512 4294967295 4294967295
-node "si" units = "V", runits = ""
-residual 2520 2528 4294967295 4294967295
-node "xf1" units = "V", runits = ""
-residual 2536 2544 4294967295 4294967295
-node "xf2" units = "V", runits = ""
-residual 2552 2560 4294967295 4294967295
-node "xf" units = "V", runits = ""
-residual 2568 2576 4294967295 4294967295
-node "n1" units = "V", runits = ""
-residual 4294967295 4294967295 4294967295 4294967295
-node "n2" units = "V", runits = ""
-residual 4294967295 4294967295 4294967295 4294967295
+node "c" units = "V", runits = "A"
+node "b" units = "V", runits = "A"
+node "e" units = "V", runits = "A"
+node "s" units = "V", runits = "A"
+node "tnode" units = "V", runits = "A"
+node "ci" units = "V", runits = "A"
+node "ei" units = "V", runits = "A"
+node "bp" units = "V", runits = "A"
+node "bi" units = "V", runits = "A"
+node "si" units = "V", runits = "A"
+node "xf1" units = "V", runits = "A"
+node "xf2" units = "V", runits = "A"
+node "xf" units = "V", runits = "A"
+node "n1" units = "V", runits = "A"
+node "n2" units = "V", runits = "A"
 node "implicit_equation_0" units = "", runits = ""
-residual 4294967295 4294967295 4294967295 4294967295
 node "implicit_equation_1" units = "", runits = ""
-residual 4294967295 4294967295 4294967295 4294967295
-jacobian (c, c) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 760
-jacobian (c, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 768
-jacobian (c, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 776
-jacobian (c, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 784
-jacobian (b, e) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 792
-jacobian (b, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 800
-jacobian (b, ci) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 808
-jacobian (b, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (e, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 816
-jacobian (e, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 824
-jacobian (e, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (e, ei) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (e, bp) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 832
-jacobian (s, c) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 840
-jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 848
-jacobian (s, tnode) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 856
-jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 864
-jacobian (tnode, c) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (tnode, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (tnode, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (tnode, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 872
-jacobian (tnode, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (tnode, ei) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (tnode, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (tnode, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (tnode, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (ci, c) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (ci, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 880
-jacobian (ci, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 888
-jacobian (ci, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 896
-jacobian (ci, ei) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 904
-jacobian (ci, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 912
-jacobian (ci, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 920
-jacobian (ci, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 928
-jacobian (ci, xf2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (ci, n2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (ei, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (ei, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 936
-jacobian (ei, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 944
-jacobian (ei, ei) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 952
-jacobian (ei, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 960
-jacobian (ei, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 968
-jacobian (ei, xf2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (ei, xf) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 976
-jacobian (ei, n1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (ei, n2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (ei, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (ei, implicit_equation_1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (bp, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (bp, e) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 984
-jacobian (bp, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 992
-jacobian (bp, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1000
-jacobian (bp, ei) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1008
-jacobian (bp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1016
-jacobian (bp, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1024
-jacobian (bp, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (bi, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1032
-jacobian (bi, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1040
-jacobian (bi, ei) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1048
-jacobian (bi, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1056
-jacobian (bi, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1064
-jacobian (bi, xf) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1072
-jacobian (bi, n1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (bi, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (bi, implicit_equation_1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1080
-jacobian (si, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1088
-jacobian (si, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1096
-jacobian (si, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1104
-jacobian (xf1, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (xf1, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (xf1, ei) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (xf1, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (xf1, xf1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1112
-jacobian (xf1, xf2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (xf2, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (xf2, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (xf2, ei) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (xf2, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (xf2, xf1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (xf2, xf2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1120
-jacobian (xf, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (xf, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (xf, ei) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (xf, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (xf, xf) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1128
-jacobian (n1, n1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (n2, n2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (implicit_equation_0, n1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1136
-jacobian (implicit_equation_0, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (implicit_equation_1, n2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1144
-jacobian (implicit_equation_1, implicit_equation_1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
+jacobian (c, c) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (c, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (c, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (c, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (b, e) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (b, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (b, ci) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (b, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (e, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (e, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (e, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (e, ei) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (e, bp) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (s, c) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (s, tnode) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (tnode, c) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (tnode, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (tnode, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (tnode, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (tnode, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (tnode, ei) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (tnode, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (tnode, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (tnode, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (ci, c) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (ci, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (ci, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (ci, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (ci, ei) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (ci, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (ci, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (ci, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (ci, xf2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (ci, n2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (ei, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (ei, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (ei, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (ei, ei) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (ei, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (ei, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (ei, xf2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (ei, xf) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (ei, n1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (ei, n2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (ei, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (ei, implicit_equation_1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (bp, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (bp, e) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (bp, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bp, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bp, ei) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bp, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bp, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (bi, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bi, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bi, ei) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bi, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bi, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bi, xf) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (bi, n1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (bi, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (bi, implicit_equation_1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (xf1, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (xf1, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (xf1, ei) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (xf1, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (xf1, xf1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (xf1, xf2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (xf2, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (xf2, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (xf2, ei) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (xf2, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (xf2, xf1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (xf2, xf2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (xf, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (xf, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (xf, ei) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (xf, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (xf, xf) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (n1, n1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (n2, n2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (implicit_equation_0, n1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (implicit_equation_0, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (implicit_equation_1, n2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (implicit_equation_1, implicit_equation_1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST)
 collapsible (implicit_equation_0, gnd)
 collapsible (implicit_equation_1, gnd)
 collapsible (b, bp)
@@ -429,5 +412,3 @@ noise "ibei" (n1, gnd)
 noise "it" (n2, gnd)
 0 states
 has bound_step false
-instance size 3560
-model size 1112
diff --git a/openvaf/test_data/osdi/hisim2.snap b/openvaf/test_data/osdi/hisim2.snap
index ca0c37381..0a6cebd61 100644
--- a/openvaf/test_data/osdi/hisim2.snap
+++ b/openvaf/test_data/osdi/hisim2.snap
@@ -1376,94 +1376,81 @@ param "PSLIMPT"
 units = "V", desc = "Ps0 limit for deep punchthrough ", flags = ParameterFlags(0x0)
 
 4 terminals
-node "d" units = "V", runits = ""
-residual 3688 4294967295 4294967295 4294967295
-node "g" units = "V", runits = ""
-residual 3696 4294967295 4294967295 4294967295
-node "s" units = "V", runits = ""
-residual 3704 4294967295 4294967295 4294967295
-node "b" units = "V", runits = ""
-residual 3712 4294967295 4294967295 4294967295
-node "dp" units = "V", runits = ""
-residual 3720 3728 4294967295 4294967295
-node "gp" units = "V", runits = ""
-residual 3736 3744 4294967295 4294967295
-node "sp" units = "V", runits = ""
-residual 3752 3760 4294967295 4294967295
-node "bp" units = "V", runits = ""
-residual 3768 3776 4294967295 4294967295
-node "db" units = "V", runits = ""
-residual 3784 3792 4294967295 4294967295
-node "sb" units = "V", runits = ""
-residual 3800 3808 4294967295 4294967295
-node "n" units = "V", runits = ""
-residual 4294967295 4294967295 4294967295 4294967295
-node "int_nqs_b" units = "V", runits = ""
-residual 3816 3824 4294967295 4294967295
-node "int_nqs_i" units = "V", runits = ""
-residual 3832 3840 4294967295 4294967295
-jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (g, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (b, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (b, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (b, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dp, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dp, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 504
-jacobian (dp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 512
-jacobian (dp, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 520
-jacobian (dp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 528
-jacobian (dp, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 536
-jacobian (dp, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dp, int_nqs_i) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 544
-jacobian (gp, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (gp, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 552
-jacobian (gp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 560
-jacobian (gp, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 568
-jacobian (gp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 576
-jacobian (gp, int_nqs_b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 584
-jacobian (gp, int_nqs_i) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 592
-jacobian (sp, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (sp, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 600
-jacobian (sp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 608
-jacobian (sp, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 616
-jacobian (sp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 624
-jacobian (sp, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 632
-jacobian (sp, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (sp, int_nqs_b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 640
-jacobian (sp, int_nqs_i) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 648
-jacobian (bp, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (bp, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 656
-jacobian (bp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 664
-jacobian (bp, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 672
-jacobian (bp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 680
-jacobian (bp, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 688
-jacobian (bp, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 696
-jacobian (bp, int_nqs_b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 704
-jacobian (bp, int_nqs_i) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 712
-jacobian (db, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (db, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 720
-jacobian (db, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 728
-jacobian (db, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 736
-jacobian (sb, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (sb, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 744
-jacobian (sb, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 752
-jacobian (sb, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 760
-jacobian (n, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (int_nqs_b, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (int_nqs_b, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (int_nqs_b, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (int_nqs_b, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (int_nqs_b, int_nqs_b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 768
-jacobian (int_nqs_i, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (int_nqs_i, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (int_nqs_i, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (int_nqs_i, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (int_nqs_i, int_nqs_i) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 776
+node "d" units = "V", runits = "A"
+node "g" units = "V", runits = "A"
+node "s" units = "V", runits = "A"
+node "b" units = "V", runits = "A"
+node "dp" units = "V", runits = "A"
+node "gp" units = "V", runits = "A"
+node "sp" units = "V", runits = "A"
+node "bp" units = "V", runits = "A"
+node "db" units = "V", runits = "A"
+node "sb" units = "V", runits = "A"
+node "n" units = "V", runits = "A"
+node "int_nqs_b" units = "V", runits = "A"
+node "int_nqs_i" units = "V", runits = "A"
+jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (g, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (b, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (b, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (b, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dp, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dp, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (dp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (dp, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (dp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (dp, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (dp, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dp, int_nqs_i) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (gp, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (gp, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gp, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gp, int_nqs_b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (gp, int_nqs_i) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (sp, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (sp, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (sp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (sp, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (sp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (sp, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (sp, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (sp, int_nqs_b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (sp, int_nqs_i) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (bp, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (bp, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bp, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bp, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bp, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bp, int_nqs_b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (bp, int_nqs_i) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (db, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (db, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (db, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (db, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (sb, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (sb, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (sb, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (sb, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (n, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (int_nqs_b, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (int_nqs_b, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (int_nqs_b, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (int_nqs_b, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (int_nqs_b, int_nqs_b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (int_nqs_i, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (int_nqs_i, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (int_nqs_i, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (int_nqs_i, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (int_nqs_i, int_nqs_i) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
 collapsible (d, dp)
 collapsible (sp, s)
 collapsible (g, gp)
@@ -1480,5 +1467,3 @@ noise "isource" (sp, s)
 noise "unnamed1" (n, gnd)
 0 states
 has bound_step false
-instance size 4416
-model size 5480
diff --git a/openvaf/test_data/osdi/hisimhv.snap b/openvaf/test_data/osdi/hisimhv.snap
index fe0b90252..567eb8fb5 100644
--- a/openvaf/test_data/osdi/hisimhv.snap
+++ b/openvaf/test_data/osdi/hisimhv.snap
@@ -1724,174 +1724,155 @@ param "PVDIFFJS"
 units = "-", desc = "Cross-term dependence of vdiffjs )", flags = ParameterFlags(0x0)
 
 6 terminals
-node "d" units = "V", runits = ""
-residual 5776 5784 4294967295 4294967295
-node "g" units = "V", runits = ""
-residual 5792 4294967295 4294967295 4294967295
-node "s" units = "V", runits = ""
-residual 5800 5808 4294967295 4294967295
-node "b" units = "V", runits = ""
-residual 5816 4294967295 4294967295 4294967295
-node "sub" units = "V", runits = ""
-residual 4294967295 4294967295 4294967295 4294967295
-node "temp" units = "V", runits = ""
-residual 5824 5832 4294967295 4294967295
-node "dp" units = "V", runits = ""
-residual 5840 5848 4294967295 4294967295
-node "gp" units = "V", runits = ""
-residual 5856 5864 4294967295 4294967295
-node "sp" units = "V", runits = ""
-residual 5872 5880 4294967295 4294967295
-node "bp" units = "V", runits = ""
-residual 5888 5896 4294967295 4294967295
-node "db" units = "V", runits = ""
-residual 5904 5912 4294967295 4294967295
-node "sb" units = "V", runits = ""
-residual 5920 5928 4294967295 4294967295
-node "qi" units = "V", runits = ""
-residual 5936 5944 4294967295 4294967295
-node "qb" units = "V", runits = ""
-residual 5952 5960 4294967295 4294967295
-node "qbd" units = "V", runits = ""
-residual 5968 5976 4294967295 4294967295
-node "n" units = "V", runits = ""
-residual 4294967295 4294967295 4294967295 4294967295
-node "charge_A" units = "V", runits = ""
-residual 5984 5992 4294967295 4294967295
-node "charge_K" units = "V", runits = ""
-residual 6000 6008 4294967295 4294967295
-node "depl_A" units = "V", runits = ""
-residual 6016 6024 4294967295 4294967295
-jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1048
-jacobian (d, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1056
-jacobian (d, sub) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1064
-jacobian (d, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1072
-jacobian (d, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1080
-jacobian (d, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1088
-jacobian (d, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1096
-jacobian (d, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1104
-jacobian (d, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1112
-jacobian (d, charge_A) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1120
-jacobian (d, charge_K) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1128
-jacobian (d, depl_A) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1136
-jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (g, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1144
-jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1152
-jacobian (s, sub) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1160
-jacobian (s, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1168
-jacobian (s, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1176
-jacobian (s, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1184
-jacobian (s, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1192
-jacobian (s, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1200
-jacobian (s, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1208
-jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (b, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (temp, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (temp, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (temp, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1216
-jacobian (temp, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (temp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (temp, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (temp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dp, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1224
-jacobian (dp, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1232
-jacobian (dp, sub) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1240
-jacobian (dp, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1248
-jacobian (dp, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1256
-jacobian (dp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1264
-jacobian (dp, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1272
-jacobian (dp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1280
-jacobian (dp, db) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1288
-jacobian (dp, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dp, qi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1296
-jacobian (dp, qbd) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1304
-jacobian (dp, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (gp, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1312
-jacobian (gp, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (gp, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1320
-jacobian (gp, sub) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1328
-jacobian (gp, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1336
-jacobian (gp, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1344
-jacobian (gp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1352
-jacobian (gp, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1360
-jacobian (gp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1368
-jacobian (gp, qi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1376
-jacobian (gp, qb) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1384
-jacobian (gp, qbd) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1392
-jacobian (sp, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1400
-jacobian (sp, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1408
-jacobian (sp, sub) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1416
-jacobian (sp, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1424
-jacobian (sp, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1432
-jacobian (sp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1440
-jacobian (sp, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1448
-jacobian (sp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1456
-jacobian (sp, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1464
-jacobian (sp, qi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1472
-jacobian (sp, qb) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1480
-jacobian (sp, qbd) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1488
-jacobian (sp, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (bp, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1496
-jacobian (bp, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1504
-jacobian (bp, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (bp, sub) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1512
-jacobian (bp, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1520
-jacobian (bp, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1528
-jacobian (bp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1536
-jacobian (bp, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1544
-jacobian (bp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1552
-jacobian (bp, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1560
-jacobian (bp, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1568
-jacobian (bp, qi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1576
-jacobian (bp, qb) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1584
-jacobian (bp, qbd) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1592
-jacobian (db, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1600
-jacobian (db, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1608
-jacobian (db, dp) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1616
-jacobian (db, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1624
-jacobian (db, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1632
-jacobian (db, charge_A) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1640
-jacobian (db, charge_K) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1648
-jacobian (db, depl_A) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1656
-jacobian (sb, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1664
-jacobian (sb, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1672
-jacobian (sb, sp) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1680
-jacobian (sb, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1688
-jacobian (sb, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1696
-jacobian (qi, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (qi, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (qi, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (qi, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (qi, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (qi, qi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1704
-jacobian (qb, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (qb, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (qb, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (qb, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (qb, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (qb, qb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1712
-jacobian (qbd, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (qbd, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (qbd, sub) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (qbd, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (qbd, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (qbd, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (qbd, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (qbd, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (qbd, qbd) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1720
-jacobian (n, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (charge_A, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (charge_A, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (charge_A, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (charge_A, charge_A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1728
-jacobian (charge_K, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (charge_K, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (charge_K, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (charge_K, charge_K) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1736
-jacobian (depl_A, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (depl_A, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (depl_A, depl_A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1744
+node "d" units = "V", runits = "A"
+node "g" units = "V", runits = "A"
+node "s" units = "V", runits = "A"
+node "b" units = "V", runits = "A"
+node "sub" units = "V", runits = "A"
+node "temp" units = "V", runits = "A"
+node "dp" units = "V", runits = "A"
+node "gp" units = "V", runits = "A"
+node "sp" units = "V", runits = "A"
+node "bp" units = "V", runits = "A"
+node "db" units = "V", runits = "A"
+node "sb" units = "V", runits = "A"
+node "qi" units = "V", runits = "A"
+node "qb" units = "V", runits = "A"
+node "qbd" units = "V", runits = "A"
+node "n" units = "V", runits = "A"
+node "charge_A" units = "V", runits = "A"
+node "charge_K" units = "V", runits = "A"
+node "depl_A" units = "V", runits = "A"
+jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (d, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (d, sub) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (d, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (d, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (d, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (d, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (d, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (d, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (d, charge_A) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (d, charge_K) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (d, depl_A) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (g, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (s, sub) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (s, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (s, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (s, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (s, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (s, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (s, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (b, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (temp, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (temp, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (temp, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (temp, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (temp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (temp, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (temp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dp, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (dp, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (dp, sub) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (dp, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (dp, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (dp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (dp, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (dp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (dp, db) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (dp, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dp, qi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (dp, qbd) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (dp, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (gp, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (gp, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (gp, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (gp, sub) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (gp, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gp, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gp, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gp, qi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (gp, qb) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (gp, qbd) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (sp, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (sp, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (sp, sub) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (sp, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (sp, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (sp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (sp, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (sp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (sp, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (sp, qi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (sp, qb) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (sp, qbd) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (sp, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (bp, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bp, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bp, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (bp, sub) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (bp, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bp, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bp, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bp, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bp, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bp, qi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (bp, qb) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (bp, qbd) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (db, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (db, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (db, dp) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (db, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (db, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (db, charge_A) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (db, charge_K) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (db, depl_A) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (sb, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (sb, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (sb, sp) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (sb, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (sb, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (qi, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (qi, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (qi, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (qi, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (qi, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (qi, qi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (qb, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (qb, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (qb, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (qb, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (qb, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (qb, qb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (qbd, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (qbd, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (qbd, sub) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (qbd, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (qbd, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (qbd, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (qbd, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (qbd, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (qbd, qbd) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (n, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (charge_A, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (charge_A, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (charge_A, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (charge_A, charge_A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (charge_K, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (charge_K, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (charge_K, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (charge_K, charge_K) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (depl_A, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (depl_A, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (depl_A, depl_A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
 collapsible (sub, temp)
 collapsible (charge_A, gnd)
 collapsible (charge_K, gnd)
@@ -1915,5 +1896,3 @@ noise "isource" (sp, s)
 noise "unnamed1" (n, gnd)
 0 states
 has bound_step false
-instance size 7424
-model size 6848
diff --git a/openvaf/test_data/osdi/hisimsotb.snap b/openvaf/test_data/osdi/hisimsotb.snap
index 5958633bc..86b29b050 100644
--- a/openvaf/test_data/osdi/hisimsotb.snap
+++ b/openvaf/test_data/osdi/hisimsotb.snap
@@ -632,93 +632,82 @@ param "TN"
 units = "", desc = "", flags = ParameterFlags(0x0)
 
 4 terminals
-node "d" units = "V", runits = ""
-residual 2248 2256 4294967295 4294967295
-node "g" units = "V", runits = ""
-residual 2264 4294967295 4294967295 4294967295
-node "s" units = "V", runits = ""
-residual 2272 2280 4294967295 4294967295
-node "e" units = "V", runits = ""
-residual 4294967295 4294967295 4294967295 4294967295
-node "t" units = "K", runits = ""
-residual 2288 2296 4294967295 4294967295
-node "gp" units = "V", runits = ""
-residual 2304 2312 4294967295 4294967295
-node "bp" units = "V", runits = ""
-residual 2320 2328 4294967295 4294967295
-node "n" units = "V", runits = ""
-residual 4294967295 4294967295 4294967295 4294967295
-node "nqs_qi" units = "V", runits = ""
-residual 2336 2344 4294967295 4294967295
-node "nqs_qb" units = "V", runits = ""
-residual 2352 2360 4294967295 4294967295
-node "nqs_qhs" units = "V", runits = ""
-residual 2368 2376 4294967295 4294967295
-jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 528
-jacobian (d, g) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 536
-jacobian (d, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 544
-jacobian (d, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 552
-jacobian (d, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 560
-jacobian (d, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 568
-jacobian (d, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, nqs_qi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 576
-jacobian (d, nqs_qhs) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 584
-jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (g, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 592
-jacobian (s, g) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 600
-jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 608
-jacobian (s, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 616
-jacobian (s, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 624
-jacobian (s, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 632
-jacobian (s, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, nqs_qi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 640
-jacobian (s, nqs_qb) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 648
-jacobian (s, nqs_qhs) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 656
-jacobian (t, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (t, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (t, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 664
-jacobian (t, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (t, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (t, nqs_qhs) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (gp, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 672
-jacobian (gp, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 680
-jacobian (gp, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 688
-jacobian (gp, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 696
-jacobian (gp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 704
-jacobian (gp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 712
-jacobian (gp, nqs_qi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 720
-jacobian (gp, nqs_qb) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 728
-jacobian (gp, nqs_qhs) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 736
-jacobian (bp, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 744
-jacobian (bp, g) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 752
-jacobian (bp, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 760
-jacobian (bp, t) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 768
-jacobian (bp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 776
-jacobian (bp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 784
-jacobian (bp, nqs_qb) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 792
-jacobian (bp, nqs_qhs) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 800
-jacobian (n, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (nqs_qi, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (nqs_qi, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (nqs_qi, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (nqs_qi, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (nqs_qi, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (nqs_qi, nqs_qi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 808
-jacobian (nqs_qi, nqs_qhs) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (nqs_qb, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (nqs_qb, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (nqs_qb, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (nqs_qb, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (nqs_qb, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (nqs_qb, nqs_qb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 816
-jacobian (nqs_qb, nqs_qhs) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (nqs_qhs, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (nqs_qhs, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (nqs_qhs, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (nqs_qhs, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (nqs_qhs, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (nqs_qhs, nqs_qhs) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 824
+node "d" units = "V", runits = "A"
+node "g" units = "V", runits = "A"
+node "s" units = "V", runits = "A"
+node "e" units = "V", runits = "A"
+node "t" units = "K", runits = "W"
+node "gp" units = "V", runits = "A"
+node "bp" units = "V", runits = "A"
+node "n" units = "V", runits = "A"
+node "nqs_qi" units = "V", runits = "A"
+node "nqs_qb" units = "V", runits = "A"
+node "nqs_qhs" units = "V", runits = "A"
+jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (d, g) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (d, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (d, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (d, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (d, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (d, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, nqs_qi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (d, nqs_qhs) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (g, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (s, g) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (s, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (s, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (s, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (s, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, nqs_qi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (s, nqs_qb) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (s, nqs_qhs) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (t, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (t, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (t, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (t, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (t, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (t, nqs_qhs) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (gp, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gp, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gp, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gp, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gp, nqs_qi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (gp, nqs_qb) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (gp, nqs_qhs) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bp, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bp, g) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (bp, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bp, t) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (bp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (bp, nqs_qb) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (bp, nqs_qhs) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (n, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (nqs_qi, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (nqs_qi, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (nqs_qi, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (nqs_qi, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (nqs_qi, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (nqs_qi, nqs_qi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (nqs_qi, nqs_qhs) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (nqs_qb, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (nqs_qb, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (nqs_qb, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (nqs_qb, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (nqs_qb, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (nqs_qb, nqs_qb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (nqs_qb, nqs_qhs) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (nqs_qhs, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (nqs_qhs, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (nqs_qhs, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (nqs_qhs, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (nqs_qhs, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (nqs_qhs, nqs_qhs) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
 collapsible (g, gp)
 collapsible (e, bp)
 collapsible (t, gnd)
@@ -733,5 +722,3 @@ noise "iigb" (gp, bp)
 noise "unnamed1" (n, gnd)
 0 states
 has bound_step false
-instance size 3056
-model size 2480
diff --git a/openvaf/test_data/osdi/mextram.snap b/openvaf/test_data/osdi/mextram.snap
index 37190cc49..4d1e491e5 100644
--- a/openvaf/test_data/osdi/mextram.snap
+++ b/openvaf/test_data/osdi/mextram.snap
@@ -244,138 +244,130 @@ param "gmin"
 units = "", desc = "Minimum conductance", flags = ParameterFlags(0x0)
 
 5 terminals
-node "c" units = "V", runits = ""
-residual 2616 2624 4294967295 4294967295
-node "b" units = "V", runits = ""
-residual 2632 2640 4294967295 4294967295
-node "e" units = "V", runits = ""
-residual 2648 2656 4294967295 4294967295
-node "s" units = "V", runits = ""
-residual 2664 2672 4294967295 4294967295
-node "dt" units = "V", runits = ""
-residual 2680 2688 4294967295 4294967295
-node "e1" units = "V", runits = ""
-residual 2696 2704 4294967295 4294967295
-node "b1" units = "V", runits = ""
-residual 2712 2720 4294967295 4294967295
-node "b2" units = "V", runits = ""
-residual 2728 2736 4294967295 4294967295
-node "c1" units = "V", runits = ""
-residual 2744 2752 4294967295 4294967295
-node "c2" units = "V", runits = ""
-residual 2760 2768 4294967295 4294967295
-node "c3" units = "V", runits = ""
-residual 2776 2784 4294967295 4294967295
-node "c4" units = "V", runits = ""
-residual 2792 2800 4294967295 4294967295
-node "noi" units = "V", runits = ""
-residual 4294967295 4294967295 4294967295 4294967295
+node "c" units = "V", runits = "A"
+node "b" units = "V", runits = "A"
+node "e" units = "V", runits = "A"
+node "s" units = "V", runits = "A"
+node "dt" units = "V", runits = "A"
+node "e1" units = "V", runits = "A"
+node "b1" units = "V", runits = "A"
+node "b2" units = "V", runits = "A"
+node "c1" units = "V", runits = "A"
+node "c2" units = "V", runits = "A"
+node "c3" units = "V", runits = "A"
+node "c4" units = "V", runits = "A"
+node "noi" units = "V", runits = "A"
 node "implicit_equation_0" units = "", runits = ""
-residual 4294967295 4294967295 4294967295 4294967295
-jacobian (c, c) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 840
-jacobian (c, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 848
-jacobian (c, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (c, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (c, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (c, c3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (c, c4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (b, c) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 856
-jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 864
-jacobian (b, e) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 872
-jacobian (b, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 880
-jacobian (b, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 888
-jacobian (b, b1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 896
-jacobian (b, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 904
-jacobian (b, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 912
-jacobian (b, c3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 920
-jacobian (b, c4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 928
-jacobian (e, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 936
-jacobian (e, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 944
-jacobian (e, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (e, e1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 952
-jacobian (s, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 960
-jacobian (s, b1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 968
-jacobian (s, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, c3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, c4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dt, c) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dt, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dt, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dt, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dt, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 976
-jacobian (dt, e1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dt, b1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dt, b2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dt, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dt, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dt, c3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dt, c4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (e1, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (e1, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 984
-jacobian (e1, e1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 992
-jacobian (e1, b1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1000
-jacobian (e1, b2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1008
-jacobian (e1, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1016
-jacobian (e1, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1024
-jacobian (e1, noi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (e1, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (b1, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (b1, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (b1, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1032
-jacobian (b1, e1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1040
-jacobian (b1, b1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1048
-jacobian (b1, b2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1056
-jacobian (b1, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1064
-jacobian (b1, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1072
-jacobian (b1, c4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1080
-jacobian (b2, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1088
-jacobian (b2, e1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1096
-jacobian (b2, b1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1104
-jacobian (b2, b2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1112
-jacobian (b2, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1120
-jacobian (b2, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1128
-jacobian (b2, noi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (b2, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (c1, c) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (c1, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1136
-jacobian (c1, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1144
-jacobian (c1, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1152
-jacobian (c1, b1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1160
-jacobian (c1, b2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (c1, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1168
-jacobian (c1, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1176
-jacobian (c1, c3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1184
-jacobian (c1, c4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1192
-jacobian (c2, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1200
-jacobian (c2, e1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1208
-jacobian (c2, b2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1216
-jacobian (c2, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1224
-jacobian (c2, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1232
-jacobian (c2, noi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (c3, c) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (c3, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1240
-jacobian (c3, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1248
-jacobian (c3, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1256
-jacobian (c3, b1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1264
-jacobian (c3, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1272
-jacobian (c3, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1280
-jacobian (c3, c3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1288
-jacobian (c3, c4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1296
-jacobian (c4, c) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (c4, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1304
-jacobian (c4, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1312
-jacobian (c4, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1320
-jacobian (c4, b1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1328
-jacobian (c4, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1336
-jacobian (c4, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1344
-jacobian (c4, c3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1352
-jacobian (c4, c4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1360
-jacobian (noi, noi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (implicit_equation_0, noi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 1368
-jacobian (implicit_equation_0, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
+jacobian (c, c) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (c, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (c, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (c, b1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (c, b2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (c, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (c, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (c, c3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (c, c4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (b, c) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (b, e) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (b, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (b, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (b, b1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (b, b2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (b, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (b, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (b, c3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (b, c4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (e, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (e, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (e, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (e, e1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (s, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (s, b1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, b2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (s, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, c3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, c4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dt, c) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dt, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dt, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dt, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dt, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (dt, e1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dt, b1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dt, b2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dt, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dt, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dt, c3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dt, c4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (e1, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (e1, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (e1, e1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (e1, b1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (e1, b2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (e1, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (e1, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (e1, noi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (e1, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (b1, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (b1, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (b1, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (b1, e1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (b1, b1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (b1, b2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (b1, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (b1, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (b1, c4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (b2, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (b2, e1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (b2, b1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (b2, b2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (b2, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (b2, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (b2, noi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (b2, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (c1, c) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (c1, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (c1, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (c1, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (c1, b1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (c1, b2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (c1, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (c1, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (c1, c3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (c1, c4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (c2, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (c2, e1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (c2, b2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (c2, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (c2, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (c2, noi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (c3, c) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (c3, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (c3, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (c3, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (c3, b1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (c3, b2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (c3, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (c3, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (c3, c3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (c3, c4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (c4, c) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (c4, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (c4, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (c4, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (c4, b1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (c4, b2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (c4, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (c4, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (c4, c3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (c4, c4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (noi, noi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (implicit_equation_0, noi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (implicit_equation_0, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST)
 collapsible (c4, c1)
 collapsible (c3, c4)
 noise "ib1e1_f" (b1, e1)
@@ -406,5 +398,3 @@ noise "rcc" (c, c1)
 noise "in" (noi, gnd)
 0 states
 has bound_step false
-instance size 4264
-model size 960
diff --git a/openvaf/test_data/osdi/mvsg_cmc.snap b/openvaf/test_data/osdi/mvsg_cmc.snap
index 809cde9d4..5efafea9c 100644
--- a/openvaf/test_data/osdi/mvsg_cmc.snap
+++ b/openvaf/test_data/osdi/mvsg_cmc.snap
@@ -510,246 +510,221 @@ param "minc"
 units = "F", desc = "Minimum capacitance", flags = ParameterFlags(0x0)
 
 4 terminals
-node "d" units = "V", runits = ""
-residual 3560 3568 4294967295 4294967295
-node "g" units = "V", runits = ""
-residual 3576 4294967295 4294967295 4294967295
-node "s" units = "V", runits = ""
-residual 3584 3592 4294967295 4294967295
-node "b" units = "V", runits = ""
-residual 4294967295 3600 4294967295 4294967295
-node "di" units = "V", runits = ""
-residual 3608 3616 4294967295 4294967295
-node "gi1" units = "V", runits = ""
-residual 3624 3632 4294967295 4294967295
-node "gi2" units = "V", runits = ""
-residual 3640 3648 4294967295 4294967295
-node "si" units = "V", runits = ""
-residual 3656 3664 4294967295 4294967295
-node "fps1" units = "V", runits = ""
-residual 3672 3680 4294967295 4294967295
-node "fps2" units = "V", runits = ""
-residual 3688 3696 4294967295 4294967295
-node "fps3" units = "V", runits = ""
-residual 3704 3712 4294967295 4294967295
-node "fps4" units = "V", runits = ""
-residual 3720 3728 4294967295 4294967295
-node "fp1" units = "V", runits = ""
-residual 3736 3744 4294967295 4294967295
-node "fp2" units = "V", runits = ""
-residual 3752 3760 4294967295 4294967295
-node "fp3" units = "V", runits = ""
-residual 3768 3776 4294967295 4294967295
-node "fp4" units = "V", runits = ""
-residual 3784 3792 4294967295 4294967295
-node "drc" units = "V", runits = ""
-residual 3800 4294967295 4294967295 4294967295
-node "src" units = "V", runits = ""
-residual 3808 4294967295 4294967295 4294967295
-node "tr" units = "V", runits = ""
-residual 3816 3824 4294967295 4294967295
-node "tr1" units = "V", runits = ""
-residual 3832 3840 4294967295 4294967295
-node "xt1" units = "V", runits = ""
-residual 3848 3856 4294967295 4294967295
-node "xt2" units = "V", runits = ""
-residual 3864 3872 4294967295 4294967295
-node "dt" units = "K", runits = ""
-residual 3880 3888 4294967295 4294967295
+node "d" units = "V", runits = "A"
+node "g" units = "V", runits = "A"
+node "s" units = "V", runits = "A"
+node "b" units = "V", runits = "A"
+node "di" units = "V", runits = "A"
+node "gi1" units = "V", runits = "A"
+node "gi2" units = "V", runits = "A"
+node "si" units = "V", runits = "A"
+node "fps1" units = "V", runits = "A"
+node "fps2" units = "V", runits = "A"
+node "fps3" units = "V", runits = "A"
+node "fps4" units = "V", runits = "A"
+node "fp1" units = "V", runits = "A"
+node "fp2" units = "V", runits = "A"
+node "fp3" units = "V", runits = "A"
+node "fp4" units = "V", runits = "A"
+node "drc" units = "V", runits = "A"
+node "src" units = "V", runits = "A"
+node "tr" units = "V", runits = "A"
+node "tr1" units = "V", runits = "A"
+node "xt1" units = "V", runits = "A"
+node "xt2" units = "V", runits = "A"
+node "dt" units = "K", runits = "W"
 node(flow) "flow(d,drc)" units = "A", runits = ""
-residual 3896 4294967295 4294967295 4294967295
 node(flow) "flow(src,s)" units = "A", runits = ""
-residual 3904 4294967295 4294967295 4294967295
-jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1528
-jacobian (d, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1536
-jacobian (d, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1544
-jacobian (d, gi1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1552
-jacobian (d, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (d, flow(d,drc)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (g, gi1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (s, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1560
-jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1568
-jacobian (s, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1576
-jacobian (s, di) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1584
-jacobian (s, gi1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1592
-jacobian (s, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1600
-jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1608
-jacobian (s, fps1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1616
-jacobian (s, fps2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1624
-jacobian (s, fps3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1632
-jacobian (s, fps4) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1640
-jacobian (s, fp1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1648
-jacobian (s, fp2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1656
-jacobian (s, fp3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1664
-jacobian (s, fp4) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1672
-jacobian (s, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1680
-jacobian (s, flow(src,s)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (b, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1688
-jacobian (b, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1696
-jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1704
-jacobian (b, di) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1712
-jacobian (b, gi1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1720
-jacobian (b, fps1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1728
-jacobian (b, fps2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1736
-jacobian (b, fps3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1744
-jacobian (b, fps4) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1752
-jacobian (b, fp1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1760
-jacobian (b, fp2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1768
-jacobian (b, fp3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1776
-jacobian (b, dt) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1784
-jacobian (di, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1792
-jacobian (di, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1800
-jacobian (di, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1808
-jacobian (di, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1816
-jacobian (di, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1824
-jacobian (di, fp1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1832
-jacobian (di, xt2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (di, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1840
-jacobian (gi1, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1848
-jacobian (gi1, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (gi1, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1856
-jacobian (gi1, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1864
-jacobian (gi1, gi1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1872
-jacobian (gi1, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (gi2, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1880
-jacobian (gi2, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1888
-jacobian (gi2, gi1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (gi2, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1896
-jacobian (gi2, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1904
-jacobian (gi2, fps1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1912
-jacobian (gi2, fps2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1920
-jacobian (gi2, fps3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1928
-jacobian (gi2, fps4) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1936
-jacobian (gi2, fp1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1944
-jacobian (gi2, fp2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1952
-jacobian (gi2, fp3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1960
-jacobian (gi2, fp4) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1968
-jacobian (gi2, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1976
-jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1984
-jacobian (si, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1992
-jacobian (si, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2000
-jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2008
-jacobian (si, fps1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2016
-jacobian (si, fps2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 2024
-jacobian (si, fps3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 2032
-jacobian (si, fps4) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 2040
-jacobian (si, fp1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 2048
-jacobian (si, fp2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 2056
-jacobian (si, fp3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 2064
-jacobian (si, xt2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (si, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2072
-jacobian (fps1, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2080
-jacobian (fps1, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 2088
-jacobian (fps1, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2096
-jacobian (fps1, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2104
-jacobian (fps1, fps1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2112
-jacobian (fps1, fps2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2120
-jacobian (fps1, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2128
-jacobian (fps2, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2136
-jacobian (fps2, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 2144
-jacobian (fps2, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2152
-jacobian (fps2, fps1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2160
-jacobian (fps2, fps2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2168
-jacobian (fps2, fps3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2176
-jacobian (fps2, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2184
-jacobian (fps3, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2192
-jacobian (fps3, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 2200
-jacobian (fps3, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2208
-jacobian (fps3, fps2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2216
-jacobian (fps3, fps3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2224
-jacobian (fps3, fps4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2232
-jacobian (fps3, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2240
-jacobian (fps4, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (fps4, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2248
-jacobian (fps4, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 2256
-jacobian (fps4, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2264
-jacobian (fps4, fps3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2272
-jacobian (fps4, fps4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2280
-jacobian (fps4, src) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (fps4, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2288
-jacobian (fp1, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2296
-jacobian (fp1, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 2304
-jacobian (fp1, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2312
-jacobian (fp1, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2320
-jacobian (fp1, fp1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2328
-jacobian (fp1, fp2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2336
-jacobian (fp1, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2344
-jacobian (fp2, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2352
-jacobian (fp2, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 2360
-jacobian (fp2, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2368
-jacobian (fp2, fp1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2376
-jacobian (fp2, fp2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2384
-jacobian (fp2, fp3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2392
-jacobian (fp2, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2400
-jacobian (fp3, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2408
-jacobian (fp3, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 2416
-jacobian (fp3, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2424
-jacobian (fp3, fp2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2432
-jacobian (fp3, fp3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2440
-jacobian (fp3, fp4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2448
-jacobian (fp3, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2456
-jacobian (fp4, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (fp4, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2464
-jacobian (fp4, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2472
-jacobian (fp4, fp3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2480
-jacobian (fp4, fp4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2488
-jacobian (fp4, drc) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (fp4, tr) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (fp4, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2496
-jacobian (drc, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (drc, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (drc, fp4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (drc, drc) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (drc, tr) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (drc, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (drc, flow(d,drc)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (src, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (src, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (src, fps4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (src, src) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (src, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (src, flow(src,s)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (tr, tr) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2504
-jacobian (tr, tr1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 2512
-jacobian (tr1, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (tr1, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (tr1, tr) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 2520
-jacobian (tr1, tr1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 2528
-jacobian (xt1, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (xt1, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (xt1, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (xt1, xt1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 2536
-jacobian (xt1, xt2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (xt1, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (xt2, xt1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (xt2, xt2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2544
-jacobian (dt, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dt, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dt, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dt, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dt, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dt, fps1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dt, fps2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dt, fps3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dt, fps4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dt, fp1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dt, fp2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dt, fp3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dt, fp4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dt, drc) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dt, src) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dt, tr) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (dt, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2552
-jacobian (flow(d,drc), d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (flow(d,drc), drc) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (flow(d,drc), dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (flow(d,drc), flow(d,drc)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (flow(src,s), s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (flow(src,s), src) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (flow(src,s), dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (flow(src,s), flow(src,s)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
+jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (d, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (d, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (d, gi1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (d, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (d, flow(d,drc)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (g, gi1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (s, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (s, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (s, di) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (s, gi1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (s, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (s, fps1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (s, fps2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (s, fps3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (s, fps4) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (s, fp1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (s, fp2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (s, fp3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (s, fp4) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (s, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (s, flow(src,s)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (b, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (b, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (b, di) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (b, gi1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (b, fps1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (b, fps2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (b, fps3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (b, fps4) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (b, fp1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (b, fp2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (b, fp3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (b, dt) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (di, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (di, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, fp1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (di, xt2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (di, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gi1, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (gi1, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (gi1, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (gi1, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (gi1, gi1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gi1, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (gi2, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (gi2, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gi2, gi1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (gi2, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gi2, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (gi2, fps1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (gi2, fps2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (gi2, fps3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (gi2, fps4) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (gi2, fp1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (gi2, fp2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (gi2, fp3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (gi2, fp4) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (gi2, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, fps1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (si, fps2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (si, fps3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (si, fps4) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (si, fp1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (si, fp2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (si, fp3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (si, xt2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (si, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fps1, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fps1, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (fps1, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fps1, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fps1, fps1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fps1, fps2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fps1, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fps2, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fps2, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (fps2, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fps2, fps1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fps2, fps2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fps2, fps3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fps2, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fps3, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fps3, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (fps3, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fps3, fps2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fps3, fps3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fps3, fps4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fps3, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fps4, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (fps4, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fps4, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (fps4, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fps4, fps3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fps4, fps4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fps4, src) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (fps4, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp1, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp1, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (fp1, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp1, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp1, fp1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp1, fp2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp1, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp2, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp2, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (fp2, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp2, fp1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp2, fp2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp2, fp3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp2, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp3, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp3, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (fp3, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp3, fp2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp3, fp3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp3, fp4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp3, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp4, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (fp4, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp4, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp4, fp3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp4, fp4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (fp4, drc) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (fp4, tr) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (fp4, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (drc, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (drc, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (drc, fp4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (drc, drc) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (drc, tr) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (drc, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (drc, flow(d,drc)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (src, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (src, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (src, fps4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (src, src) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (src, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (src, flow(src,s)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (tr, tr) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (tr, tr1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (tr1, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (tr1, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (tr1, tr) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (tr1, tr1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (xt1, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (xt1, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (xt1, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (xt1, xt1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (xt1, xt2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (xt1, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (xt2, xt1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (xt2, xt2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (dt, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dt, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dt, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dt, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dt, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dt, fps1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dt, fps2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dt, fps3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dt, fps4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dt, fp1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dt, fp2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dt, fp3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dt, fp4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dt, drc) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dt, src) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dt, tr) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (dt, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (flow(d,drc), d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (flow(d,drc), drc) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (flow(d,drc), dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (flow(d,drc), flow(d,drc)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (flow(src,s), s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (flow(src,s), src) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (flow(src,s), dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (flow(src,s), flow(src,s)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
 collapsible (tr1, gnd)
 collapsible (tr, gnd)
 collapsible (fp4, fp3)
@@ -787,5 +762,3 @@ noise "rcd" (flow(d,drc), gnd)
 noise "rcs" (flow(src,s), gnd)
 0 states
 has bound_step false
-instance size 5840
-model size 2072
diff --git a/openvaf/test_data/osdi/noise.snap b/openvaf/test_data/osdi/noise.snap
index 2f8a138d0..07cd51887 100644
--- a/openvaf/test_data/osdi/noise.snap
+++ b/openvaf/test_data/osdi/noise.snap
@@ -7,14 +7,10 @@ units = "", desc = "", flags = ParameterFlags(0x0)
 
 2 terminals
 node "a" units = "V", runits = "A"
-residual 4294967295 4294967295 4294967295 4294967295
 node "c" units = "V", runits = "A"
-residual 4294967295 4294967295 4294967295 4294967295
 noise "white1" (a, c)
 noise "white2" (a, c)
 noise "flickr1" (a, c)
 noise "flickr2" (a, c)
 0 states
 has bound_step false
-instance size 96
-model size 32
diff --git a/openvaf/test_data/osdi/psp102.snap b/openvaf/test_data/osdi/psp102.snap
index d8f457c1c..86c84f185 100644
--- a/openvaf/test_data/osdi/psp102.snap
+++ b/openvaf/test_data/osdi/psp102.snap
@@ -636,78 +636,67 @@ param "XGW"
 units = "", desc = "", flags = ParameterFlags(0x0)
 
 4 terminals
-node "D" units = "V", runits = ""
-residual 5088 5096 4294967295 4294967295
-node "G" units = "V", runits = ""
-residual 5104 4294967295 4294967295 4294967295
-node "S" units = "V", runits = ""
-residual 5112 5120 4294967295 4294967295
-node "B" units = "V", runits = ""
-residual 5128 4294967295 4294967295 4294967295
-node "NOI" units = "V", runits = ""
-residual 5136 5144 4294967295 4294967295
-node "NOI2" units = "V", runits = ""
-residual 5152 4294967295 4294967295 4294967295
-node "GP" units = "V", runits = ""
-residual 5160 5168 4294967295 4294967295
-node "BP" units = "V", runits = ""
-residual 5176 5184 4294967295 4294967295
-node "BI" units = "V", runits = ""
-residual 5192 4294967295 4294967295 4294967295
-node "BS" units = "V", runits = ""
-residual 5200 5208 4294967295 4294967295
-node "BD" units = "V", runits = ""
-residual 5216 5224 4294967295 4294967295
-jacobian (D, D) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 408
-jacobian (D, S) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 416
-jacobian (D, NOI) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 424
-jacobian (D, NOI2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (D, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 432
-jacobian (D, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 440
-jacobian (D, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 448
-jacobian (D, BD) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 456
-jacobian (G, G) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (G, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (S, D) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 464
-jacobian (S, S) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 472
-jacobian (S, NOI) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 480
-jacobian (S, NOI2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (S, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 488
-jacobian (S, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 496
-jacobian (S, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 504
-jacobian (B, B) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (B, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (NOI, D) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 512
-jacobian (NOI, S) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 520
-jacobian (NOI, NOI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 528
-jacobian (NOI, NOI2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (NOI, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 536
-jacobian (NOI, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 544
-jacobian (NOI2, NOI2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (GP, D) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 552
-jacobian (GP, G) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (GP, S) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 560
-jacobian (GP, NOI) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 568
-jacobian (GP, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 576
-jacobian (GP, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 584
-jacobian (BP, D) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 592
-jacobian (BP, S) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 600
-jacobian (BP, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 608
-jacobian (BP, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 616
-jacobian (BP, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (BI, B) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (BI, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (BI, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (BI, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (BI, BD) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (BS, S) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 624
-jacobian (BS, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (BS, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 632
-jacobian (BD, D) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 640
-jacobian (BD, S) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 648
-jacobian (BD, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (BD, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 656
-jacobian (BD, BD) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 664
+node "D" units = "V", runits = "A"
+node "G" units = "V", runits = "A"
+node "S" units = "V", runits = "A"
+node "B" units = "V", runits = "A"
+node "NOI" units = "V", runits = "A"
+node "NOI2" units = "V", runits = "A"
+node "GP" units = "V", runits = "A"
+node "BP" units = "V", runits = "A"
+node "BI" units = "V", runits = "A"
+node "BS" units = "V", runits = "A"
+node "BD" units = "V", runits = "A"
+jacobian (D, D) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (D, S) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (D, NOI) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (D, NOI2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (D, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (D, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (D, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (D, BD) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (G, G) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (G, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (S, D) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (S, S) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (S, NOI) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (S, NOI2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (S, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (S, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (S, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (B, B) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (B, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (NOI, D) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (NOI, S) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (NOI, NOI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (NOI, NOI2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (NOI, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (NOI, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (NOI2, NOI2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (GP, D) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (GP, G) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (GP, S) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (GP, NOI) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (GP, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (GP, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (BP, D) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (BP, S) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (BP, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (BP, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (BP, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (BI, B) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (BI, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (BI, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (BI, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (BI, BD) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (BS, S) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (BS, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (BS, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (BD, D) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (BD, S) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (BD, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (BD, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (BD, BD) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
 collapsible (G, GP)
 collapsible (BP, BI)
 collapsible (BS, BI)
@@ -727,5 +716,3 @@ noise "unnamed4" (B, BI)
 noise "igig" (NOI2, gnd)
 0 states
 has bound_step false
-instance size 5760
-model size 2584
diff --git a/openvaf/test_data/osdi/psp103.snap b/openvaf/test_data/osdi/psp103.snap
index 5fc3954fe..bac20d683 100644
--- a/openvaf/test_data/osdi/psp103.snap
+++ b/openvaf/test_data/osdi/psp103.snap
@@ -1692,88 +1692,75 @@ param "FJUNQD"
 units = "", desc = "Fraction below which drain-bulk junction capacitance components are considered negligible", flags = ParameterFlags(0x0)
 
 4 terminals
-node "D" units = "V", runits = ""
-residual 6488 4294967295 4294967295 4294967295
-node "G" units = "V", runits = ""
-residual 6496 4294967295 4294967295 4294967295
-node "S" units = "V", runits = ""
-residual 6504 4294967295 4294967295 4294967295
-node "B" units = "V", runits = ""
-residual 6512 4294967295 4294967295 4294967295
-node "NOI" units = "V", runits = ""
-residual 6520 6528 4294967295 4294967295
-node "GP" units = "V", runits = ""
-residual 6536 6544 4294967295 4294967295
-node "SI" units = "V", runits = ""
-residual 6552 6560 4294967295 4294967295
-node "DI" units = "V", runits = ""
-residual 6568 6576 4294967295 4294967295
-node "BP" units = "V", runits = ""
-residual 6584 6592 4294967295 4294967295
-node "BI" units = "V", runits = ""
-residual 6600 4294967295 4294967295 4294967295
-node "BS" units = "V", runits = ""
-residual 6608 6616 4294967295 4294967295
-node "BD" units = "V", runits = ""
-residual 6624 6632 4294967295 4294967295
-node(flow) "flow(NOII)" units = "A", runits = ""
-residual 6640 4294967295 4294967295 4294967295
-jacobian (D, D) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (D, DI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (G, G) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (G, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (S, S) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (S, SI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (B, B) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (B, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (NOI, NOI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 456
-jacobian (NOI, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 464
-jacobian (NOI, SI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 472
-jacobian (NOI, DI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 480
-jacobian (NOI, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 488
-jacobian (NOI, flow(NOII)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (GP, G) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (GP, NOI) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 496
-jacobian (GP, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 504
-jacobian (GP, SI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 512
-jacobian (GP, DI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 520
-jacobian (GP, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 528
-jacobian (SI, S) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (SI, NOI) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 536
-jacobian (SI, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 544
-jacobian (SI, SI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 552
-jacobian (SI, DI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 560
-jacobian (SI, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 568
-jacobian (SI, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 576
-jacobian (SI, flow(NOII)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (DI, D) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (DI, NOI) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 584
-jacobian (DI, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 592
-jacobian (DI, SI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 600
-jacobian (DI, DI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 608
-jacobian (DI, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 616
-jacobian (DI, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 624
-jacobian (DI, BD) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 632
-jacobian (DI, flow(NOII)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (BP, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 640
-jacobian (BP, SI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 648
-jacobian (BP, DI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 656
-jacobian (BP, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 664
-jacobian (BP, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (BI, B) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (BI, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (BI, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (BI, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (BI, BD) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (BS, SI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 672
-jacobian (BS, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (BS, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 680
-jacobian (BD, SI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 688
-jacobian (BD, DI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 696
-jacobian (BD, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (BD, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 704
-jacobian (BD, BD) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 712
-jacobian (flow(NOII), flow(NOII)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
+node "D" units = "V", runits = "A"
+node "G" units = "V", runits = "A"
+node "S" units = "V", runits = "A"
+node "B" units = "V", runits = "A"
+node "NOI" units = "V", runits = "A"
+node "GP" units = "V", runits = "A"
+node "SI" units = "V", runits = "A"
+node "DI" units = "V", runits = "A"
+node "BP" units = "V", runits = "A"
+node "BI" units = "V", runits = "A"
+node "BS" units = "V", runits = "A"
+node "BD" units = "V", runits = "A"
+node(flow) "flow(NOII)" units = "A", runits = "A"
+jacobian (D, D) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (D, DI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (G, G) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (G, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (S, S) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (S, SI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (B, B) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (B, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (NOI, NOI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (NOI, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (NOI, SI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (NOI, DI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (NOI, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (NOI, flow(NOII)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (GP, G) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (GP, NOI) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (GP, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (GP, SI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (GP, DI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (GP, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (SI, S) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (SI, NOI) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (SI, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (SI, SI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (SI, DI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (SI, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (SI, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (SI, flow(NOII)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (DI, D) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (DI, NOI) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST)
+jacobian (DI, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (DI, SI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (DI, DI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (DI, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (DI, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (DI, BD) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (DI, flow(NOII)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (BP, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (BP, SI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (BP, DI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (BP, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (BP, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (BI, B) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (BI, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (BI, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (BI, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (BI, BD) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (BS, SI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (BS, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (BS, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (BD, SI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (BD, DI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (BD, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (BD, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (BD, BD) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT)
+jacobian (flow(NOII), flow(NOII)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST)
 collapsible (G, GP)
 collapsible (S, SI)
 collapsible (D, DI)
@@ -1799,5 +1786,3 @@ noise "rwell" (B, BI)
 noise "igig" (flow(NOII), gnd)
 0 states
 has bound_step false
-instance size 7184
-model size 6824
diff --git a/openvaf/test_data/osdi/resistor.snap b/openvaf/test_data/osdi/resistor.snap
index 1986b397d..7fa110aa8 100644
--- a/openvaf/test_data/osdi/resistor.snap
+++ b/openvaf/test_data/osdi/resistor.snap
@@ -8,15 +8,11 @@ param "tnom"
 units = "Kelvin", desc = "Reference Temp.", flags = ParameterFlags(0x0)
 
 2 terminals
-node "A" units = "V", runits = ""
-residual 96 4294967295 4294967295 4294967295
-node "B" units = "V", runits = ""
-residual 104 4294967295 4294967295 4294967295
-jacobian (A, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (A, B) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (B, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (B, B) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
+node "A" units = "V", runits = "A"
+node "B" units = "V", runits = "A"
+jacobian (A, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (A, B) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (B, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (B, B) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
 0 states
 has bound_step false
-instance size 112
-model size 40
diff --git a/openvaf/test_data/osdi/strings.snap b/openvaf/test_data/osdi/strings.snap
index 9cdc5928f..da78845d8 100644
--- a/openvaf/test_data/osdi/strings.snap
+++ b/openvaf/test_data/osdi/strings.snap
@@ -6,11 +6,7 @@ param "dummy2"
 units = "none", desc = "Dummy", flags = ParameterFlags(PARA_TY_STR)
 
 2 terminals
-node "A" units = "V", runits = ""
-residual 64 4294967295 4294967295 4294967295
-node "C" units = "V", runits = ""
-residual 72 4294967295 4294967295 4294967295
+node "A" units = "V", runits = "A"
+node "C" units = "V", runits = "A"
 0 states
 has bound_step false
-instance size 80
-model size 32
diff --git a/openvaf/test_data/osdi/vccs.snap b/openvaf/test_data/osdi/vccs.snap
index 7851eb07a..c09e98688 100644
--- a/openvaf/test_data/osdi/vccs.snap
+++ b/openvaf/test_data/osdi/vccs.snap
@@ -8,27 +8,21 @@ param "Rout"
 units = "Ohm", desc = "output Resistance", flags = ParameterFlags(0x0)
 
 4 terminals
-node "Inp" units = "V", runits = ""
-residual 192 4294967295 4294967295 4294967295
-node "Inm" units = "V", runits = ""
-residual 200 4294967295 4294967295 4294967295
-node "Outp" units = "V", runits = ""
-residual 208 4294967295 4294967295 4294967295
-node "Outm" units = "V", runits = ""
-residual 216 4294967295 4294967295 4294967295
-jacobian (Inp, Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (Inp, Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (Inm, Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (Inm, Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (Outp, Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (Outp, Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (Outp, Outp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (Outp, Outm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (Outm, Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (Outm, Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (Outm, Outp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
-jacobian (Outm, Outm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295
+node "Inp" units = "V", runits = "A"
+node "Inm" units = "V", runits = "A"
+node "Outp" units = "V", runits = "A"
+node "Outm" units = "V", runits = "A"
+jacobian (Inp, Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (Inp, Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (Inm, Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (Inm, Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (Outp, Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (Outp, Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (Outp, Outp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (Outp, Outm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (Outm, Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (Outm, Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (Outm, Outp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
+jacobian (Outm, Outm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST)
 0 states
 has bound_step false
-instance size 224
-model size 40
diff --git a/openvaf/test_data/ui/analog_in_cond.log b/openvaf/test_data/ui/analog_in_cond.log
new file mode 100644
index 000000000..539257e70
--- /dev/null
+++ b/openvaf/test_data/ui/analog_in_cond.log
@@ -0,0 +1,36 @@
+error: analog operator 'limexp' is not allowed in conditions
+   --> /analog_in_cond.va:24:27
+   |
+22 |         if (v_internal > 0) begin
+   |             ---------- help: this condition is not a constant
+23 |             // Error: limexp in conditional
+24 |             temp_factor = limexp(v_internal / vth);
+   |                           ^^^^^^^^^^^^^^^^^^^^^^^^ not allowed here
+   |
+   = help: analog operators are only allowed in non-conditional behaviour
+   = help: only constant and analysis functions are allowed in conditions
+
+error: analog operator 'ddt' is not allowed in conditions
+   --> /analog_in_cond.va:31:26
+   |
+29 |         if (use_limexp > 0.5) begin
+   |             ---------- help: this condition is not a constant
+30 |             // Error: ddt in conditional
+31 |             i_internal = ddt(v_internal);
+   |                          ^^^^^^^^^^^^^^^ not allowed here
+   |
+   = help: analog operators are only allowed in non-conditional behaviour
+   = help: only constant and analysis functions are allowed in conditions
+
+error: analog operator 'idt' is not allowed in conditions
+   --> /analog_in_cond.va:37:30
+   |
+34 |         case (use_limexp)
+   |               ---------- help: this condition is not a constant
+   .
+37 |                 v_internal = idt(i_internal);
+   |                              ^^^^^^^^^^^^^^^ not allowed here
+   |
+   = help: analog operators are only allowed in non-conditional behaviour
+   = help: only constant and analysis functions are allowed in conditions
+
diff --git a/openvaf/test_data/ui/analog_in_cond.va b/openvaf/test_data/ui/analog_in_cond.va
new file mode 100644
index 000000000..f1d4daae4
--- /dev/null
+++ b/openvaf/test_data/ui/analog_in_cond.va
@@ -0,0 +1,46 @@
+`include "disciplines.va"
+
+module analog_in_cond(a, c);
+    inout a, c;
+    electrical a, c;
+    real v_internal, i_internal, temp_factor;
+    real use_limexp;
+    parameter real vth = 0.026;
+    parameter real is = 1e-14;
+
+    analog begin
+        use_limexp = 1.0;
+        v_internal = V(a, c);
+
+        // This is valid: analog operators in analog block
+        temp_factor = limexp(v_internal / vth);
+        i_internal = is * temp_factor;
+
+        // These should produce errors without --allow-analog-in-cond flag:
+        // Analog operators (limexp, ddt, idt) in signal-dependent conditionals
+
+        if (v_internal > 0) begin
+            // Error: limexp in conditional
+            temp_factor = limexp(v_internal / vth);
+        end else begin
+            temp_factor = 1.0;
+        end
+
+        if (use_limexp > 0.5) begin
+            // Error: ddt in conditional
+            i_internal = ddt(v_internal);
+        end
+
+        case (use_limexp)
+            1.0: begin
+                // Error: idt in conditional (case statement)
+                v_internal = idt(i_internal);
+            end
+            default: begin
+                v_internal = 0.0;
+            end
+        endcase
+
+        I(a, c) <+ i_internal;
+    end
+endmodule
diff --git a/openvaf/test_data/ui_allow_analog_cond/diode_with_conditionals.log b/openvaf/test_data/ui_allow_analog_cond/diode_with_conditionals.log
new file mode 100644
index 000000000..e69de29bb
diff --git a/openvaf/test_data/ui_allow_analog_cond/diode_with_conditionals.va b/openvaf/test_data/ui_allow_analog_cond/diode_with_conditionals.va
new file mode 100644
index 000000000..57c124441
--- /dev/null
+++ b/openvaf/test_data/ui_allow_analog_cond/diode_with_conditionals.va
@@ -0,0 +1,66 @@
+`include "disciplines.va"
+
+// Test case for --allow-analog-in-cond flag
+// This model uses analog operators (limexp, ddt, idt) inside conditionals
+// which is non-standard Verilog-A but required by some foundry models
+module diode_with_conditionals(anode, cathode);
+    inout anode, cathode;
+    electrical anode, cathode;
+
+    parameter real is = 1e-14;           // Saturation current
+    parameter real vth = 0.026;          // Thermal voltage
+    parameter real n = 1.0;              // Ideality factor
+    parameter real cj0 = 1e-12;          // Junction capacitance
+    parameter real use_dynamic = 1;      // Enable dynamic behavior
+    parameter real use_smooth = 1;       // Enable smoothing
+    parameter real temp_coeff = 0.0;     // Temperature coefficient
+
+    real v_diode, i_static, i_dynamic, q_charge;
+    real temp_factor, smooth_factor;
+
+    analog begin
+        v_diode = V(anode, cathode);
+
+        // Signal-dependent conditional with limexp (smoothing function)
+        // This pattern is common in foundry models
+        if (use_smooth > 0.5) begin
+            // Use limexp for smooth exponential to avoid numerical issues
+            temp_factor = limexp(v_diode / (n * vth));
+            i_static = is * (temp_factor - 1.0);
+        end else begin
+            // Use regular exponential
+            i_static = is * (exp(v_diode / (n * vth)) - 1.0);
+        end
+
+        // Dynamic behavior with conditional ddt/idt
+        if (use_dynamic > 0.5) begin
+            // Time-derivative for capacitive current
+            q_charge = cj0 * v_diode;
+            i_dynamic = ddt(q_charge);
+        end else begin
+            i_dynamic = 0.0;
+        end
+
+        // Temperature-dependent behavior using idt in conditional
+        if (temp_coeff > 0.0) begin
+            // Integrate temperature effect
+            smooth_factor = idt(temp_coeff * i_static);
+        end else begin
+            smooth_factor = 0.0;
+        end
+
+        // Case statement with analog operator
+        case (use_smooth)
+            1.0: begin
+                // Another limexp usage in case block
+                temp_factor = limexp(-v_diode / vth);
+            end
+            default: begin
+                temp_factor = 1.0;
+            end
+        endcase
+
+        // Total current contribution
+        I(anode, cathode) <+ i_static + i_dynamic + smooth_factor;
+    end
+endmodule
diff --git a/openvaf/tokens/src/parser/generated.rs b/openvaf/tokens/src/parser/generated.rs
index 0a59b3ad8..abfc5d440 100644
--- a/openvaf/tokens/src/parser/generated.rs
+++ b/openvaf/tokens/src/parser/generated.rs
@@ -127,6 +127,7 @@ pub enum SyntaxKind {
     IF_STMT,
     LITERAL,
     MODULE_DECL,
+    MODULE_INST,
     MODULE_PORT,
     MODULE_PORTS,
     NAME,
@@ -138,11 +139,15 @@ pub enum SyntaxKind {
     NET_DECL,
     NETS,
     PARAM,
+    PARAM_ASSIGNMENT,
+    PARAM_ASSIGNMENTS,
     ALIAS_PARAM,
     PARAM_DECL,
     PAREN_EXPR,
     PATH,
     PATH_EXPR,
+    PORT_CONNECTION,
+    PORT_CONNECTIONS,
     PORT_DECL,
     PORTS,
     PREFIX_EXPR,
diff --git a/openvaf/vfs/Cargo.toml b/openvaf/vfs/Cargo.toml
index cac615bac..405ad174a 100644
--- a/openvaf/vfs/Cargo.toml
+++ b/openvaf/vfs/Cargo.toml
@@ -13,7 +13,7 @@ doctest = false
 
 paths = {path="../../lib/paths",version="0.0.0"}
 indexmap = "2.0"
-ahash = "0.8"
+rustc-hash = "2.0"
 encoding_rs = "0.8"
 chardetng = "0.1"
 
diff --git a/openvaf/vfs/src/path_interner.rs b/openvaf/vfs/src/path_interner.rs
index 027cd8bf1..c7409e582 100644
--- a/openvaf/vfs/src/path_interner.rs
+++ b/openvaf/vfs/src/path_interner.rs
@@ -2,14 +2,17 @@
 //! no longer exist -- the assumption is total size of paths we ever look at is
 //! not too big.
 
+use std::hash::BuildHasherDefault;
+
 use indexmap::IndexSet;
+use rustc_hash::FxHasher;
 
 use crate::{FileId, VfsPath};
 
 /// Structure to map between [`VfsPath`] and [`FileId`].
 #[derive(Default, Debug)]
 pub(crate) struct PathInterner {
-    map: IndexSet<VfsPath, ahash::RandomState>,
+    map: IndexSet<VfsPath, BuildHasherDefault<FxHasher>>,
 }
 
 impl PathInterner {
diff --git a/sourcegen/Cargo.toml b/sourcegen/Cargo.toml
index 7983d78ce..cd9a8b841 100644
--- a/sourcegen/Cargo.toml
+++ b/sourcegen/Cargo.toml
@@ -11,6 +11,9 @@ readme="../README.md"
 [lib]
 doctest = false
 
+[lints.rust]
+unexpected_cfgs = { level = "warn", check-cfg = ['cfg(cross_compile)'] }
+
 [badges]
 maintenance = { status = "actively-developed" }
 
diff --git a/sourcegen/src/ast/src.rs b/sourcegen/src/ast/src.rs
index c1880e2c3..fd0a25c80 100644
--- a/sourcegen/src/ast/src.rs
+++ b/sourcegen/src/ast/src.rs
@@ -126,6 +126,7 @@ pub(crate) const KINDS_SRC: KindsSrc = KindsSrc {
         "IF_STMT",
         "LITERAL",
         "MODULE_DECL",
+        "MODULE_INST",
         "MODULE_PORT",
         "MODULE_PORTS",
         "NAME",
@@ -137,11 +138,15 @@ pub(crate) const KINDS_SRC: KindsSrc = KindsSrc {
         "NET_DECL",
         "NETS",
         "PARAM",
+        "PARAM_ASSIGNMENT",
+        "PARAM_ASSIGNMENTS",
         "ALIAS_PARAM",
         "PARAM_DECL",
         "PAREN_EXPR",
         "PATH",
         "PATH_EXPR",
+        "PORT_CONNECTION",
+        "PORT_CONNECTIONS",
         "PORT_DECL",
         "PORTS",
         "PREFIX_EXPR",
diff --git a/sourcegen/src/hir_builtins.rs b/sourcegen/src/hir_builtins.rs
index 686f228b7..79e5637bd 100644
--- a/sourcegen/src/hir_builtins.rs
+++ b/sourcegen/src/hir_builtins.rs
@@ -292,18 +292,20 @@ fn generate_builtins() {
             }
         }
 
-        pub fn insert_builtin_scope(dst: &mut IndexMap<Name, ScopeDefItem, RandomState>){
+        pub fn insert_builtin_scope(dst: &mut IndexMap<Name, ScopeDefItem, BuildHasherDefault<FxHasher>>){
             #(dst.insert(#kw_types::#kws,BuiltIn::#variants.into());)*
         }
 
 
-        pub fn insert_module_builtin_scope(dst: &mut IndexMap<Name, ScopeDefItem, RandomState>){
+        pub fn insert_module_builtin_scope(dst: &mut IndexMap<Name, ScopeDefItem, BuildHasherDefault<FxHasher>>){
             #(dst.insert(sysfun::#params,ParamSysFun::#params.into());)*
         }
     };
 
-    let header = "use ahash::RandomState;
+    let header = "use std::hash::BuildHasherDefault;
+
         use indexmap::IndexMap;
+        use rustc_hash::FxHasher;
         use syntax::name::{kw, sysfun, Name};
 
         use crate::nameres::ScopeDefItem;
diff --git a/verilogae/verilogae/src/compiler_db.rs b/verilogae/verilogae/src/compiler_db.rs
index 543768cf9..2e1102271 100644
--- a/verilogae/verilogae/src/compiler_db.rs
+++ b/verilogae/verilogae/src/compiler_db.rs
@@ -9,7 +9,8 @@ use basedb::{BaseDB, FileId, VfsPath};
 use camino::Utf8Path;
 pub use hir::CompilationDB;
 use hir::{
-    Branch, BranchKind, Module, Node, Parameter, PathResolveError, ScopeDef, Type, Variable,
+    Branch, BranchKind, CompilationOpts, Module, Node, Parameter, PathResolveError, ScopeDef, Type,
+    Variable,
 };
 use hir_lower::CurrentKind;
 use indexmap::IndexMap;
@@ -46,6 +47,7 @@ pub(crate) fn new(root_file: &Utf8Path, opts: &Opts) -> Result<CompilationDB> {
         opts.include_dirs().map(|path| path.map(VfsPath::from)),
         opts.macro_flags(),
         lints,
+        &CompilationOpts::default(),
     )
 }
 
@@ -426,7 +428,11 @@ impl ModelInfo {
         })
     }
 
-    pub(crate) fn intern_model(&self, db: &CompilationDB, literals: &mut Rodeo) -> InternedModel {
+    pub(crate) fn intern_model(
+        &self,
+        db: &CompilationDB,
+        literals: &mut Rodeo,
+    ) -> InternedModel<'_> {
         let params = self
             .params
             .values()
diff --git a/verilogae/verilogae_py/src/ffi.rs b/verilogae/verilogae_py/src/ffi.rs
index bdd0ae9b0..fdfe37c5f 100644
--- a/verilogae/verilogae_py/src/ffi.rs
+++ b/verilogae/verilogae_py/src/ffi.rs
@@ -9,14 +9,6 @@ pub unsafe fn PyDict_GET_SIZE(op: *mut PyObject) -> Py_ssize_t {
     (*op.cast::<PyDictObject>()).ma_used
 }
 
-// #[cfg(Py_3_8)]
-// const PY_TPFLAGS_HAVE_VECTORCALL: c_ulonglong = pyo3_ffi::Py_TPFLAGS_HAVE_VECTORCALL;
-// #[cfg(not(Py_3_8))]
-// const Py_TPFLAGS_HAVE_VECTORCALL: c_ulonglong = 0;
-
-#[cfg(Py_3_10)]
-const PY_TPFLAGS_IMMUTABLETYPE: c_ulong = pyo3_ffi::Py_TPFLAGS_IMMUTABLETYPE;
-#[cfg(not(Py_3_10))]
 const PY_TPFLAGS_IMMUTABLETYPE: c_ulong = 0;
 
 const TY_FLAGS: c_ulong = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | PY_TPFLAGS_IMMUTABLETYPE;
diff --git a/verilogae/verilogae_py/src/lib.rs b/verilogae/verilogae_py/src/lib.rs
index 6650a0b31..673ed184c 100644
--- a/verilogae/verilogae_py/src/lib.rs
+++ b/verilogae/verilogae_py/src/lib.rs
@@ -18,36 +18,24 @@ use crate::load::{load_info_py, load_py, load_vfs};
 use crate::model::{VAE_FUNCTION_TY, VAE_MODEL_TY, VAE_PARAM_TY};
 use crate::typeref::init_typerefs;
 
-#[cfg(Py_3_8)]
-const FUN_FLAG: c_int = METH_FASTCALL;
-#[cfg(not(Py_3_8))]
 const FUN_FLAG: c_int = METH_VARARGS;
 
 static mut FUNCTIONS: [PyMethodDef; 4] = unsafe {
     [
     PyMethodDef {
             ml_name: "load\0".as_ptr() as *const c_char,
-            #[cfg(Py_3_8)]
-            ml_meth: PyMethodDefPointer{_PyCFunctionFastWithKeywords: load_py},
-            #[cfg(not(Py_3_8))]
             ml_meth: PyMethodDefPointer{PyCFunctionWithKeywords: load_py},
             ml_flags: FUN_FLAG | METH_KEYWORDS,
             ml_doc: "loads a Verilog-A model by either loading it from the object cache or compiling it\0".as_ptr() as *const c_char,
     },
     PyMethodDef {
             ml_name: "load_info\0".as_ptr() as *const c_char,
-            #[cfg(Py_3_8)]
-            ml_meth: PyMethodDefPointer{_PyCFunctionFastWithKeywords: load_info_py},
-            #[cfg(not(Py_3_8))]
             ml_meth: PyMethodDefPointer{PyCFunctionWithKeywords: load_info_py},
             ml_flags: FUN_FLAG | METH_KEYWORDS,
             ml_doc: "loads information about Verilog-A model by either loading it from the object cache or compiling it\nThis function does not compile retrieved functions.\nThis allows for much faster compile times.\nModelsCompiled with this function lack the `functions` attribute.\0".as_ptr() as *const c_char,
     },
     PyMethodDef {
             ml_name: "export_vfs\0".as_ptr() as *const c_char,
-            #[cfg(Py_3_8)]
-            ml_meth: PyMethodDefPointer{_PyCFunctionFastWithKeywords: load_vfs},
-            #[cfg(not(Py_3_8))]
             ml_meth: PyMethodDefPointer{PyCFunctionWithKeywords: load_vfs},
             ml_flags: FUN_FLAG | METH_KEYWORDS,
             ml_doc: "runs the preprocessor on a Verilog-A file and exports a dict with all files.\nThe result of this functions can be passed to other functions `vfs` argument\0".as_ptr() as *const c_char,
@@ -58,6 +46,7 @@ static mut FUNCTIONS: [PyMethodDef; 4] = unsafe {
 
 #[allow(clippy::missing_safety_doc)]
 #[allow(non_snake_case)]
+#[allow(static_mut_refs)]
 #[no_mangle]
 #[cold]
 pub unsafe extern "C" fn PyInit_verilogae() -> *mut PyObject {
diff --git a/verilogae/verilogae_py/src/load.rs b/verilogae/verilogae_py/src/load.rs
index a49d5fd16..bffb1f80d 100644
--- a/verilogae/verilogae_py/src/load.rs
+++ b/verilogae/verilogae_py/src/load.rs
@@ -32,53 +32,6 @@ macro_rules! handle_opt {
     };
 }
 
-#[cfg(Py_3_8)]
-macro_rules! parse_args {
-    ($fun: literal, $args: ident, $nargs: ident, $kwnames: ident, $path: ident, $opts: ident) => {
-        let num_args = pyo3_ffi::PyVectorcall_NARGS($nargs as usize);
-        if unlikely(num_args == 0) {
-            return raise_type_exception(concat!(
-                $fun,
-                "() missing 1 required positional argument: 'path'"
-            ));
-        }
-
-        if unlikely(num_args != 1) {
-            return raise_type_exception(concat!(
-                $fun,
-                "() found unexpected positional argument (expected 1)"
-            ));
-        }
-
-        let $path = match OsStr::new_path(*$args) {
-            Some(Some(path)) => path,
-            Some(None) => {
-                return raise_type_exception(concat!(
-                    $fun,
-                    "() positional argument 'path' must be a pathlib Path or str"
-                ))
-            }
-            None => return ptr::null_mut(),
-        };
-
-        let mut $opts = Opts::default();
-
-        if !$kwnames.is_null() {
-            let len = PyTuple_GET_SIZE($kwnames).saturating_sub(1);
-            for i in 0..=len {
-                let arg = PyTuple_GET_ITEM($kwnames, i as Py_ssize_t);
-                if !handle_opt!($fun, $opts, arg, *$args.offset(num_args + i)) {
-                    return raise_type_exception(concat!(
-                        $fun,
-                        "() got an unexpected keyword argument"
-                    ));
-                }
-            }
-        }
-    };
-}
-
-#[cfg(not(Py_3_8))]
 macro_rules! parse_args {
     ($fun: literal, $args: ident, $kwargs: ident, $path: ident, $opts: ident) => {
         let path = PyTuple_GET_ITEM($args, 0);
@@ -117,7 +70,6 @@ macro_rules! parse_args {
             let mut arg: *mut PyObject = std::ptr::null_mut();
             let mut val: *mut PyObject = std::ptr::null_mut();
             for _i in 0..=len {
-                // _PyDict_Next($kwargs, &mut pos, &mut arg, &mut val, std::ptr::null_mut());
                 PyDict_Next($kwargs, &mut pos, &mut arg, &mut val);
                 if !handle_opt!($fun, $opts, arg, val) {
                     if arg.is_null() {
@@ -158,7 +110,6 @@ fn raise_runtime_runtime_exception(msg: &str) -> *mut PyObject {
     std::ptr::null_mut()
 }
 
-#[cfg(not(Py_3_8))]
 #[no_mangle]
 pub unsafe extern "C" fn load_py(
     _self: *mut PyObject,
@@ -175,25 +126,6 @@ pub unsafe extern "C" fn load_py(
     VaeModel::new(model, true)
 }
 
-#[cfg(Py_3_8)]
-#[no_mangle]
-pub unsafe extern "C" fn load_py(
-    _self: *mut PyObject,
-    args: *const *mut PyObject,
-    nargs: Py_ssize_t,
-    kwnames: *mut PyObject,
-) -> *mut PyObject {
-    parse_args!("load", args, nargs, kwnames, path, opts);
-    let model = verilogae_load(path.data, true, opts.to_ffi());
-
-    if model.is_null() {
-        return raise_runtime_runtime_exception("load() compilation failed");
-    }
-
-    VaeModel::new(model, true)
-}
-
-#[cfg(not(Py_3_8))]
 #[no_mangle]
 pub unsafe extern "C" fn load_info_py(
     _self: *mut PyObject,
@@ -210,25 +142,6 @@ pub unsafe extern "C" fn load_info_py(
     VaeModel::new(model, false)
 }
 
-#[cfg(Py_3_8)]
-#[no_mangle]
-pub unsafe extern "C" fn load_info_py(
-    _self: *mut PyObject,
-    args: *const *mut PyObject,
-    nargs: Py_ssize_t,
-    kwnames: *mut PyObject,
-) -> *mut PyObject {
-    parse_args!("load_info", args, nargs, kwnames, path, opts);
-    let model = verilogae_load(path.data, false, opts.to_ffi());
-
-    if model.is_null() {
-        return raise_runtime_runtime_exception("load_info() compilation failed");
-    }
-
-    VaeModel::new(model, false)
-}
-
-#[cfg(not(Py_3_8))]
 #[no_mangle]
 pub unsafe extern "C" fn load_vfs(
     _self: *mut PyObject,
@@ -236,22 +149,6 @@ pub unsafe extern "C" fn load_vfs(
     kwds: *mut PyObject,
 ) -> *mut PyObject {
     parse_args!("load_vfs", args, kwds, path, opts);
-    let vfs = VfsExport::new(path.data, &opts);
-    match vfs {
-        Some(vfs) => vfs_to_py(vfs),
-        None => raise_runtime_runtime_exception("load_vfs() failed to create vfs"),
-    }
-}
-
-#[cfg(Py_3_8)]
-#[no_mangle]
-pub unsafe extern "C" fn load_vfs(
-    _self: *mut PyObject,
-    args: *const *mut PyObject,
-    nargs: Py_ssize_t,
-    kwnames: *mut PyObject,
-) -> *mut PyObject {
-    parse_args!("load_vfs", args, nargs, kwnames, path, opts);
     let vfs = VfsExport::new(path.data.read(), &opts);
     match vfs {
         Some(vfs) => vfs_to_py(vfs),
@@ -285,7 +182,6 @@ unsafe fn py_to_vfs(fun: &str, obj: *mut PyObject) -> Option<Vfs> {
     let mut vfs = Vec::with_capacity(len as usize);
 
     for _i in 0..=len {
-        // _PyDict_Next(obj, &mut pos, &mut arg, &mut val, std::ptr::null_mut());
         PyDict_Next(obj, &mut pos, &mut arg, &mut val);
         let mut path_size = 0;
         let path = PyUnicode_AsUTF8AndSize(arg, &mut path_size);
diff --git a/verilogae/verilogae_py/src/model.rs b/verilogae/verilogae_py/src/model.rs
index 37c3f831f..8e8d9d0c2 100644
--- a/verilogae/verilogae_py/src/model.rs
+++ b/verilogae/verilogae_py/src/model.rs
@@ -520,16 +520,6 @@ static mut VAE_FUNCTION_MEMBERS: [PyMemberDef; 6] = [
 const EVAL_DOC: &str = "\0";
 
 static mut VAE_FUNCTION_METHODS: [PyMethodDef; 2] = [
-    // #[cfg(Py_3_8)]
-    // PyMethodDef {
-    //     ml_name: "eval\0".as_ptr() as *const c_char,
-    //     ml_meth: unsafe {
-    //         transmute::<_PyCFunctionFastWithKeywords, Option<PyCFunction>>(VaeFun::eval)
-    //     },
-    //     ml_flags: METH_FASTCALL | METH_KEYWORDS,
-    //     ml_doc: EVAL_DOC.as_ptr() as *const c_char,
-    // },
-    // #[cfg(not(Py_3_8))]
     PyMethodDef {
         ml_name: "eval\0".as_ptr() as *const c_char,
         ml_meth: PyMethodDefPointer { PyCFunctionWithKeywords: VaeFun::eval },
@@ -871,7 +861,6 @@ impl VaeFun {
         take(&mut self_.ffi_str_data);
     }
 
-    // #[cfg(not(Py_3_8))]
     unsafe extern "C" fn eval(
         self_: *mut PyObject,
         args: *mut PyObject,
diff --git a/xtask/src/flags.rs b/xtask/src/flags.rs
index 8ddfe3ad4..5ad8f257c 100644
--- a/xtask/src/flags.rs
+++ b/xtask/src/flags.rs
@@ -3,6 +3,22 @@ xflags::xflags! {
 
     /// Run custom build command.
     cmd xtask {
+        /// Build OpenVAF with automatic LLVM detection on macOS
+        cmd cargo-build {
+            /// Build in release mode
+            optional --release
+            /// Additional arguments to pass to cargo build
+            repeated args: String
+        }
+
+        /// Run tests with automatic LLVM detection on macOS
+        cmd cargo-test {
+            /// Run tests in release mode
+            optional --release
+            /// Additional arguments to pass to cargo test
+            repeated args: String
+        }
+
         cmd verilogae{
             cmd build{
                 optional --force
@@ -34,10 +50,26 @@ pub struct Xtask {
 
 #[derive(Debug)]
 pub enum XtaskCmd {
+    CargoBuild(CargoBuild),
+    CargoTest(CargoTest),
     Verilogae(Verilogae),
     GenMsvcrt(GenMsvcrt),
 }
 
+#[derive(Debug)]
+pub struct CargoBuild {
+    pub args: Vec<String>,
+
+    pub release: bool,
+}
+
+#[derive(Debug)]
+pub struct CargoTest {
+    pub args: Vec<String>,
+
+    pub release: bool,
+}
+
 #[derive(Debug)]
 pub struct Verilogae {
     pub subcommand: VerilogaeCmd,
diff --git a/xtask/src/main.rs b/xtask/src/main.rs
index 065ee6803..114b889a7 100644
--- a/xtask/src/main.rs
+++ b/xtask/src/main.rs
@@ -15,7 +15,7 @@ use std::env;
 use std::path::{Path, PathBuf};
 
 use anyhow::Result;
-use xshell::Shell;
+use xshell::{cmd, Shell};
 
 // mod cache;
 mod msvcrt;
@@ -26,11 +26,86 @@ fn main() -> Result<()> {
 
     let flags = flags::Xtask::from_env()?;
     match flags.subcommand {
+        flags::XtaskCmd::CargoBuild(cmd) => cmd.run(&sh),
+        flags::XtaskCmd::CargoTest(cmd) => cmd.run(&sh),
         flags::XtaskCmd::Verilogae(cmd) => cmd.run(&mut sh),
         flags::XtaskCmd::GenMsvcrt(cmd) => cmd.run(&sh),
     }
 }
 
+impl flags::CargoBuild {
+    fn run(&self, sh: &Shell) -> Result<()> {
+        run_cargo_command(sh, "build", self.release, &self.args)
+    }
+}
+
+impl flags::CargoTest {
+    fn run(&self, sh: &Shell) -> Result<()> {
+        run_cargo_command(sh, "test", self.release, &self.args)
+    }
+}
+
+fn run_cargo_command(
+    sh: &Shell,
+    subcommand: &str,
+    release: bool,
+    extra_args: &[String],
+) -> Result<()> {
+    // Auto-detect LLVM on macOS via Homebrew
+    let llvm_prefix = detect_llvm_prefix();
+
+    let mut envs: Vec<(&str, String)> = Vec::new();
+
+    if let Some(prefix) = &llvm_prefix {
+        eprintln!("Auto-detected LLVM 18 at: {}", prefix);
+        envs.push(("LLVM_SYS_181_PREFIX", prefix.clone()));
+    }
+
+    let mut args = Vec::new();
+    if release {
+        args.push("--release".to_string());
+    }
+    args.extend(extra_args.iter().cloned());
+
+    let mut command = cmd!(sh, "cargo {subcommand} {args...}");
+    for (key, value) in envs {
+        command = command.env(key, value);
+    }
+
+    command.run()?;
+    Ok(())
+}
+
+/// Detect LLVM 18 prefix on macOS via Homebrew.
+/// Returns None on non-macOS or if HOMEBREW_PREFIX is not set.
+fn detect_llvm_prefix() -> Option<String> {
+    // Only attempt detection on macOS
+    if !cfg!(target_os = "macos") {
+        return None;
+    }
+
+    // Check if user already set LLVM_SYS_181_PREFIX
+    if env::var("LLVM_SYS_181_PREFIX").is_ok() {
+        eprintln!("Using existing LLVM_SYS_181_PREFIX from environment");
+        return None;
+    }
+
+    // Try to get HOMEBREW_PREFIX
+    let homebrew_prefix = env::var("HOMEBREW_PREFIX").ok()?;
+
+    let llvm_path = format!("{}/opt/llvm@18", homebrew_prefix);
+    let llvm_bin = format!("{}/bin/llvm-config", llvm_path);
+
+    // Verify LLVM is actually installed there
+    if Path::new(&llvm_bin).exists() {
+        Some(llvm_path)
+    } else {
+        eprintln!("Note: HOMEBREW_PREFIX is set but llvm@18 not found at {}", llvm_path);
+        eprintln!("Install with: brew install llvm@18");
+        None
+    }
+}
+
 fn project_root() -> PathBuf {
     Path::new(
         &env::var("CARGO_MANIFEST_DIR").unwrap_or_else(|_| env!("CARGO_MANIFEST_DIR").to_owned()),