Power State Tables, Transitions and State Groups

Convert a board’s allowed rail combinations into named modes. Then catch a wake sequence that skips a required stop.

You Will Be Able To

  • Read a legacy power state table by following its supply columns in order.
  • Convert the rows into state predicates and check the finite legal set by enumeration.
  • Distinguish an illegal destination from a forbidden transition between legal modes.
  • Explain when several objects need a group to describe their shared modes.
Lesson
W4.12
Time
34 min
Runs on
Your browser
Check
5 questions
Turn Each Supply Row into a StateEach four-column row on the left defines one state on the right.
Turn Each Supply Row into a StateEach four-column row on the left defines one state on the right. row NOM HIGH KEEPREF both rails on row NOM CUT KEEPREF only memory on row NOM CUT CUTREF both rails off state Work processor can run state Nap memory stays on state Cold processor and memoryoff matchesmatchesmatchesCPU offMEM offboth on
  1. row NOM HIGH KEEP REFboth rails on
    • matches → Work
  2. state Workprocessor can run
    • CPU off → Nap
  3. row NOM CUT KEEP REFonly memory on
    • matches → Nap
  4. state Napmemory stays on
    • MEM off → Cold
  5. row NOM CUT CUT REFboth rails off
    • matches → Cold
  6. state Coldprocessor and memory off
    • both on → Work
  1. Start with both rails

    Work joins all four tests in the first row.

  2. Park the processor

    CPU switches off. The second row selects Nap.

  3. Remove memory power

    MEM switches off too. The last row selects Cold.

  4. Try to wake directly

    Both endpoints have rows. The shortcut needs a separate rule.

Read the diagram as text
  • NOM HIGH KEEP REF: both rails on
  • NOM CUT KEEP REF: only memory on
  • NOM CUT CUT REF: both rails off
  • Work: processor can run
  • Nap: memory stays on
  • Cold: processor and memory off
  • NOM HIGH KEEP REF → Work: matches
  • NOM CUT KEEP REF → Nap: matches
  • NOM CUT CUT REF → Cold: matches
  • Work → Nap: CPU off
  • Nap → Cold: MEM off
  • Cold → Work: both on

Drawn from the recorded board sequence. The Cold to Work arrow is the wake the checker rejects.

On pmu_soc, the processor can sleep while memory stays on.

Raise both rails directly from Cold and the checker flags the wake.

Recorded. The converted domain with the direct wake forbidden.
cold cpu_on=0 mem_on=0 mode=Cold
OPENPA-CHECK D8 @ 6000: illegal transition rush on SYSTEM: Cold -> Work (board.upf:43)
shortcut cpu_on=1 mem_on=1 mode=Work

In shortcut, Work is legal, but D8 names the path from Cold.

The bench drives the four rails directly.

Give Each Port a Vocabulary with add_port_state

On pmu_soc, CPU needs 1.0 V and MEM needs 0.8 V. Their on bits hide that difference.

Port states in board.upf.
add_port_state VIN -state {NOM 1.0}
add_port_state CPU -state {HIGH 1.0} -state {CUT off}
add_port_state MEM -state {KEEP 0.8} -state {CUT off}
add_port_state GND -state {REF 0.0}

add_port_state gives CPU its HIGH and MEM its KEEP (6.4).

The park sample reads cpu_on=0 and mem_on=1 because CPU reaches CUT while MEM still satisfies KEEP.

Recorded regulator sequence.
start cpu_on=1 mem_on=1 mode=Work
park cpu_on=0 mem_on=1 mode=Nap
cold cpu_on=0 mem_on=0 mode=Cold

VIN stays at NOM. Powered ground reads zero volts, so GND needs REF.

PortNames before the commandNames available to a row afterward
VINA supply connectionNOM: powered at 1.0 V
CPUA separately driven connectionHIGH: powered at 1.0 V. CUT: off.
MEMA second regulator outputKEEP: powered at 0.8 V. CUT: off.
GNDThe common returnREF: powered at 0.0 V

Legacy states accept exact voltages or ranges (6.4). This board uses exact settings and off.

Which column owns CUT?

Set the Column Order with create_pst

At park, CPU is off and MEM is on. How do you read NOM CUT KEEP REF in the right order?

Before: separate vocabularies

add_port_state CPU -state {HIGH 1.0} -state {CUT off}
add_port_state MEM -state {KEEP 0.8} -state {CUT off}

Each port owns its names.

After: an ordered header

create_pst BOARD_MODES -supplies {VIN CPU MEM GND}

CPU precedes MEM.

create_pst fixes the order of supply nets or ports (6.24). Rows then define the allowed combinations.

At park, CPU is off and MEM is on. The table reports Nap.

Column in BOARD_MODESSupplyRead the Nap entry as
FirstVINNOM keeps the incoming rail at its nominal voltage.
SecondCPUCUT means the processor has lost power.
ThirdMEMKEEP means memory remains powered at 0.8 V.
FourthGNDREF requires a working return.
Recorded. OpenPA 0.3.0 checks this implementation table during simulation (6.24).
park cpu_on=0 mem_on=1 mode=Nap
missing cpu_on=1 mem_on=0 mode=<none>

Compare missing with park. Only park has MEM on and CPU off, so only park matches Nap.

If you move MEM in the header, move its entry in every row.

Now give park a row.

Admit a Combination with add_pst_state

After CPU parks, the board must keep MEM alive. That pair needs its own row.

Before: two board modes

add_pst_state Work -pst BOARD_MODES -state {NOM HIGH KEEP REF}
add_pst_state Cold -pst BOARD_MODES -state {NOM CUT CUT REF}

Only the endpoints have rows.

After: memory can stay on

add_pst_state Nap -pst BOARD_MODES -state {NOM CUT KEEP REF}

Nap admits memory-only operation.

add_pst_state names one legal combination in the table chosen by -pst (6.6). Fill -state in header order.

Without the Nap row, park reports mode=<none> and D8 fires at 2000 ps.

Recorded with only the Nap row removed.
OPENPA-CHECK D8 @ 2000: supplies VIN CPU MEM GND match no row of power state table BOARD_MODES (board.upf:22)
park cpu_on=0 mem_on=1 mode=<none>
cold cpu_on=0 mem_on=0 mode=Cold
Recorded. With Nap restored.
park cpu_on=0 mem_on=1 mode=Nap
OPENPA-COVER state pst BOARD_MODES Nap 1

Cold still matches with both rails off. Restoring Nap gives park a match without changing Cold.

VINCPUMEMGNDPermitted mode
NOMHIGHKEEPREFWork
NOMCUTKEEPREFNap
NOMCUTCUTREFCold
NOMHIGHCUTREFNo row: memory is off under an active processor

Suppose Nap used * instead of KEEP. MEM could then take any value in that column (6.6).

A star for MEM in Nap would also admit Cold’s tuple.

Keep the rows distinct when you convert them.

Convert the Rows with pst2aps

At park, the parent needs one name for CPU off with MEM on. The old row already gives you the four tests.

The PST fixes one supply list. Its rows cannot refine a parent state.

Give each column a set. Join its tests to reconstruct Nap.

Input: the CPU vocabulary

add_port_state CPU -state {HIGH 1.0} -state {CUT off}

Two CPU values.

Output: states of the CPU set

create_supply_set openpa_BOARD_MODES_CPU -function {power CPU}
add_power_state openpa_BOARD_MODES_CPU -supply \
    -state {HIGH -supply_expr {power == {FULL_ON 1}}} \
    -state {CUT -supply_expr {power == OFF}} \
    -complete

One observing set.

Input: one admissible tuple

add_pst_state Nap -pst BOARD_MODES -state {NOM CUT KEEP REF}

Four required values.

Output: one domain predicate

    -state {Nap -logic_expr {openpa_BOARD_MODES_VIN == NOM && openpa_BOARD_MODES_CPU == CUT && openpa_BOARD_MODES_MEM == KEEP && openpa_BOARD_MODES_GND == REF}} \

Four simultaneous tests.

The converted park row still reads mode=Nap because the predicate includes all four tests from the original row.

Recorded. Converted run without arc rules.
start cpu_on=1 mem_on=1 mode=Work
park cpu_on=0 mem_on=1 mode=Nap
cold cpu_on=0 mem_on=0 mode=Cold
missing cpu_on=1 mem_on=0 mode=<none>

Keep VIN and GND because either rail can fail.

From the repository root, run the converter. It prints UPF on stdout and the enumeration on stderr.

Run the conversion on the same tutorial rail combinations.
node tools/openpa/cli.mjs pst2aps content/openpa/modes/board.upf --domain SYSTEM
Read the complete converter output
Generated UPF. Keep the board wiring when replacing the legacy declarations.
# Generated by openpa pst2aps: BOARD_MODES as add_power_state (UPF 2.x form).
# Replace the add_port_state, create_pst and add_pst_state commands with these lines.
create_supply_set openpa_BOARD_MODES_VIN -function {power VIN}
add_power_state openpa_BOARD_MODES_VIN -supply \
    -state {NOM -supply_expr {power == {FULL_ON 1}}} \
    -complete
create_supply_set openpa_BOARD_MODES_CPU -function {power CPU}
add_power_state openpa_BOARD_MODES_CPU -supply \
    -state {HIGH -supply_expr {power == {FULL_ON 1}}} \
    -state {CUT -supply_expr {power == OFF}} \
    -complete
create_supply_set openpa_BOARD_MODES_MEM -function {power MEM}
add_power_state openpa_BOARD_MODES_MEM -supply \
    -state {KEEP -supply_expr {power == {FULL_ON 0.8}}} \
    -state {CUT -supply_expr {power == OFF}} \
    -complete
create_supply_set openpa_BOARD_MODES_GND -function {power GND}
add_power_state openpa_BOARD_MODES_GND -supply \
    -state {REF -supply_expr {power == {FULL_ON 0}}} \
    -complete
add_power_state SYSTEM -domain \
    -state {Work -logic_expr {openpa_BOARD_MODES_VIN == NOM && openpa_BOARD_MODES_CPU == HIGH && openpa_BOARD_MODES_MEM == KEEP && openpa_BOARD_MODES_GND == REF}} \
    -state {Nap -logic_expr {openpa_BOARD_MODES_VIN == NOM && openpa_BOARD_MODES_CPU == CUT && openpa_BOARD_MODES_MEM == KEEP && openpa_BOARD_MODES_GND == REF}} \
    -state {Cold -logic_expr {openpa_BOARD_MODES_VIN == NOM && openpa_BOARD_MODES_CPU == CUT && openpa_BOARD_MODES_MEM == CUT && openpa_BOARD_MODES_GND == REF}}
add_power_state SYSTEM -domain -update -complete

The new CPU and MEM sets only observe the rails. BOARD still powers SYSTEM.

The parent can reference SYSTEM’s Nap.

Nap still matches, but could the conversion have admitted the missing pair?

Check Every Named Combination

The board manual shows legal samples. Could the conversion also accept the forbidden pair?

VIN and GND each have one value. CPU and MEM each have two.

Recorded result from the OpenPA pst2aps command.
pst2aps: 4 combination(s) enumerated, 3 legal; the converted states have the same legal set as the table

The proof reports four combinations and three legal because the CPU-on, MEM-off pair has no row.

Bench sampleCPUMEMPST modeConverted mode
start11WorkWork
park01NapNap
cold00ColdCold
missing10<none><none>

OpenPA rereads the generated text and compares row membership with exactly one matching domain state.

Completeness makes the missing row observable in simulation. Without it, an unnamed combination could stay UNDEFINED with no domain gap report.

Recorded. Original table checker.
OPENPA-CHECK D8 @ 8000: supplies VIN CPU MEM GND match no row of power state table BOARD_MODES (board.upf:22)
missing cpu_on=1 mem_on=0 mode=<none>
Recorded. Converted file: SYSTEM reports a gap.
OPENPA-CHECK D8 @ 8000: power domain SYSTEM is in none of its defined power states (UNDEFINED), which were declared -complete (board.upf:42)
missing cpu_on=1 mem_on=0 mode=<none>

Probe outside the enumerated names by driving VIN at 0.99 V with CPU and MEM on.

Recorded. Voltage drift after conversion.
OPENPA-CHECK D8 @ 2000: supply set openpa_BOARD_MODES_VIN is in none of its defined power states, which were declared -complete (board.upf:23)
OPENPA-CHECK D8 @ 2000: power domain SYSTEM is in none of its defined power states (UNDEFINED), which were declared -complete (board.upf:42)
drift cpu_on=1 mem_on=1 mode=<none>

At drift, the VIN set has no match at 0.99 V. SYSTEM then loses every mode because each requires NOM.

In the original table, drift produces one missing-row report. Both files reject the same voltage.

Recorded. Voltage drift before conversion.
OPENPA-CHECK D8 @ 2000: supplies VIN CPU MEM GND match no row of power state table BOARD_MODES (board.upf:22)
drift cpu_on=1 mem_on=1 mode=<none>

Both files allow Cold and Work. The next failure concerns how the board gets from one to the other.

Read a Legacy describe_state_transition

After Cold, CPU wakes alongside MEM. Memory needed a head start.

Cold and Work each have a row. The old file calls their forbidden shortcut rush.

Compatibility form run on the converted domain.
describe_state_transition rush -object SYSTEM -from Cold -to Work -illegal

In the legacy run, D8 names rush at 6000 ps even though shortcut reports mode=Work.

Recorded. OpenPA executes the older transition declaration.
cold cpu_on=0 mem_on=0 mode=Cold
OPENPA-CHECK D8 @ 6000: illegal transition rush on SYSTEM: Cold -> Work (board.upf:43)
shortcut cpu_on=1 mem_on=1 mode=Work

The original PST counted shortcut as another visit to Work.

Recorded. PST coverage without rush.
shortcut cpu_on=1 mem_on=1 mode=Work
OPENPA-COVER state pst BOARD_MODES Work 2

OpenPA 0.3.0 executes this deprecated form (6.2, D.3). Migrate it with add_state_transition.

Keep the destination legal while translating the arc. Changing the state itself would also reject a correctly staged wake.

Declare the Directed Arc with add_state_transition

To preserve the wake sequence on pmu_soc, keep the endpoints of rush in order.

Compatibility file

describe_state_transition rush -object SYSTEM -from Cold -to Work -illegal

The transition name appears first.

Current file

add_state_transition SYSTEM -domain -transition {rush -from Cold -to Work -illegal}

Group the endpoints under rush.

add_state_transition defines named changes on an object (6.7). Here -domain selects SYSTEM and -transition contains the source, destination and legality.

The current run reports Cold to Work at 6000 ps, matching the endpoint order in the old declaration.

Recorded. Current arc at wake.
OPENPA-CHECK D8 @ 6000: illegal transition rush on SYSTEM: Cold -> Work (board.upf:43)
shortcut cpu_on=1 mem_on=1 mode=Work

Power MEM first. Sample Nap before powering CPU.

Recorded. Staged wake with rush enabled.
stage cpu_on=0 mem_on=1 mode=Nap
resume cpu_on=1 mem_on=1 mode=Work
OPENPA-CHECK D8 @ 10000: power domain SYSTEM is in none of its defined power states (UNDEFINED), which were declared -complete (board.upf:42)

Now stage reads Nap and resume reads Work. Only the missing pair still raises D8.

A Direct Wake and a Staged WakeAlign both sequences at Cold.
012DirectColdWork<none>StagedColdNapWork
Scroll horizontally ↔
  1. Cycle 0

    Both boards are in Cold.

  2. Cycle 1

    Direct wake enters Work. Staged wake first enters Nap.

  3. Cycle 2

    Staged enters Work. Direct tests the missing pair.

Samples aligned by sequence position after Cold. Each column shows a recorded current state.

On the way to Cold, the bench visits Work, Nap and Cold in order. Count those two steps with -paired (6.7).

Recorded experiment: add two legal coverage bins alongside rush.
add_state_transition SYSTEM -domain -update \
  -transition {via -paired {{Work Nap} {Nap Cold}} -legal}
Recorded coverage for via.
OPENPA-COVER declared via SYSTEM Work -> Nap 1
OPENPA-COVER declared via SYSTEM Nap -> Cold 1

Each via row counts one visit. Separate source and destination lists would also pair Work with Cold.

What if software needs a mode spanning blocks outside one domain?

Software treats CPU and MEM as one panel, even when they belong to separate blocks.

At park, CPU is off and MEM is on. Software wants to call that pair Warm without adding a block to pmu_soc.

Before: two column sets

create_supply_set openpa_BOARD_MODES_CPU -function {power CPU}
create_supply_set openpa_BOARD_MODES_MEM -function {power MEM}

Each supply has its own state vocabulary.

After: a group in the same scope

create_power_state_group PANEL
add_power_state PANEL -group -state {Warm -logic_expr {openpa_BOARD_MODES_CPU == CUT && openpa_BOARD_MODES_MEM == KEEP}}

Drawn standard intent. Warm describes the panel’s two changing rails.

At park, CUT and KEEP both hold, so the drawing gives Warm.

Recorded inputs for the group drawing.
park cpu_on=0 mem_on=1 mode=Nap
cold cpu_on=0 mem_on=0 mode=Cold

At cold, MEM leaves KEEP, so Warm no longer holds. A group can combine states in its scope or below (6.22).

Warm describes only the panel. To represent the whole board, include VIN and GND.

Recorded OpenPA 0.3.0 refusal on PANEL. The Warm grouping above is drawn from 6.22.
group.upf:1: create_power_state_group is not supported (IEEE 1801-2024 6.22)

In W4.12.1, preserve the camera board’s combinations. In W4.12.2, keep both endpoints legal and forbid the two direct shortcuts.

Try It

Run the converted domain. Find both D8 reports. Identify the one caused by an arc and the one caused by a missing destination.

At shortcut, bring up MEM first, call sample("stage"), then bring up CPU. The wake now passes through Nap.

Keep the final MEM cut. You should still see the missing-pair error even after fixing the wake order.

The quiz runs the original PST against the same stimulus. Compare its rail pair at shortcut and its later row-miss message.

RUNIcarus Verilog · in your browser
Edit the code, then run it
Expected: OPENPA-INFO corruption=x seed=1 start cpu_on=1 mem_on=1 mode=Work park cpu_on=0 mem_on=1 mode=Nap cold cpu_on=0 mem_on=0 mode=Cold OPENPA-CHECK D8 @ 6000: illegal transition rush on SYSTEM: Cold -> Work (board.upf:43) shortcut cpu_on=1 mem_on=1 mode=Work OPENPA-CHECK D8 @ 8000: power domain SYSTEM is in none of its defined power states (UNDEFINED), which were declared -complete (board.upf:42) missing cpu_on=1 mem_on=0 mode=<none> OPENPA-SUMMARY D1=0 D2=0 D3=0 D4=0 D5=0 D6=0 D7=0 D8=2 D9=0 D10=0 D11=0 D12=0 D13=0 D14=0 OPENPA-COVER state supply_set openpa_BOARD_MODES_VIN NOM 1 OPENPA-COVER state supply_set openpa_BOARD_MODES_CPU HIGH 2 OPENPA-COVER state supply_set openpa_BOARD_MODES_CPU CUT 1 OPENPA-COVER transition supply_set openpa_BOARD_MODES_CPU HIGH -> CUT 1 OPENPA-COVER transition supply_set openpa_BOARD_MODES_CPU CUT -> HIGH 1 OPENPA-COVER state supply_set openpa_BOARD_MODES_MEM KEEP 2 OPENPA-COVER state supply_set openpa_BOARD_MODES_MEM CUT 2 OPENPA-COVER transition supply_set openpa_BOARD_MODES_MEM KEEP -> CUT 2 OPENPA-COVER transition supply_set openpa_BOARD_MODES_MEM CUT -> KEEP 1 OPENPA-COVER state supply_set openpa_BOARD_MODES_GND REF 1 OPENPA-COVER state domain SYSTEM Work 2 OPENPA-COVER state domain SYSTEM Nap 1 OPENPA-COVER state domain SYSTEM Cold 1 OPENPA-COVER state domain SYSTEM <none> 1 OPENPA-COVER transition domain SYSTEM Work -> Nap 1 OPENPA-COVER transition domain SYSTEM Work -> <none> 1 OPENPA-COVER transition domain SYSTEM Nap -> Cold 1 OPENPA-COVER transition domain SYSTEM Cold -> Work 1 OPENPA-COVER-SUMMARY states=9/9 declared_transitions=0/0 sequences=0/0
Read the power intent: board.upf
upf_version 4.0
set_design_top pmu_soc
create_power_domain SYSTEM -include_scope
create_supply_port VIN
create_supply_net VIN_N
connect_supply_net VIN_N -ports {VIN}
create_supply_port CPU
create_supply_net CPU_N
connect_supply_net CPU_N -ports {CPU}
create_supply_port MEM
create_supply_net MEM_N
connect_supply_net MEM_N -ports {MEM}
create_supply_port GND
create_supply_net GND_N
connect_supply_net GND_N -ports {GND}
create_supply_set BOARD -function {power VIN_N} -function {ground GND_N}
associate_supply_set BOARD -handle SYSTEM.primary
# Generated by openpa pst2aps: BOARD_MODES as add_power_state (UPF 2.x form).
# Replace the add_port_state, create_pst and add_pst_state commands with these lines.
create_supply_set openpa_BOARD_MODES_VIN -function {power VIN}
add_power_state openpa_BOARD_MODES_VIN -supply \
    -state {NOM -supply_expr {power == {FULL_ON 1}}} \
    -complete
create_supply_set openpa_BOARD_MODES_CPU -function {power CPU}
add_power_state openpa_BOARD_MODES_CPU -supply \
    -state {HIGH -supply_expr {power == {FULL_ON 1}}} \
    -state {CUT -supply_expr {power == OFF}} \
    -complete
create_supply_set openpa_BOARD_MODES_MEM -function {power MEM}
add_power_state openpa_BOARD_MODES_MEM -supply \
    -state {KEEP -supply_expr {power == {FULL_ON 0.8}}} \
    -state {CUT -supply_expr {power == OFF}} \
    -complete
create_supply_set openpa_BOARD_MODES_GND -function {power GND}
add_power_state openpa_BOARD_MODES_GND -supply \
    -state {REF -supply_expr {power == {FULL_ON 0}}} \
    -complete
add_power_state SYSTEM -domain \
    -state {Work -logic_expr {openpa_BOARD_MODES_VIN == NOM && openpa_BOARD_MODES_CPU == HIGH && openpa_BOARD_MODES_MEM == KEEP && openpa_BOARD_MODES_GND == REF}} \
    -state {Nap -logic_expr {openpa_BOARD_MODES_VIN == NOM && openpa_BOARD_MODES_CPU == CUT && openpa_BOARD_MODES_MEM == KEEP && openpa_BOARD_MODES_GND == REF}} \
    -state {Cold -logic_expr {openpa_BOARD_MODES_VIN == NOM && openpa_BOARD_MODES_CPU == CUT && openpa_BOARD_MODES_MEM == CUT && openpa_BOARD_MODES_GND == REF}}
add_power_state SYSTEM -domain -update -complete
add_state_transition SYSTEM -domain -transition {rush -from Cold -to Work -illegal}
Read the power-unaware RTL: pmu_soc.sv
// pmu_soc: two power domains. The top and the controller are always on; u_core can be switched off.
// The RTL is power-unaware: no isolation cell, no supply, no retention register is written here.
module pmu_soc (
  input  logic       clk,
  input  logic       rst_n,
  input  logic       sleep_req,
  input  logic       wake_req,
  input  logic       en,
  input  logic [7:0] d,
  input  logic [1:0] rf_addr,
  input  logic       rf_we,
  output logic [7:0] total,
  output logic       led,
  output logic [7:0] rd,
  output logic [3:0] beats,
  output logic [7:0] status,
  output logic [2:0] pmu_state
);
  logic iso_en, save, restore, pwr_en, core_rst_n;
  logic [7:0] acc, rf_rd;
  logic busy;
  logic [3:0] core_beats;

  pmu u_pmu (
    .clk        (clk),
    .rst_n      (rst_n),
    .sleep_req  (sleep_req),
    .wake_req   (wake_req),
    .iso_en     (iso_en),
    .save       (save),
    .restore    (restore),
    .pwr_en     (pwr_en),
    .core_rst_n (core_rst_n),
    .state_o    (pmu_state)
  );

  core u_core (
    .clk     (clk),
    .rst_n   (core_rst_n),
    .en      (en),
    .d       (d),
    .rf_addr (rf_addr),
    .rf_we   (rf_we),
    .acc     (acc),
    .rf_rd   (rf_rd),
    .busy    (busy),
    .beats   (core_beats)
  );

  // Always-on consumers of the core's outputs.
  assign total = acc;
  assign led   = busy;
  assign rd    = rf_rd;
  assign beats = core_beats;
  // A status register: keeps the last accumulator value seen while the core was busy.
  always_ff @(posedge clk or negedge rst_n)
    if (!rst_n) status <= '0;
    else if (busy) status <= acc;
endmodule
Read the power-unaware RTL: pmu.sv
// pmu_soc: the always-on power controller. Power-unaware RTL: it only drives control signals.
// Sleep: isolate, save, switch off. Wake: switch on, reset, restore, release isolation.
module pmu (
  input  logic       clk,
  input  logic       rst_n,
  input  logic       sleep_req,
  input  logic       wake_req,
  output logic       iso_en,
  output logic       save,
  output logic       restore,
  output logic       pwr_en,
  output logic       core_rst_n,
  output logic [2:0] state_o
);
  typedef enum logic [2:0] { RUN, ISOLATE, SAVE, OFF, PWRUP, RESET, RESTORE, RELEASE } st_e;
  st_e st;
  always_ff @(posedge clk or negedge rst_n)
    if (!rst_n) st <= RUN;
    else case (st)
      RUN:     if (sleep_req) st <= ISOLATE;
      ISOLATE: st <= SAVE;
      SAVE:    st <= OFF;
      OFF:     if (wake_req) st <= PWRUP;
      PWRUP:   st <= RESET;
      RESET:   st <= RESTORE;
      RESTORE: st <= RELEASE;
      RELEASE: st <= RUN;
      default: st <= RUN;
    endcase
  assign iso_en     = (st != RUN);
  assign save       = (st == SAVE);
  assign restore    = (st == RESTORE);
  assign pwr_en     = !(st == OFF);
  assign core_rst_n = rst_n && (st != RESET);
  assign state_o    = st;
endmodule
Read the power-unaware RTL: core.sv
// pmu_soc: the switchable core. An accumulator, a beat counter and a 4-word register file.
// Power-unaware RTL: nothing here knows about supplies.
module core (
  input  logic       clk,
  input  logic       rst_n,
  input  logic       en,
  input  logic [7:0] d,
  input  logic [1:0] rf_addr,
  input  logic       rf_we,
  output logic [7:0] acc,
  output logic [7:0] rf_rd,
  output logic       busy,
  output logic [3:0] beats
);
  logic [7:0] rf [0:3];
  always_ff @(posedge clk or negedge rst_n)
    if (!rst_n) begin
      acc   <= '0;
      beats <= '0;
    end else if (en) begin
      acc   <= acc + d;
      beats <= beats + 4'd1;
    end
  always_ff @(posedge clk)
    if (rf_we) rf[rf_addr] <= acc;
  assign rf_rd = rf[rf_addr];
  assign busy  = en;
endmodule
What UPF added: 18 objects

4 supply port, 4 supply net, 5 supply set, 4 register corruption, 1 memory corruption.

ObjectWhereDetailRuleUPF line
Supply portVINboard.upf:4
Supply portCPUboard.upf:7
Supply portMEMboard.upf:10
Supply portGNDboard.upf:13
Supply netVIN_Nboard.upf:4
Supply netCPU_Nboard.upf:7
Supply netMEM_Nboard.upf:10
Supply netGND_Nboard.upf:13
Supply setBOARDboard.upf:16
Supply setopenpa_BOARD_MODES_VINboard.upf:20
Supply setopenpa_BOARD_MODES_CPUboard.upf:24
Supply setopenpa_BOARD_MODES_MEMboard.upf:29
Supply setopenpa_BOARD_MODES_GNDboard.upf:34
Register corruptionstatusC1board.upf:3
Register corruptionu_core.accC1board.upf:3
Register corruptionu_core.beatsC1board.upf:3
Register corruptionu_pmu.stC1board.upf:3
Memory corruptionu_core.rfC1board.upf:3
Read the power-aware copy that runs (generated by OpenPA 0.3.0): pa_pmu_soc.sv
// pa_pmu_soc.sv: power-aware copy of pmu_soc, generated by OpenPA from board.upf.
// Do not edit: regenerate. Simulators: Icarus 12 (4-state, X corruption) or Verilator 5 with --timing (2-state).
// Build with -Wno-fatal on Verilator: forced registers raise MULTIDRIVEN warnings.
`timescale 1ns/1ps
// ---------------------------------------------------------------------------
// package UPF: generated by OpenPA. Supply types, supply_on/supply_off and the power
// state of the design. Names starting with openpa_ are internal.
// ---------------------------------------------------------------------------
package UPF;
  typedef string upfStringT; typedef int upfIntegerT; typedef bit upfBooleanT; typedef logic upfLogicT; typedef real upfRealT; typedef int upfHandleT;
  typedef enum { OFF, FULL_ON, PARTIAL_ON, UNDETERMINED } upfSupplyStateE;
  typedef struct packed { upfSupplyStateE state; int voltage; } upfSupplyTypeT;  // voltage in microvolts
  typedef upfSupplyTypeT supply_net_type;
  bit openpa_armed;        // set by the first call that drives a supply
  bit openpa_kick;         // pulsed once at time 0 to evaluate everything
  bit openpa_xmode;        // 1: corrupt to X; 0: seeded 2-state values
  int unsigned openpa_seed = 1;
  int openpa_cmode;        // 2-state corruption: 0 random, 1 all zero, 2 all one
  supply_net_type openpa_port_VIN;   // supply port VIN (board.upf:4)
  supply_net_type openpa_port_CPU;   // supply port CPU (board.upf:7)
  supply_net_type openpa_port_MEM;   // supply port MEM (board.upf:10)
  supply_net_type openpa_port_GND;   // supply port GND (board.upf:13)
  supply_net_type openpa_net_VIN_N;   // supply net VIN_N
  supply_net_type openpa_net_CPU_N;   // supply net CPU_N
  supply_net_type openpa_net_MEM_N;   // supply net MEM_N
  supply_net_type openpa_net_GND_N;   // supply net GND_N
  bit openpa_ss_openpa_BOARD_MODES_VIN_ok; int unsigned openpa_ss_openpa_BOARD_MODES_VIN_ep; int openpa_ss_openpa_BOARD_MODES_VIN_st = -1; bit openpa_ss_openpa_BOARD_MODES_VIN_multi; int openpa_ss_openpa_BOARD_MODES_VIN_sim = 5; bit [0:0] openpa_ss_openpa_BOARD_MODES_VIN_a;   // supply set openpa_BOARD_MODES_VIN
  bit openpa_ss_openpa_BOARD_MODES_CPU_ok; int unsigned openpa_ss_openpa_BOARD_MODES_CPU_ep; int openpa_ss_openpa_BOARD_MODES_CPU_st = -1; bit openpa_ss_openpa_BOARD_MODES_CPU_multi; int openpa_ss_openpa_BOARD_MODES_CPU_sim = 5; bit [1:0] openpa_ss_openpa_BOARD_MODES_CPU_a;   // supply set openpa_BOARD_MODES_CPU
  bit openpa_ss_openpa_BOARD_MODES_MEM_ok; int unsigned openpa_ss_openpa_BOARD_MODES_MEM_ep; int openpa_ss_openpa_BOARD_MODES_MEM_st = -1; bit openpa_ss_openpa_BOARD_MODES_MEM_multi; int openpa_ss_openpa_BOARD_MODES_MEM_sim = 5; bit [1:0] openpa_ss_openpa_BOARD_MODES_MEM_a;   // supply set openpa_BOARD_MODES_MEM
  bit openpa_ss_openpa_BOARD_MODES_GND_ok; int unsigned openpa_ss_openpa_BOARD_MODES_GND_ep; int openpa_ss_openpa_BOARD_MODES_GND_st = -1; bit openpa_ss_openpa_BOARD_MODES_GND_multi; int openpa_ss_openpa_BOARD_MODES_GND_sim = 5; bit [0:0] openpa_ss_openpa_BOARD_MODES_GND_a;   // supply set openpa_BOARD_MODES_GND
  bit openpa_ss_BOARD_ok; int unsigned openpa_ss_BOARD_ep; int openpa_ss_BOARD_st = -1; bit openpa_ss_BOARD_multi; int openpa_ss_BOARD_sim = 5;   // supply set BOARD
  bit openpa_dom_SYSTEM_ok; int unsigned openpa_dom_SYSTEM_ep; int openpa_dom_SYSTEM_sim = 5;   // power domain SYSTEM: ok = powered (simstate not CORRUPT); sim = simstate code (board.upf:3)
  // simstate codes, by IEEE 1801-2024 4.8 precedence: 0 NORMAL, 1 CORRUPT_STATE_ON_CHANGE, 2 CORRUPT_STATE_ON_ACTIVITY,
  // 3 CORRUPT_ON_CHANGE, 4 CORRUPT_ON_ACTIVITY, 5 CORRUPT (and NOT_NORMAL, 9.5.8); README "Simstates"
  int openpa_ds_SYSTEM_st = -1; bit openpa_ds_SYSTEM_multi; bit [2:0] openpa_ds_SYSTEM_a;   // power state of domain SYSTEM
  function automatic logic [63:0] openpa_mix(int unsigned id, int unsigned ep, int unsigned lane);
    logic [63:0] z;
    if (openpa_cmode == 1) return 64'd0;
    if (openpa_cmode == 2) return ~64'd0;
    z = {32'd0, openpa_seed} * 64'h9E3779B97F4A7C15 + {32'd0, id} * 64'hC2B2AE3D27D4EB4F + {32'd0, ep} * 64'h165667B19E3779F9 + {32'd0, lane} * 64'hD6E8FEB86659FD93;
    z = (z ^ (z >> 30)) * 64'hBF58476D1CE4E5B9;
    z = (z ^ (z >> 27)) * 64'h94D049BB133111EB;
    return z ^ (z >> 31);
  endfunction
  function automatic bit openpa_bit(int unsigned id, int unsigned ep); logic [63:0] z; z = openpa_mix(id, ep, 0); return z[0]; endfunction
  function automatic int openpa_uv(real v); return $rtoi(v * 1.0e6 + (v < 0.0 ? -0.5 : 0.5)); endfunction
  // supply_on: FULL_ON at the given voltage (11.2.4; default 1.0 V)
  function automatic upfBooleanT supply_on(string pad_name, real value = 1.0);
    openpa_armed = 1;
    if (pad_name == "VIN") begin openpa_port_VIN.state = FULL_ON; openpa_port_VIN.voltage = openpa_uv(value); return 1; end
    if (pad_name == "CPU") begin openpa_port_CPU.state = FULL_ON; openpa_port_CPU.voltage = openpa_uv(value); return 1; end
    if (pad_name == "MEM") begin openpa_port_MEM.state = FULL_ON; openpa_port_MEM.voltage = openpa_uv(value); return 1; end
    if (pad_name == "GND") begin openpa_port_GND.state = FULL_ON; openpa_port_GND.voltage = openpa_uv(value); return 1; end
    if (pad_name == "VIN_N") begin $display("OPENPA-ERROR supply_on(\"%s\"): VIN_N already has a driver (port VIN); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "BOARD.power") begin $display("OPENPA-ERROR supply_on(\"%s\"): BOARD.power already has a driver (port VIN); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "openpa_BOARD_MODES_VIN.power") begin $display("OPENPA-ERROR supply_on(\"%s\"): openpa_BOARD_MODES_VIN.power already has a driver (port VIN); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "SYSTEM.primary.power") begin $display("OPENPA-ERROR supply_on(\"%s\"): SYSTEM.primary.power already has a driver (port VIN); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "CPU_N") begin $display("OPENPA-ERROR supply_on(\"%s\"): CPU_N already has a driver (port CPU); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "openpa_BOARD_MODES_CPU.power") begin $display("OPENPA-ERROR supply_on(\"%s\"): openpa_BOARD_MODES_CPU.power already has a driver (port CPU); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "MEM_N") begin $display("OPENPA-ERROR supply_on(\"%s\"): MEM_N already has a driver (port MEM); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "openpa_BOARD_MODES_MEM.power") begin $display("OPENPA-ERROR supply_on(\"%s\"): openpa_BOARD_MODES_MEM.power already has a driver (port MEM); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "GND_N") begin $display("OPENPA-ERROR supply_on(\"%s\"): GND_N already has a driver (port GND); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "BOARD.ground") begin $display("OPENPA-ERROR supply_on(\"%s\"): BOARD.ground already has a driver (port GND); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "openpa_BOARD_MODES_GND.power") begin $display("OPENPA-ERROR supply_on(\"%s\"): openpa_BOARD_MODES_GND.power already has a driver (port GND); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "SYSTEM.primary.ground") begin $display("OPENPA-ERROR supply_on(\"%s\"): SYSTEM.primary.ground already has a driver (port GND); drive its root supply instead", pad_name); return 0; end
    $display("OPENPA-ERROR supply_on(\"%s\"): no supply port or root supply net of that name (writable: VIN CPU MEM GND)", pad_name);
    return 0;
  endfunction
  // supply_off: OFF, voltage unchanged (9.3.1); a second argument is accepted and ignored
  function automatic upfBooleanT supply_off(string pad_name, real value = 0.0);
    openpa_armed = 1;
    if (pad_name == "VIN") begin openpa_port_VIN.state = OFF; return 1; end
    if (pad_name == "CPU") begin openpa_port_CPU.state = OFF; return 1; end
    if (pad_name == "MEM") begin openpa_port_MEM.state = OFF; return 1; end
    if (pad_name == "GND") begin openpa_port_GND.state = OFF; return 1; end
    if (pad_name == "VIN_N") begin $display("OPENPA-ERROR supply_off(\"%s\"): VIN_N already has a driver (port VIN); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "BOARD.power") begin $display("OPENPA-ERROR supply_off(\"%s\"): BOARD.power already has a driver (port VIN); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "openpa_BOARD_MODES_VIN.power") begin $display("OPENPA-ERROR supply_off(\"%s\"): openpa_BOARD_MODES_VIN.power already has a driver (port VIN); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "SYSTEM.primary.power") begin $display("OPENPA-ERROR supply_off(\"%s\"): SYSTEM.primary.power already has a driver (port VIN); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "CPU_N") begin $display("OPENPA-ERROR supply_off(\"%s\"): CPU_N already has a driver (port CPU); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "openpa_BOARD_MODES_CPU.power") begin $display("OPENPA-ERROR supply_off(\"%s\"): openpa_BOARD_MODES_CPU.power already has a driver (port CPU); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "MEM_N") begin $display("OPENPA-ERROR supply_off(\"%s\"): MEM_N already has a driver (port MEM); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "openpa_BOARD_MODES_MEM.power") begin $display("OPENPA-ERROR supply_off(\"%s\"): openpa_BOARD_MODES_MEM.power already has a driver (port MEM); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "GND_N") begin $display("OPENPA-ERROR supply_off(\"%s\"): GND_N already has a driver (port GND); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "BOARD.ground") begin $display("OPENPA-ERROR supply_off(\"%s\"): BOARD.ground already has a driver (port GND); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "openpa_BOARD_MODES_GND.power") begin $display("OPENPA-ERROR supply_off(\"%s\"): openpa_BOARD_MODES_GND.power already has a driver (port GND); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "SYSTEM.primary.ground") begin $display("OPENPA-ERROR supply_off(\"%s\"): SYSTEM.primary.ground already has a driver (port GND); drive its root supply instead", pad_name); return 0; end
    $display("OPENPA-ERROR supply_off(\"%s\"): no supply port or root supply net of that name (writable: VIN CPU MEM GND)", pad_name);
    return 0;
  endfunction
  // supply_partial_on: PARTIAL_ON at the given voltage (11.2.4)
  function automatic upfBooleanT supply_partial_on(string pad_name, real value = 1.0);
    openpa_armed = 1;
    if (pad_name == "VIN") begin openpa_port_VIN.state = PARTIAL_ON; openpa_port_VIN.voltage = openpa_uv(value); return 1; end
    if (pad_name == "CPU") begin openpa_port_CPU.state = PARTIAL_ON; openpa_port_CPU.voltage = openpa_uv(value); return 1; end
    if (pad_name == "MEM") begin openpa_port_MEM.state = PARTIAL_ON; openpa_port_MEM.voltage = openpa_uv(value); return 1; end
    if (pad_name == "GND") begin openpa_port_GND.state = PARTIAL_ON; openpa_port_GND.voltage = openpa_uv(value); return 1; end
    if (pad_name == "VIN_N") begin $display("OPENPA-ERROR supply_partial_on(\"%s\"): VIN_N already has a driver (port VIN); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "BOARD.power") begin $display("OPENPA-ERROR supply_partial_on(\"%s\"): BOARD.power already has a driver (port VIN); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "openpa_BOARD_MODES_VIN.power") begin $display("OPENPA-ERROR supply_partial_on(\"%s\"): openpa_BOARD_MODES_VIN.power already has a driver (port VIN); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "SYSTEM.primary.power") begin $display("OPENPA-ERROR supply_partial_on(\"%s\"): SYSTEM.primary.power already has a driver (port VIN); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "CPU_N") begin $display("OPENPA-ERROR supply_partial_on(\"%s\"): CPU_N already has a driver (port CPU); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "openpa_BOARD_MODES_CPU.power") begin $display("OPENPA-ERROR supply_partial_on(\"%s\"): openpa_BOARD_MODES_CPU.power already has a driver (port CPU); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "MEM_N") begin $display("OPENPA-ERROR supply_partial_on(\"%s\"): MEM_N already has a driver (port MEM); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "openpa_BOARD_MODES_MEM.power") begin $display("OPENPA-ERROR supply_partial_on(\"%s\"): openpa_BOARD_MODES_MEM.power already has a driver (port MEM); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "GND_N") begin $display("OPENPA-ERROR supply_partial_on(\"%s\"): GND_N already has a driver (port GND); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "BOARD.ground") begin $display("OPENPA-ERROR supply_partial_on(\"%s\"): BOARD.ground already has a driver (port GND); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "openpa_BOARD_MODES_GND.power") begin $display("OPENPA-ERROR supply_partial_on(\"%s\"): openpa_BOARD_MODES_GND.power already has a driver (port GND); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "SYSTEM.primary.ground") begin $display("OPENPA-ERROR supply_partial_on(\"%s\"): SYSTEM.primary.ground already has a driver (port GND); drive its root supply instead", pad_name); return 0; end
    $display("OPENPA-ERROR supply_partial_on(\"%s\"): no supply port or root supply net of that name (writable: VIN CPU MEM GND)", pad_name);
    return 0;
  endfunction
  // set_supply_state: the state only, voltage unchanged (9.3.1)
  function automatic upfBooleanT set_supply_state(string pad_name, upfSupplyStateE supply_state);
    openpa_armed = 1;
    if (pad_name == "VIN") begin openpa_port_VIN.state = supply_state; return 1; end
    if (pad_name == "CPU") begin openpa_port_CPU.state = supply_state; return 1; end
    if (pad_name == "MEM") begin openpa_port_MEM.state = supply_state; return 1; end
    if (pad_name == "GND") begin openpa_port_GND.state = supply_state; return 1; end
    if (pad_name == "VIN_N") begin $display("OPENPA-ERROR set_supply_state(\"%s\"): VIN_N already has a driver (port VIN); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "BOARD.power") begin $display("OPENPA-ERROR set_supply_state(\"%s\"): BOARD.power already has a driver (port VIN); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "openpa_BOARD_MODES_VIN.power") begin $display("OPENPA-ERROR set_supply_state(\"%s\"): openpa_BOARD_MODES_VIN.power already has a driver (port VIN); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "SYSTEM.primary.power") begin $display("OPENPA-ERROR set_supply_state(\"%s\"): SYSTEM.primary.power already has a driver (port VIN); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "CPU_N") begin $display("OPENPA-ERROR set_supply_state(\"%s\"): CPU_N already has a driver (port CPU); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "openpa_BOARD_MODES_CPU.power") begin $display("OPENPA-ERROR set_supply_state(\"%s\"): openpa_BOARD_MODES_CPU.power already has a driver (port CPU); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "MEM_N") begin $display("OPENPA-ERROR set_supply_state(\"%s\"): MEM_N already has a driver (port MEM); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "openpa_BOARD_MODES_MEM.power") begin $display("OPENPA-ERROR set_supply_state(\"%s\"): openpa_BOARD_MODES_MEM.power already has a driver (port MEM); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "GND_N") begin $display("OPENPA-ERROR set_supply_state(\"%s\"): GND_N already has a driver (port GND); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "BOARD.ground") begin $display("OPENPA-ERROR set_supply_state(\"%s\"): BOARD.ground already has a driver (port GND); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "openpa_BOARD_MODES_GND.power") begin $display("OPENPA-ERROR set_supply_state(\"%s\"): openpa_BOARD_MODES_GND.power already has a driver (port GND); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "SYSTEM.primary.ground") begin $display("OPENPA-ERROR set_supply_state(\"%s\"): SYSTEM.primary.ground already has a driver (port GND); drive its root supply instead", pad_name); return 0; end
    $display("OPENPA-ERROR set_supply_state(\"%s\"): no supply port or root supply net of that name (writable: VIN CPU MEM GND)", pad_name);
    return 0;
  endfunction
  // set_power_state (9.3.1) is not supported: OpenPA has no deferred power states. A call is reported, never ignored.
  function automatic upfBooleanT set_power_state(string object_name, string power_state);
    $display("OPENPA-ERROR set_power_state(\"%s\", \"%s\"): not supported by OpenPA; drive the supplies with supply_on, supply_off or set_supply_state", object_name, power_state);
    return 0;
  endfunction
  // Supply queries (11.2.4). Names: supply ports, supply nets and supply set functions as the UPF wrote them.
  function automatic upfSupplyTypeT get_supply_value(string name);
    if (name == "VIN" || name == "VIN_N" || name == "BOARD.power" || name == "openpa_BOARD_MODES_VIN.power" || name == "SYSTEM.primary.power") return openpa_net_VIN_N;
    if (name == "CPU" || name == "CPU_N" || name == "openpa_BOARD_MODES_CPU.power") return openpa_net_CPU_N;
    if (name == "MEM" || name == "MEM_N" || name == "openpa_BOARD_MODES_MEM.power") return openpa_net_MEM_N;
    if (name == "GND" || name == "GND_N" || name == "BOARD.ground" || name == "openpa_BOARD_MODES_GND.power" || name == "SYSTEM.primary.ground") return openpa_net_GND_N;
    $display("OPENPA-ERROR get_supply_value(\"%s\"): no supply net, port or supply set function of that name", name);
    return 0;
  endfunction
  function automatic upfRealT get_supply_voltage(upfSupplyTypeT arg); return arg.voltage / 1.0e6; endfunction
  // 11.2.4: 1 for FULL_ON; 0 otherwise.
  function automatic upfBooleanT get_supply_on_state(upfSupplyTypeT arg); return arg.state == FULL_ON; endfunction
  function automatic upfSupplyStateE get_supply_state(upfSupplyTypeT arg); return arg.state; endfunction
endpackage
// ---------------------------------------------------------------------------
// OpenPA cells (generated; do not edit)
// ---------------------------------------------------------------------------
// openpa_corrupt: rule C2. Passes d while the driving domain is NORMAL; otherwise drives X (4-state)
// or a seeded value (2-state). The value is computed ahead for the episode the next power-down starts
// (ep + 1 while ok), so at power-down the output goes straight from d to the new value: no delta glitch
// through the previous episode's value (Icarus would turn one into a clock edge).
module openpa_corrupt #(parameter int W = 1, parameter int unsigned ID = 0) (
  input  logic [W-1:0] d,
  output logic [W-1:0] q,
  input  bit           ok,
  input  int unsigned  ep
);
  localparam int L = (W + 63) / 64;
  logic [L*64-1:0] cv;
  always @(ep or ok or UPF::openpa_kick)
    for (int i = 0; i < L; i++) cv[i*64 +: 64] = UPF::openpa_mix(ID, ok ? ep + 1 : ep, i);
  assign q = ok ? d : (UPF::openpa_xmode ? {W{1'bx}} : cv[W-1:0]);
endmodule

// openpa_corrupt_sim: rule C2 for a domain that has intermediate simstates (IEEE 1801-2024 9.5). As
// openpa_corrupt, and also corrupt while lhit is set (CORRUPT_ON_ACTIVITY after input activity), or after d
// changed while coc is set (CORRUPT_ON_CHANGE); leaving CORRUPT_ON_CHANGE clears that.
module openpa_corrupt_sim #(parameter int W = 1, parameter int unsigned ID = 0) (
  input  logic [W-1:0] d,
  output logic [W-1:0] q,
  input  bit           ok,
  input  int unsigned  ep,
  input  bit           lhit,
  input  bit           coc
);
  localparam int L = (W + 63) / 64;
  logic [L*64-1:0] cv;
  bit chg;
  always @(ep or ok or UPF::openpa_kick)
    for (int i = 0; i < L; i++) cv[i*64 +: 64] = UPF::openpa_mix(ID, ok ? ep + 1 : ep, i);
  // verilator lint_off MULTIDRIVEN
  for (genvar i = 0; i < W; i++) begin : g_chg
    always @(posedge d[i] or negedge d[i]) if (coc && ok) chg = 1'b1;
  end
  always @(negedge coc) chg = 1'b0;
  // verilator lint_on MULTIDRIVEN
  assign q = (ok && !lhit && !chg) ? d : (UPF::openpa_xmode ? {W{1'bx}} : cv[W-1:0]);
endmodule

// openpa_iso: rules I1-I4 (IEEE 1801-2024 9.8). CLAMP 0, 1, 2 (latch: the value the input had while the enable
// was inactive) or 3 (Z: high impedance on 4-state; 0 on 2-state backends, which cannot represent Z).
// sup_ok is 1 while the isolation supply is NORMAL (always, for a strategy with no supply); otherwise the output,
// and a latched value, are corrupt. An enable at X or Z corrupts the output and the latched value.
module openpa_iso #(parameter int W = 1, parameter int CLAMP = 0, parameter bit SENSE = 1'b1, parameter int unsigned ID = 0) (
  input  logic [W-1:0] d,
  output logic [W-1:0] q,
  input  logic         en,
  input  bit           sup_ok,
  input  int unsigned  sup_ep
);
  localparam int L = (W + 63) / 64;
  logic [L*64-1:0] cv;
  logic [W-1:0] held;
  always @(sup_ep or sup_ok or UPF::openpa_kick)
    for (int i = 0; i < L; i++) cv[i*64 +: 64] = UPF::openpa_mix(ID + 32'h4000_0000, sup_ok ? sup_ep + 1 : sup_ep, i);
  wire active   = (en === SENSE);
  wire inactive = (en === !SENSE);
  wire [W-1:0] bad    = UPF::openpa_xmode ? {W{1'bx}} : cv[W-1:0];
  if (CLAMP == 2) begin : g_latch
    always @(d or en or sup_ok or bad) if (!sup_ok || !(active || inactive)) held = bad; else if (inactive) held = d;
  end
  wire [W-1:0] clampv = (CLAMP == 3) ? (UPF::openpa_xmode ? {W{1'bz}} : {W{1'b0}}) : (CLAMP == 2) ? held : (CLAMP == 1) ? {W{1'b1}} : {W{1'b0}};
  assign q = !sup_ok ? bad : active ? clampv : inactive ? d : bad;
endmodule

// openpa_ls: rule L1 (IEEE 1801-2024 9.9). Passes d while every supply set of the cell is NORMAL; otherwise corrupt.
module openpa_ls #(parameter int W = 1, parameter int unsigned ID = 0) (
  input  logic [W-1:0] d,
  output logic [W-1:0] q,
  input  bit           src_ok,
  input  bit           dst_ok,
  input  int unsigned  ep
);
  localparam int L = (W + 63) / 64;
  logic [L*64-1:0] cv;
  always @(ep or src_ok or dst_ok or UPF::openpa_kick)
    for (int i = 0; i < L; i++) cv[i*64 +: 64] = UPF::openpa_mix(ID + 32'h8000_0000, (src_ok && dst_ok) ? ep + 1 : ep, i);
  assign q = (src_ok && dst_ok) ? d : (UPF::openpa_xmode ? {W{1'bx}} : cv[W-1:0]);
endmodule

`line 1 "pmu_soc.sv" 0
// pmu_soc: two power domains. The top and the controller are always on; u_core can be switched off.
// The RTL is power-unaware: no isolation cell, no supply, no retention register is written here.
module pmu_soc (
  input  logic       clk,
  input  logic       rst_n,
  input  logic       sleep_req,
  input  logic       wake_req,
  input  logic       en,
  input  logic [7:0] d,
  input  logic [1:0] rf_addr,
  input  logic       rf_we,
  output logic [7:0] total,
  output logic       led,
  output logic [7:0] rd,
  output logic [3:0] beats,
  output logic [7:0] status,
  output logic [2:0] pmu_state
);
  logic iso_en, save, restore, pwr_en, core_rst_n;
  logic [7:0] acc, rf_rd;
  logic busy;
  logic [3:0] core_beats;

  pmu u_pmu (
    .clk        (clk),
    .rst_n      (rst_n),
    .sleep_req  (sleep_req),
    .wake_req   (wake_req),
    .iso_en     (iso_en),
    .save       (save),
    .restore    (restore),
    .pwr_en     (pwr_en),
    .core_rst_n (core_rst_n),
    .state_o    (pmu_state)
  );

  core u_core (
    .clk     (clk),
    .rst_n   (core_rst_n),
    .en      (en),
    .d       (d),
    .rf_addr (rf_addr),
    .rf_we   (rf_we),
    .acc     (acc),
    .rf_rd   (rf_rd),
    .busy    (busy),
    .beats   (core_beats)
  );

  // Always-on consumers of the core's outputs.
  assign total = acc;
  assign led   = busy;
  assign rd    = rf_rd;
  assign beats = core_beats;
  // A status register: keeps the last accumulator value seen while the core was busy.
  always_ff @(posedge clk or negedge rst_n)
    if (!rst_n) status <= '0;
    else if (busy) status <= acc;

`line 1 "openpa_overlay.sv" 0
  // ===================================================================================
  // OpenPA overlay for pmu_soc: generated from board.upf. Do not edit.
  // ===================================================================================
  // verilator lint_off MULTIDRIVEN
  // verilator lint_off ENUMVALUE
  // verilator lint_off WIDTHTRUNC
  // verilator lint_off WIDTHEXPAND
  // verilator lint_off BLKSEQ
  // verilator lint_off IGNOREDRETURN
  import UPF::openpa_cmode;
  import UPF::openpa_dom_SYSTEM_ep;
  import UPF::openpa_dom_SYSTEM_ok;
  import UPF::openpa_dom_SYSTEM_sim;
  import UPF::openpa_ds_SYSTEM_a;
  import UPF::openpa_ds_SYSTEM_multi;
  import UPF::openpa_ds_SYSTEM_st;
  import UPF::openpa_kick;
  import UPF::openpa_net_CPU_N;
  import UPF::openpa_net_GND_N;
  import UPF::openpa_net_MEM_N;
  import UPF::openpa_net_VIN_N;
  import UPF::openpa_seed;
  import UPF::openpa_ss_BOARD_ep;
  import UPF::openpa_ss_BOARD_multi;
  import UPF::openpa_ss_BOARD_ok;
  import UPF::openpa_ss_BOARD_sim;
  import UPF::openpa_ss_BOARD_st;
  import UPF::openpa_ss_openpa_BOARD_MODES_CPU_a;
  import UPF::openpa_ss_openpa_BOARD_MODES_CPU_ep;
  import UPF::openpa_ss_openpa_BOARD_MODES_CPU_multi;
  import UPF::openpa_ss_openpa_BOARD_MODES_CPU_ok;
  import UPF::openpa_ss_openpa_BOARD_MODES_CPU_sim;
  import UPF::openpa_ss_openpa_BOARD_MODES_CPU_st;
  import UPF::openpa_ss_openpa_BOARD_MODES_GND_a;
  import UPF::openpa_ss_openpa_BOARD_MODES_GND_ep;
  import UPF::openpa_ss_openpa_BOARD_MODES_GND_multi;
  import UPF::openpa_ss_openpa_BOARD_MODES_GND_ok;
  import UPF::openpa_ss_openpa_BOARD_MODES_GND_sim;
  import UPF::openpa_ss_openpa_BOARD_MODES_GND_st;
  import UPF::openpa_ss_openpa_BOARD_MODES_MEM_a;
  import UPF::openpa_ss_openpa_BOARD_MODES_MEM_ep;
  import UPF::openpa_ss_openpa_BOARD_MODES_MEM_multi;
  import UPF::openpa_ss_openpa_BOARD_MODES_MEM_ok;
  import UPF::openpa_ss_openpa_BOARD_MODES_MEM_sim;
  import UPF::openpa_ss_openpa_BOARD_MODES_MEM_st;
  import UPF::openpa_ss_openpa_BOARD_MODES_VIN_a;
  import UPF::openpa_ss_openpa_BOARD_MODES_VIN_ep;
  import UPF::openpa_ss_openpa_BOARD_MODES_VIN_multi;
  import UPF::openpa_ss_openpa_BOARD_MODES_VIN_ok;
  import UPF::openpa_ss_openpa_BOARD_MODES_VIN_sim;
  import UPF::openpa_ss_openpa_BOARD_MODES_VIN_st;
  import UPF::openpa_xmode;
  // ---- mode, seed, trace
  bit openpa_tr, openpa_obs;
  int openpa_n [1:14];
  int openpa_seq [1:1];   // good-form sequence bins (coverage)
  bit openpa_sreq; bit openpa_sp [1:11];   // deferred checks: request and pending flags
  string openpa_mode_arg;
  initial begin
  `ifdef VERILATOR
    openpa_xmode = 1'b0;
  `else
    openpa_xmode = 1'b1;
  `endif
    openpa_cmode = 0;
    if ($value$plusargs("openpa_corrupt=%s", openpa_mode_arg)) begin
      if (openpa_mode_arg == "x") openpa_xmode = 1'b1;
      else if (openpa_mode_arg == "random") openpa_xmode = 1'b0;
      else if (openpa_mode_arg == "zero") begin openpa_xmode = 1'b0; openpa_cmode = 1; end
      else if (openpa_mode_arg == "one") begin openpa_xmode = 1'b0; openpa_cmode = 2; end
      else $display("OPENPA-ERROR +openpa_corrupt=%s: use x, random, zero or one", openpa_mode_arg);
    end
    if (!$value$plusargs("openpa_seed=%d", openpa_seed)) openpa_seed = 1;
    openpa_tr = $test$plusargs("openpa_trace");
    openpa_obs = $test$plusargs("openpa_obs");
    $display("OPENPA-INFO corruption=%0s seed=%0d", openpa_xmode ? "x" : (openpa_cmode == 1 ? "zero" : openpa_cmode == 2 ? "one" : "random"), openpa_seed);
    #0 openpa_kick = 1'b1;
  end
  task automatic openpa_check(input int id, input string msg);
    openpa_n[id] = openpa_n[id] + 1;
    $display("OPENPA-CHECK D%0d @ %0t: %s", id, $time, msg);
  endtask
  task automatic openpa_t(input string msg);
    if (openpa_tr) $display("OPENPA-TRACE @ %0t: %s", $time, msg);
  endtask

  // ---- copies of the design signals the UPF names (4-state, so X is visible)

  // ---- supply network, switches, supply sets, simstates, power states (one block, evaluated in order)
  bit openpa_tg_ss_openpa_BOARD_MODES_VIN_st; int openpa_pv_ss_openpa_BOARD_MODES_VIN_st = -2;
  bit openpa_tg_ss_openpa_BOARD_MODES_VIN_multi; int openpa_pv_ss_openpa_BOARD_MODES_VIN_multi = -2;
  bit openpa_tg_ss_openpa_BOARD_MODES_CPU_st; int openpa_pv_ss_openpa_BOARD_MODES_CPU_st = -2;
  bit openpa_tg_ss_openpa_BOARD_MODES_CPU_multi; int openpa_pv_ss_openpa_BOARD_MODES_CPU_multi = -2;
  bit openpa_tg_ss_openpa_BOARD_MODES_MEM_st; int openpa_pv_ss_openpa_BOARD_MODES_MEM_st = -2;
  bit openpa_tg_ss_openpa_BOARD_MODES_MEM_multi; int openpa_pv_ss_openpa_BOARD_MODES_MEM_multi = -2;
  bit openpa_tg_ss_openpa_BOARD_MODES_GND_st; int openpa_pv_ss_openpa_BOARD_MODES_GND_st = -2;
  bit openpa_tg_ss_openpa_BOARD_MODES_GND_multi; int openpa_pv_ss_openpa_BOARD_MODES_GND_multi = -2;
  bit openpa_tg_ds_SYSTEM_st; int openpa_pv_ds_SYSTEM_st = -2;
  bit openpa_tg_ds_SYSTEM_multi; int openpa_pv_ds_SYSTEM_multi = -2;
  always @(openpa_kick or UPF::openpa_port_VIN or UPF::openpa_port_CPU or UPF::openpa_port_MEM or UPF::openpa_port_GND) begin : openpa_network
    openpa_net_VIN_N = UPF::openpa_port_VIN;   // VIN_N <- port VIN
    openpa_net_CPU_N = UPF::openpa_port_CPU;   // CPU_N <- port CPU
    openpa_net_MEM_N = UPF::openpa_port_MEM;   // MEM_N <- port MEM
    openpa_net_GND_N = UPF::openpa_port_GND;   // GND_N <- port GND
    // supply set BOARD (also SYSTEM.primary): IEEE 1801-2024 4.7.3, 4.7.4, 6.5.6, 9.3.2, 5.7.8
    begin : openpa_ss_BOARD
      bit nx; int sm;
      sm = (UPF::openpa_net_VIN_N.state == UPF::FULL_ON && UPF::openpa_net_GND_N.state == UPF::FULL_ON) ? 0 : 5;   // predefined ON (NORMAL) or OFF (CORRUPT), IEEE 1801-2024 4.7.4
      openpa_ss_BOARD_sim = sm;
      nx = sm < 5;
      if (openpa_ss_BOARD_ok && !nx) openpa_ss_BOARD_ep = openpa_ss_BOARD_ep + 1;
      openpa_ss_BOARD_ok = nx;
    end
    // supply set openpa_BOARD_MODES_VIN: IEEE 1801-2024 4.7.3, 4.7.4, 6.5.6, 9.3.2, 5.7.8
    begin : openpa_ss_openpa_BOARD_MODES_VIN
      bit nx; int sm;
      openpa_ss_openpa_BOARD_MODES_VIN_a = '0; openpa_ss_openpa_BOARD_MODES_VIN_st = -1;
      begin int dm; dm = -1;
        openpa_ss_openpa_BOARD_MODES_VIN_a[0] = ((UPF::openpa_net_VIN_N.state == UPF::FULL_ON && UPF::openpa_net_VIN_N.voltage == 1000000));   // NOM
        if (openpa_ss_openpa_BOARD_MODES_VIN_a[0] && 0 > dm) begin dm = 0; openpa_ss_openpa_BOARD_MODES_VIN_st = 0; end
      end
      openpa_ss_openpa_BOARD_MODES_VIN_multi = 1'b0;
      sm = (UPF::openpa_net_VIN_N.state == UPF::FULL_ON) ? 0 : -1;
      if (sm < 0) sm = 5;
      openpa_ss_openpa_BOARD_MODES_VIN_sim = sm;
      nx = sm < 5;
      if (openpa_ss_openpa_BOARD_MODES_VIN_ok && !nx) openpa_ss_openpa_BOARD_MODES_VIN_ep = openpa_ss_openpa_BOARD_MODES_VIN_ep + 1;
      openpa_ss_openpa_BOARD_MODES_VIN_ok = nx;
    end
    // supply set openpa_BOARD_MODES_CPU: IEEE 1801-2024 4.7.3, 4.7.4, 6.5.6, 9.3.2, 5.7.8
    begin : openpa_ss_openpa_BOARD_MODES_CPU
      bit nx; int sm;
      openpa_ss_openpa_BOARD_MODES_CPU_a = '0; openpa_ss_openpa_BOARD_MODES_CPU_st = -1;
      begin int dm; dm = -1;
        openpa_ss_openpa_BOARD_MODES_CPU_a[0] = ((UPF::openpa_net_CPU_N.state == UPF::FULL_ON && UPF::openpa_net_CPU_N.voltage == 1000000));   // HIGH
        if (openpa_ss_openpa_BOARD_MODES_CPU_a[0] && 0 > dm) begin dm = 0; openpa_ss_openpa_BOARD_MODES_CPU_st = 0; end
        openpa_ss_openpa_BOARD_MODES_CPU_a[1] = ((UPF::openpa_net_CPU_N.state == UPF::OFF));   // CUT
        if (openpa_ss_openpa_BOARD_MODES_CPU_a[1] && 0 > dm) begin dm = 0; openpa_ss_openpa_BOARD_MODES_CPU_st = 1; end
      end
      openpa_ss_openpa_BOARD_MODES_CPU_multi = (openpa_ss_openpa_BOARD_MODES_CPU_a[0] + openpa_ss_openpa_BOARD_MODES_CPU_a[1]) > 1;
      sm = (UPF::openpa_net_CPU_N.state == UPF::FULL_ON) ? 0 : -1;
      if (sm < 0) sm = 5;
      openpa_ss_openpa_BOARD_MODES_CPU_sim = sm;
      nx = sm < 5;
      if (openpa_ss_openpa_BOARD_MODES_CPU_ok && !nx) openpa_ss_openpa_BOARD_MODES_CPU_ep = openpa_ss_openpa_BOARD_MODES_CPU_ep + 1;
      openpa_ss_openpa_BOARD_MODES_CPU_ok = nx;
    end
    // supply set openpa_BOARD_MODES_MEM: IEEE 1801-2024 4.7.3, 4.7.4, 6.5.6, 9.3.2, 5.7.8
    begin : openpa_ss_openpa_BOARD_MODES_MEM
      bit nx; int sm;
      openpa_ss_openpa_BOARD_MODES_MEM_a = '0; openpa_ss_openpa_BOARD_MODES_MEM_st = -1;
      begin int dm; dm = -1;
        openpa_ss_openpa_BOARD_MODES_MEM_a[0] = ((UPF::openpa_net_MEM_N.state == UPF::FULL_ON && UPF::openpa_net_MEM_N.voltage == 800000));   // KEEP
        if (openpa_ss_openpa_BOARD_MODES_MEM_a[0] && 0 > dm) begin dm = 0; openpa_ss_openpa_BOARD_MODES_MEM_st = 0; end
        openpa_ss_openpa_BOARD_MODES_MEM_a[1] = ((UPF::openpa_net_MEM_N.state == UPF::OFF));   // CUT
        if (openpa_ss_openpa_BOARD_MODES_MEM_a[1] && 0 > dm) begin dm = 0; openpa_ss_openpa_BOARD_MODES_MEM_st = 1; end
      end
      openpa_ss_openpa_BOARD_MODES_MEM_multi = (openpa_ss_openpa_BOARD_MODES_MEM_a[0] + openpa_ss_openpa_BOARD_MODES_MEM_a[1]) > 1;
      sm = (UPF::openpa_net_MEM_N.state == UPF::FULL_ON) ? 0 : -1;
      if (sm < 0) sm = 5;
      openpa_ss_openpa_BOARD_MODES_MEM_sim = sm;
      nx = sm < 5;
      if (openpa_ss_openpa_BOARD_MODES_MEM_ok && !nx) openpa_ss_openpa_BOARD_MODES_MEM_ep = openpa_ss_openpa_BOARD_MODES_MEM_ep + 1;
      openpa_ss_openpa_BOARD_MODES_MEM_ok = nx;
    end
    // supply set openpa_BOARD_MODES_GND: IEEE 1801-2024 4.7.3, 4.7.4, 6.5.6, 9.3.2, 5.7.8
    begin : openpa_ss_openpa_BOARD_MODES_GND
      bit nx; int sm;
      openpa_ss_openpa_BOARD_MODES_GND_a = '0; openpa_ss_openpa_BOARD_MODES_GND_st = -1;
      begin int dm; dm = -1;
        openpa_ss_openpa_BOARD_MODES_GND_a[0] = ((UPF::openpa_net_GND_N.state == UPF::FULL_ON && UPF::openpa_net_GND_N.voltage == 0));   // REF
        if (openpa_ss_openpa_BOARD_MODES_GND_a[0] && 0 > dm) begin dm = 0; openpa_ss_openpa_BOARD_MODES_GND_st = 0; end
      end
      openpa_ss_openpa_BOARD_MODES_GND_multi = 1'b0;
      sm = (UPF::openpa_net_GND_N.state == UPF::FULL_ON) ? 0 : -1;
      if (sm < 0) sm = 5;
      openpa_ss_openpa_BOARD_MODES_GND_sim = sm;
      nx = sm < 5;
      if (openpa_ss_openpa_BOARD_MODES_GND_ok && !nx) openpa_ss_openpa_BOARD_MODES_GND_ep = openpa_ss_openpa_BOARD_MODES_GND_ep + 1;
      openpa_ss_openpa_BOARD_MODES_GND_ok = nx;
    end
    // domain SYSTEM: simstate of its primary supply set BOARD
    if (openpa_dom_SYSTEM_ok && !UPF::openpa_ss_BOARD_ok) openpa_dom_SYSTEM_ep = openpa_dom_SYSTEM_ep + 1;
    openpa_dom_SYSTEM_ok = UPF::openpa_ss_BOARD_ok;
    openpa_dom_SYSTEM_sim = openpa_ss_BOARD_sim;
    // power states of domain SYSTEM (rule P1)
    begin : openpa_ds_SYSTEM
      openpa_ds_SYSTEM_a = '0; openpa_ds_SYSTEM_st = -1;
      begin int dm; dm = -1;
        openpa_ds_SYSTEM_a[0] = (((((UPF::openpa_ss_openpa_BOARD_MODES_VIN_a[0]) && (UPF::openpa_ss_openpa_BOARD_MODES_CPU_a[0])) && (UPF::openpa_ss_openpa_BOARD_MODES_MEM_a[0])) && (UPF::openpa_ss_openpa_BOARD_MODES_GND_a[0])));   // Work
        if (openpa_ds_SYSTEM_a[0] && 0 > dm) begin dm = 0; openpa_ds_SYSTEM_st = 0; end
        openpa_ds_SYSTEM_a[1] = (((((UPF::openpa_ss_openpa_BOARD_MODES_VIN_a[0]) && (UPF::openpa_ss_openpa_BOARD_MODES_CPU_a[1])) && (UPF::openpa_ss_openpa_BOARD_MODES_MEM_a[0])) && (UPF::openpa_ss_openpa_BOARD_MODES_GND_a[0])));   // Nap
        if (openpa_ds_SYSTEM_a[1] && 0 > dm) begin dm = 0; openpa_ds_SYSTEM_st = 1; end
        openpa_ds_SYSTEM_a[2] = (((((UPF::openpa_ss_openpa_BOARD_MODES_VIN_a[0]) && (UPF::openpa_ss_openpa_BOARD_MODES_CPU_a[1])) && (UPF::openpa_ss_openpa_BOARD_MODES_MEM_a[1])) && (UPF::openpa_ss_openpa_BOARD_MODES_GND_a[0])));   // Cold
        if (openpa_ds_SYSTEM_a[2] && 0 > dm) begin dm = 0; openpa_ds_SYSTEM_st = 2; end
      end
      openpa_ds_SYSTEM_multi = (openpa_ds_SYSTEM_a[0] + openpa_ds_SYSTEM_a[1] + openpa_ds_SYSTEM_a[2]) > 1;
    end
    if (openpa_ss_openpa_BOARD_MODES_VIN_st != openpa_pv_ss_openpa_BOARD_MODES_VIN_st) begin openpa_tg_ss_openpa_BOARD_MODES_VIN_st = ~openpa_tg_ss_openpa_BOARD_MODES_VIN_st; openpa_pv_ss_openpa_BOARD_MODES_VIN_st = openpa_ss_openpa_BOARD_MODES_VIN_st; end
    if (openpa_ss_openpa_BOARD_MODES_VIN_multi != openpa_pv_ss_openpa_BOARD_MODES_VIN_multi) begin openpa_tg_ss_openpa_BOARD_MODES_VIN_multi = ~openpa_tg_ss_openpa_BOARD_MODES_VIN_multi; openpa_pv_ss_openpa_BOARD_MODES_VIN_multi = openpa_ss_openpa_BOARD_MODES_VIN_multi; end
    if (openpa_ss_openpa_BOARD_MODES_CPU_st != openpa_pv_ss_openpa_BOARD_MODES_CPU_st) begin openpa_tg_ss_openpa_BOARD_MODES_CPU_st = ~openpa_tg_ss_openpa_BOARD_MODES_CPU_st; openpa_pv_ss_openpa_BOARD_MODES_CPU_st = openpa_ss_openpa_BOARD_MODES_CPU_st; end
    if (openpa_ss_openpa_BOARD_MODES_CPU_multi != openpa_pv_ss_openpa_BOARD_MODES_CPU_multi) begin openpa_tg_ss_openpa_BOARD_MODES_CPU_multi = ~openpa_tg_ss_openpa_BOARD_MODES_CPU_multi; openpa_pv_ss_openpa_BOARD_MODES_CPU_multi = openpa_ss_openpa_BOARD_MODES_CPU_multi; end
    if (openpa_ss_openpa_BOARD_MODES_MEM_st != openpa_pv_ss_openpa_BOARD_MODES_MEM_st) begin openpa_tg_ss_openpa_BOARD_MODES_MEM_st = ~openpa_tg_ss_openpa_BOARD_MODES_MEM_st; openpa_pv_ss_openpa_BOARD_MODES_MEM_st = openpa_ss_openpa_BOARD_MODES_MEM_st; end
    if (openpa_ss_openpa_BOARD_MODES_MEM_multi != openpa_pv_ss_openpa_BOARD_MODES_MEM_multi) begin openpa_tg_ss_openpa_BOARD_MODES_MEM_multi = ~openpa_tg_ss_openpa_BOARD_MODES_MEM_multi; openpa_pv_ss_openpa_BOARD_MODES_MEM_multi = openpa_ss_openpa_BOARD_MODES_MEM_multi; end
    if (openpa_ss_openpa_BOARD_MODES_GND_st != openpa_pv_ss_openpa_BOARD_MODES_GND_st) begin openpa_tg_ss_openpa_BOARD_MODES_GND_st = ~openpa_tg_ss_openpa_BOARD_MODES_GND_st; openpa_pv_ss_openpa_BOARD_MODES_GND_st = openpa_ss_openpa_BOARD_MODES_GND_st; end
    if (openpa_ss_openpa_BOARD_MODES_GND_multi != openpa_pv_ss_openpa_BOARD_MODES_GND_multi) begin openpa_tg_ss_openpa_BOARD_MODES_GND_multi = ~openpa_tg_ss_openpa_BOARD_MODES_GND_multi; openpa_pv_ss_openpa_BOARD_MODES_GND_multi = openpa_ss_openpa_BOARD_MODES_GND_multi; end
    if (openpa_ds_SYSTEM_st != openpa_pv_ds_SYSTEM_st) begin openpa_tg_ds_SYSTEM_st = ~openpa_tg_ds_SYSTEM_st; openpa_pv_ds_SYSTEM_st = openpa_ds_SYSTEM_st; end
    if (openpa_ds_SYSTEM_multi != openpa_pv_ds_SYSTEM_multi) begin openpa_tg_ds_SYSTEM_multi = ~openpa_tg_ds_SYSTEM_multi; openpa_pv_ds_SYSTEM_multi = openpa_ds_SYSTEM_multi; end
  end

  // ---- corruption: registers forced, memories overwritten (rules C1, C3)
  // domain SYSTEM (board.upf:3): 4 register(s), 1 memory(ies)
  bit openpa_SYSTEM_applied, openpa_SYSTEM_valid;
  logic [7:0] openpa_cv1;   // corruption value for status
  logic [7:0] openpa_cv2;   // corruption value for u_core.acc
  logic [3:0] openpa_cv3;   // corruption value for u_core.beats
  logic [2:0] openpa_cv4;   // corruption value for u_pmu.st
  // The first evaluation counts as a power-up from OFF: registers take the corruption value even when the
  // supplies are already on at time 0 (rule C3), so 4-state and 2-state runs start alike.
  always @(UPF::openpa_dom_SYSTEM_ok or openpa_kick) if (!openpa_SYSTEM_valid || openpa_SYSTEM_applied != UPF::openpa_dom_SYSTEM_ok) begin
    openpa_t({"SYSTEM ", UPF::openpa_dom_SYSTEM_ok ? "NORMAL" : "CORRUPT"});
    if (!UPF::openpa_dom_SYSTEM_ok || !openpa_SYSTEM_valid) begin
      if (openpa_xmode) openpa_cv1 = 'x; else openpa_cv1 = UPF::openpa_mix(1, UPF::openpa_dom_SYSTEM_ep, 0);
      force status = openpa_cv1;
      if (openpa_xmode) openpa_cv2 = 'x; else openpa_cv2 = UPF::openpa_mix(2, UPF::openpa_dom_SYSTEM_ep, 0);
      force u_core.acc = openpa_cv2;
      if (openpa_xmode) openpa_cv3 = 'x; else openpa_cv3 = UPF::openpa_mix(3, UPF::openpa_dom_SYSTEM_ep, 0);
      force u_core.beats = openpa_cv3;
      if (openpa_xmode) openpa_cv4 = 'x; else openpa_cv4 = UPF::openpa_mix(4, UPF::openpa_dom_SYSTEM_ep, 0);
      force u_pmu.st = openpa_cv4;
      for (int i = 0; i < 4; i++) u_core.rf[0 + i] = openpa_xmode ? 8'bx : UPF::openpa_mix(100000, UPF::openpa_dom_SYSTEM_ep, (i) * 1 + 0);
    end
    if (UPF::openpa_dom_SYSTEM_ok) begin
      for (int i = 0; i < 4; i++) u_core.rf[0 + i] = openpa_xmode ? 8'bx : UPF::openpa_mix(100000, UPF::openpa_dom_SYSTEM_ep, (i) * 1 + 0);
      release status;
      release u_core.acc;
      release u_core.beats;
      release u_pmu.st;
    end
    openpa_SYSTEM_valid = 1'b1; openpa_SYSTEM_applied = UPF::openpa_dom_SYSTEM_ok;
  end

  // ---- power states (D8): checked once the bench has driven a supply, after the time step settles
  always @(posedge openpa_tg_ss_openpa_BOARD_MODES_VIN_st or negedge openpa_tg_ss_openpa_BOARD_MODES_VIN_st or posedge openpa_tg_ss_openpa_BOARD_MODES_VIN_multi or negedge openpa_tg_ss_openpa_BOARD_MODES_VIN_multi or posedge UPF::openpa_armed) if (UPF::openpa_armed)
    begin openpa_sp[1] = 1'b1; openpa_sreq = 1'b1; end
  always @(posedge openpa_tg_ss_openpa_BOARD_MODES_CPU_st or negedge openpa_tg_ss_openpa_BOARD_MODES_CPU_st or posedge openpa_tg_ss_openpa_BOARD_MODES_CPU_multi or negedge openpa_tg_ss_openpa_BOARD_MODES_CPU_multi or posedge UPF::openpa_armed) if (UPF::openpa_armed)
    begin openpa_sp[2] = 1'b1; openpa_sreq = 1'b1; end
  always @(posedge openpa_tg_ss_openpa_BOARD_MODES_MEM_st or negedge openpa_tg_ss_openpa_BOARD_MODES_MEM_st or posedge openpa_tg_ss_openpa_BOARD_MODES_MEM_multi or negedge openpa_tg_ss_openpa_BOARD_MODES_MEM_multi or posedge UPF::openpa_armed) if (UPF::openpa_armed)
    begin openpa_sp[3] = 1'b1; openpa_sreq = 1'b1; end
  always @(posedge openpa_tg_ss_openpa_BOARD_MODES_GND_st or negedge openpa_tg_ss_openpa_BOARD_MODES_GND_st or posedge openpa_tg_ss_openpa_BOARD_MODES_GND_multi or negedge openpa_tg_ss_openpa_BOARD_MODES_GND_multi or posedge UPF::openpa_armed) if (UPF::openpa_armed)
    begin openpa_sp[4] = 1'b1; openpa_sreq = 1'b1; end
  always @(posedge openpa_tg_ds_SYSTEM_st or negedge openpa_tg_ds_SYSTEM_st or posedge openpa_tg_ds_SYSTEM_multi or negedge openpa_tg_ds_SYSTEM_multi or posedge UPF::openpa_armed) if (UPF::openpa_armed)
    begin openpa_sp[5] = 1'b1; openpa_sreq = 1'b1; end
  int openpa_tr1_prev = -1;
  always @(posedge openpa_tg_ds_SYSTEM_st or negedge openpa_tg_ds_SYSTEM_st or posedge UPF::openpa_armed) if (UPF::openpa_armed)
    begin openpa_sp[6] = 1'b1; openpa_sreq = 1'b1; end
  always @(posedge openpa_tg_ds_SYSTEM_st or negedge openpa_tg_ds_SYSTEM_st) if (openpa_tr) openpa_t($sformatf("SYSTEM state %0s", (UPF::openpa_ds_SYSTEM_st == 0) ? "Work" : (UPF::openpa_ds_SYSTEM_st == 1) ? "Nap" : (UPF::openpa_ds_SYSTEM_st == 2) ? "Cold" : "<none>"));
  always @(posedge openpa_tg_ss_openpa_BOARD_MODES_VIN_st or negedge openpa_tg_ss_openpa_BOARD_MODES_VIN_st) if (openpa_tr) openpa_t($sformatf("openpa_BOARD_MODES_VIN state %0s", (UPF::openpa_ss_openpa_BOARD_MODES_VIN_st == 0) ? "NOM" : "<none>"));
  always @(posedge openpa_tg_ss_openpa_BOARD_MODES_CPU_st or negedge openpa_tg_ss_openpa_BOARD_MODES_CPU_st) if (openpa_tr) openpa_t($sformatf("openpa_BOARD_MODES_CPU state %0s", (UPF::openpa_ss_openpa_BOARD_MODES_CPU_st == 0) ? "HIGH" : (UPF::openpa_ss_openpa_BOARD_MODES_CPU_st == 1) ? "CUT" : "<none>"));
  always @(posedge openpa_tg_ss_openpa_BOARD_MODES_MEM_st or negedge openpa_tg_ss_openpa_BOARD_MODES_MEM_st) if (openpa_tr) openpa_t($sformatf("openpa_BOARD_MODES_MEM state %0s", (UPF::openpa_ss_openpa_BOARD_MODES_MEM_st == 0) ? "KEEP" : (UPF::openpa_ss_openpa_BOARD_MODES_MEM_st == 1) ? "CUT" : "<none>"));
  always @(posedge openpa_tg_ss_openpa_BOARD_MODES_GND_st or negedge openpa_tg_ss_openpa_BOARD_MODES_GND_st) if (openpa_tr) openpa_t($sformatf("openpa_BOARD_MODES_GND state %0s", (UPF::openpa_ss_openpa_BOARD_MODES_GND_st == 0) ? "REF" : "<none>"));
  int openpa_cs1 [0:1]; int openpa_ct1 [0:1][0:1]; int openpa_cp1 = -1, openpa_cc1;   // coverage of supply set openpa_BOARD_MODES_VIN
  function automatic string openpa_cn1(int i); case (i) 0: return "NOM"; default: return "<none>"; endcase endfunction
  always @(posedge openpa_tg_ss_openpa_BOARD_MODES_VIN_st or negedge openpa_tg_ss_openpa_BOARD_MODES_VIN_st or posedge UPF::openpa_armed) if (UPF::openpa_armed)
    begin openpa_sp[7] = 1'b1; openpa_sreq = 1'b1; end
  int openpa_cs2 [0:2]; int openpa_ct2 [0:2][0:2]; int openpa_cp2 = -1, openpa_cc2;   // coverage of supply set openpa_BOARD_MODES_CPU
  function automatic string openpa_cn2(int i); case (i) 0: return "HIGH"; 1: return "CUT"; default: return "<none>"; endcase endfunction
  always @(posedge openpa_tg_ss_openpa_BOARD_MODES_CPU_st or negedge openpa_tg_ss_openpa_BOARD_MODES_CPU_st or posedge UPF::openpa_armed) if (UPF::openpa_armed)
    begin openpa_sp[8] = 1'b1; openpa_sreq = 1'b1; end
  int openpa_cs3 [0:2]; int openpa_ct3 [0:2][0:2]; int openpa_cp3 = -1, openpa_cc3;   // coverage of supply set openpa_BOARD_MODES_MEM
  function automatic string openpa_cn3(int i); case (i) 0: return "KEEP"; 1: return "CUT"; default: return "<none>"; endcase endfunction
  always @(posedge openpa_tg_ss_openpa_BOARD_MODES_MEM_st or negedge openpa_tg_ss_openpa_BOARD_MODES_MEM_st or posedge UPF::openpa_armed) if (UPF::openpa_armed)
    begin openpa_sp[9] = 1'b1; openpa_sreq = 1'b1; end
  int openpa_cs4 [0:1]; int openpa_ct4 [0:1][0:1]; int openpa_cp4 = -1, openpa_cc4;   // coverage of supply set openpa_BOARD_MODES_GND
  function automatic string openpa_cn4(int i); case (i) 0: return "REF"; default: return "<none>"; endcase endfunction
  always @(posedge openpa_tg_ss_openpa_BOARD_MODES_GND_st or negedge openpa_tg_ss_openpa_BOARD_MODES_GND_st or posedge UPF::openpa_armed) if (UPF::openpa_armed)
    begin openpa_sp[10] = 1'b1; openpa_sreq = 1'b1; end
  int openpa_cs5 [0:3]; int openpa_ct5 [0:3][0:3]; int openpa_cp5 = -1, openpa_cc5;   // coverage of domain SYSTEM
  function automatic string openpa_cn5(int i); case (i) 0: return "Work"; 1: return "Nap"; 2: return "Cold"; default: return "<none>"; endcase endfunction
  always @(posedge openpa_tg_ds_SYSTEM_st or negedge openpa_tg_ds_SYSTEM_st or posedge UPF::openpa_armed) if (UPF::openpa_armed)
    begin openpa_sp[11] = 1'b1; openpa_sreq = 1'b1; end

  // ---- observation for differential corruption (+openpa_obs): design-top outputs while the top domain is on
  `ifdef OPENPA_OBS
  longint openpa_obs_after;
  initial if (!$value$plusargs("openpa_obs_after=%d", openpa_obs_after)) openpa_obs_after = 0;
  always @(total) if (openpa_obs && UPF::openpa_dom_SYSTEM_ok && $time >= openpa_obs_after) $display("OPENPA-OBS @ %0t: total=%h", $time, total);
  always @(led) if (openpa_obs && UPF::openpa_dom_SYSTEM_ok && $time >= openpa_obs_after) $display("OPENPA-OBS @ %0t: led=%h", $time, led);
  always @(rd) if (openpa_obs && UPF::openpa_dom_SYSTEM_ok && $time >= openpa_obs_after) $display("OPENPA-OBS @ %0t: rd=%h", $time, rd);
  always @(beats) if (openpa_obs && UPF::openpa_dom_SYSTEM_ok && $time >= openpa_obs_after) $display("OPENPA-OBS @ %0t: beats=%h", $time, beats);
  always @(status) if (openpa_obs && UPF::openpa_dom_SYSTEM_ok && $time >= openpa_obs_after) $display("OPENPA-OBS @ %0t: status=%h", $time, status);
  always @(pmu_state) if (openpa_obs && UPF::openpa_dom_SYSTEM_ok && $time >= openpa_obs_after) $display("OPENPA-OBS @ %0t: pmu_state=%h", $time, pmu_state);
  `else
  initial if ($test$plusargs("openpa_obs")) $display("OPENPA-ERROR +openpa_obs needs the copy compiled with OPENPA_OBS defined (-DOPENPA_OBS or +define+OPENPA_OBS)");
  `endif

  // Icarus 12 runs no named block inside a final block, so the report is a function.
  function automatic void openpa_cover_report();
      int hs, ht, hq;
      hs = 0; ht = 0; hq = 0;
      $display("OPENPA-COVER state supply_set openpa_BOARD_MODES_VIN NOM %0d", openpa_cs1[0]);
      if (openpa_cs1[1]) $display("OPENPA-COVER state supply_set openpa_BOARD_MODES_VIN <none> %0d", openpa_cs1[1]);
      for (int i = 0; i <= 1; i++) for (int j = 0; j <= 1; j++) if (openpa_ct1[i][j]) $display("OPENPA-COVER transition supply_set openpa_BOARD_MODES_VIN %0s -> %0s %0d", openpa_cn1(i), openpa_cn1(j), openpa_ct1[i][j]);
      $display("OPENPA-COVER state supply_set openpa_BOARD_MODES_CPU HIGH %0d", openpa_cs2[0]);
      $display("OPENPA-COVER state supply_set openpa_BOARD_MODES_CPU CUT %0d", openpa_cs2[1]);
      if (openpa_cs2[2]) $display("OPENPA-COVER state supply_set openpa_BOARD_MODES_CPU <none> %0d", openpa_cs2[2]);
      for (int i = 0; i <= 2; i++) for (int j = 0; j <= 2; j++) if (openpa_ct2[i][j]) $display("OPENPA-COVER transition supply_set openpa_BOARD_MODES_CPU %0s -> %0s %0d", openpa_cn2(i), openpa_cn2(j), openpa_ct2[i][j]);
      $display("OPENPA-COVER state supply_set openpa_BOARD_MODES_MEM KEEP %0d", openpa_cs3[0]);
      $display("OPENPA-COVER state supply_set openpa_BOARD_MODES_MEM CUT %0d", openpa_cs3[1]);
      if (openpa_cs3[2]) $display("OPENPA-COVER state supply_set openpa_BOARD_MODES_MEM <none> %0d", openpa_cs3[2]);
      for (int i = 0; i <= 2; i++) for (int j = 0; j <= 2; j++) if (openpa_ct3[i][j]) $display("OPENPA-COVER transition supply_set openpa_BOARD_MODES_MEM %0s -> %0s %0d", openpa_cn3(i), openpa_cn3(j), openpa_ct3[i][j]);
      $display("OPENPA-COVER state supply_set openpa_BOARD_MODES_GND REF %0d", openpa_cs4[0]);
      if (openpa_cs4[1]) $display("OPENPA-COVER state supply_set openpa_BOARD_MODES_GND <none> %0d", openpa_cs4[1]);
      for (int i = 0; i <= 1; i++) for (int j = 0; j <= 1; j++) if (openpa_ct4[i][j]) $display("OPENPA-COVER transition supply_set openpa_BOARD_MODES_GND %0s -> %0s %0d", openpa_cn4(i), openpa_cn4(j), openpa_ct4[i][j]);
      $display("OPENPA-COVER state domain SYSTEM Work %0d", openpa_cs5[0]);
      $display("OPENPA-COVER state domain SYSTEM Nap %0d", openpa_cs5[1]);
      $display("OPENPA-COVER state domain SYSTEM Cold %0d", openpa_cs5[2]);
      if (openpa_cs5[3]) $display("OPENPA-COVER state domain SYSTEM <none> %0d", openpa_cs5[3]);
      for (int i = 0; i <= 3; i++) for (int j = 0; j <= 3; j++) if (openpa_ct5[i][j]) $display("OPENPA-COVER transition domain SYSTEM %0s -> %0s %0d", openpa_cn5(i), openpa_cn5(j), openpa_ct5[i][j]);
      if (openpa_cs1[0]) hs = hs + 1;
      if (openpa_cs2[0]) hs = hs + 1;
      if (openpa_cs2[1]) hs = hs + 1;
      if (openpa_cs3[0]) hs = hs + 1;
      if (openpa_cs3[1]) hs = hs + 1;
      if (openpa_cs4[0]) hs = hs + 1;
      if (openpa_cs5[0]) hs = hs + 1;
      if (openpa_cs5[1]) hs = hs + 1;
      if (openpa_cs5[2]) hs = hs + 1;
      $display("OPENPA-COVER-SUMMARY states=%0d/9 declared_transitions=%0d/0 sequences=%0d/0", hs, ht, hq);
  endfunction

  // ---- settle process: 11 deferred check(s), run after one #0 in a fixed order
  initial forever begin
    wait (openpa_sreq && openpa_kick);
    #0;
    openpa_sreq = 1'b0;
    if (openpa_sp[1]) begin
      openpa_sp[1] = 1'b0;
        if (!1'b0)   // suspended while a power switch is undetermined (D10 reports that)
        begin
          if (UPF::openpa_ss_openpa_BOARD_MODES_VIN_st == -1) openpa_check(8, "supply set openpa_BOARD_MODES_VIN is in none of its defined power states, which were declared -complete (board.upf:23)");
          if (UPF::openpa_ss_openpa_BOARD_MODES_VIN_multi) openpa_check(8, "supply set openpa_BOARD_MODES_VIN: more than one power state holds (the ERROR state)");
        end
    end
    if (openpa_sp[2]) begin
      openpa_sp[2] = 1'b0;
        if (!1'b0)   // suspended while a power switch is undetermined (D10 reports that)
        begin
          if (UPF::openpa_ss_openpa_BOARD_MODES_CPU_st == -1) openpa_check(8, "supply set openpa_BOARD_MODES_CPU is in none of its defined power states, which were declared -complete (board.upf:28)");
          if (UPF::openpa_ss_openpa_BOARD_MODES_CPU_multi) openpa_check(8, "supply set openpa_BOARD_MODES_CPU: more than one power state holds (the ERROR state)");
        end
    end
    if (openpa_sp[3]) begin
      openpa_sp[3] = 1'b0;
        if (!1'b0)   // suspended while a power switch is undetermined (D10 reports that)
        begin
          if (UPF::openpa_ss_openpa_BOARD_MODES_MEM_st == -1) openpa_check(8, "supply set openpa_BOARD_MODES_MEM is in none of its defined power states, which were declared -complete (board.upf:33)");
          if (UPF::openpa_ss_openpa_BOARD_MODES_MEM_multi) openpa_check(8, "supply set openpa_BOARD_MODES_MEM: more than one power state holds (the ERROR state)");
        end
    end
    if (openpa_sp[4]) begin
      openpa_sp[4] = 1'b0;
        if (!1'b0)   // suspended while a power switch is undetermined (D10 reports that)
        begin
          if (UPF::openpa_ss_openpa_BOARD_MODES_GND_st == -1) openpa_check(8, "supply set openpa_BOARD_MODES_GND is in none of its defined power states, which were declared -complete (board.upf:37)");
          if (UPF::openpa_ss_openpa_BOARD_MODES_GND_multi) openpa_check(8, "supply set openpa_BOARD_MODES_GND: more than one power state holds (the ERROR state)");
        end
    end
    if (openpa_sp[5]) begin
      openpa_sp[5] = 1'b0;
        if (!1'b0)   // suspended while a power switch is undetermined (D10 reports that)
        begin
          if (UPF::openpa_ds_SYSTEM_st == -1) openpa_check(8, "power domain SYSTEM is in none of its defined power states (UNDEFINED), which were declared -complete (board.upf:42)");
          if (UPF::openpa_ds_SYSTEM_multi) openpa_check(8, "power domain SYSTEM: more than one power state holds (the ERROR state)");
        end
    end
    if (openpa_sp[6]) begin
      openpa_sp[6] = 1'b0;
        if (UPF::openpa_ds_SYSTEM_st != openpa_tr1_prev) begin
          if (((openpa_tr1_prev == 2) && (UPF::openpa_ds_SYSTEM_st == 0))) openpa_check(8, "illegal transition rush on SYSTEM: Cold -> Work (board.upf:43)");
          openpa_tr1_prev = UPF::openpa_ds_SYSTEM_st;
        end
    end
    if (openpa_sp[7]) begin
      openpa_sp[7] = 1'b0;
        if (!1'b0) begin
          openpa_cc1 = (UPF::openpa_ss_openpa_BOARD_MODES_VIN_st < 0) ? 1 : UPF::openpa_ss_openpa_BOARD_MODES_VIN_st;
          if (openpa_cc1 != openpa_cp1) begin
            openpa_cs1[openpa_cc1] = openpa_cs1[openpa_cc1] + 1;
            if (openpa_cp1 >= 0) openpa_ct1[openpa_cp1][openpa_cc1] = openpa_ct1[openpa_cp1][openpa_cc1] + 1;
            openpa_cp1 = openpa_cc1;
          end
        end
    end
    if (openpa_sp[8]) begin
      openpa_sp[8] = 1'b0;
        if (!1'b0) begin
          openpa_cc2 = (UPF::openpa_ss_openpa_BOARD_MODES_CPU_st < 0) ? 2 : UPF::openpa_ss_openpa_BOARD_MODES_CPU_st;
          if (openpa_cc2 != openpa_cp2) begin
            openpa_cs2[openpa_cc2] = openpa_cs2[openpa_cc2] + 1;
            if (openpa_cp2 >= 0) openpa_ct2[openpa_cp2][openpa_cc2] = openpa_ct2[openpa_cp2][openpa_cc2] + 1;
            openpa_cp2 = openpa_cc2;
          end
        end
    end
    if (openpa_sp[9]) begin
      openpa_sp[9] = 1'b0;
        if (!1'b0) begin
          openpa_cc3 = (UPF::openpa_ss_openpa_BOARD_MODES_MEM_st < 0) ? 2 : UPF::openpa_ss_openpa_BOARD_MODES_MEM_st;
          if (openpa_cc3 != openpa_cp3) begin
            openpa_cs3[openpa_cc3] = openpa_cs3[openpa_cc3] + 1;
            if (openpa_cp3 >= 0) openpa_ct3[openpa_cp3][openpa_cc3] = openpa_ct3[openpa_cp3][openpa_cc3] + 1;
            openpa_cp3 = openpa_cc3;
          end
        end
    end
    if (openpa_sp[10]) begin
      openpa_sp[10] = 1'b0;
        if (!1'b0) begin
          openpa_cc4 = (UPF::openpa_ss_openpa_BOARD_MODES_GND_st < 0) ? 1 : UPF::openpa_ss_openpa_BOARD_MODES_GND_st;
          if (openpa_cc4 != openpa_cp4) begin
            openpa_cs4[openpa_cc4] = openpa_cs4[openpa_cc4] + 1;
            if (openpa_cp4 >= 0) openpa_ct4[openpa_cp4][openpa_cc4] = openpa_ct4[openpa_cp4][openpa_cc4] + 1;
            openpa_cp4 = openpa_cc4;
          end
        end
    end
    if (openpa_sp[11]) begin
      openpa_sp[11] = 1'b0;
        if (!1'b0) begin
          openpa_cc5 = (UPF::openpa_ds_SYSTEM_st < 0) ? 3 : UPF::openpa_ds_SYSTEM_st;
          if (openpa_cc5 != openpa_cp5) begin
            openpa_cs5[openpa_cc5] = openpa_cs5[openpa_cc5] + 1;
            if (openpa_cp5 >= 0) openpa_ct5[openpa_cp5][openpa_cc5] = openpa_ct5[openpa_cp5][openpa_cc5] + 1;
            openpa_cp5 = openpa_cc5;
          end
        end
    end
  end
  final begin
    $display("OPENPA-SUMMARY D1=%0d D2=%0d D3=%0d D4=%0d D5=%0d D6=%0d D7=%0d D8=%0d D9=%0d D10=%0d D11=%0d D12=%0d D13=%0d D14=%0d", openpa_n[1], openpa_n[2], openpa_n[3], openpa_n[4], openpa_n[5], openpa_n[6], openpa_n[7], openpa_n[8], openpa_n[9], openpa_n[10], openpa_n[11], openpa_n[12], openpa_n[13], openpa_n[14]);
    openpa_cover_report();
    if (!UPF::openpa_armed) $display("OPENPA-WARNING no supply was driven (supply_on/supply_off never called): every domain stayed CORRUPT");
  end
  // verilator lint_on MULTIDRIVEN
`line 59 "pmu_soc.sv" 0
endmodule

`line 1 "pmu.sv" 0
// pmu_soc: the always-on power controller. Power-unaware RTL: it only drives control signals.
// Sleep: isolate, save, switch off. Wake: switch on, reset, restore, release isolation.
module pmu (
  input  logic       clk,
  input  logic       rst_n,
  input  logic       sleep_req,
  input  logic       wake_req,
  output logic       iso_en,
  output logic       save,
  output logic       restore,
  output logic       pwr_en,
  output logic       core_rst_n,
  output logic [2:0] state_o
);
  typedef enum logic [2:0] { RUN, ISOLATE, SAVE, OFF, PWRUP, RESET, RESTORE, RELEASE } st_e;
  st_e st;
  always_ff @(posedge clk or negedge rst_n)
    if (!rst_n) st <= RUN;
    else case (st)
      RUN:     if (sleep_req) st <= ISOLATE;
      ISOLATE: st <= SAVE;
      SAVE:    st <= OFF;
      OFF:     if (wake_req) st <= PWRUP;
      PWRUP:   st <= RESET;
      RESET:   st <= RESTORE;
      RESTORE: st <= RELEASE;
      RELEASE: st <= RUN;
      default: st <= RUN;
    endcase
  assign iso_en     = (st != RUN);
  assign save       = (st == SAVE);
  assign restore    = (st == RESTORE);
  assign pwr_en     = !(st == OFF);
  assign core_rst_n = rst_n && (st != RESET);
  assign state_o    = st;
endmodule

`line 1 "core.sv" 0
// pmu_soc: the switchable core. An accumulator, a beat counter and a 4-word register file.
// Power-unaware RTL: nothing here knows about supplies.
module core (
  input  logic       clk,
  input  logic       rst_n,
  input  logic       en,
  input  logic [7:0] d,
  input  logic [1:0] rf_addr,
  input  logic       rf_we,
  output logic [7:0] acc,
  output logic [7:0] rf_rd,
  output logic       busy,
  output logic [3:0] beats
);
  logic [7:0] rf [0:3];
  always_ff @(posedge clk or negedge rst_n)
    if (!rst_n) begin
      acc   <= '0;
      beats <= '0;
    end else if (en) begin
      acc   <= acc + d;
      beats <= beats + 4'd1;
    end
  always_ff @(posedge clk)
    if (rf_we) rf[rf_addr] <= acc;
  assign rf_rd = rf[rf_addr];
  assign busy  = en;
endmodule

Check Yourself

Predict the outputRun the original PST with no transition declaration. What does the shortcut sample print?
`timescale 1ns/1ps
module tb;
  import UPF::*;
  pmu_soc dut(.clk(1'b0), .rst_n(1'b1));
  task sample(string label);
    #2;
    $display("%s cpu_on=%0d mem_on=%0d mode=%0s",label,
      get_supply_on_state(get_supply_value("CPU")),get_supply_on_state(get_supply_value("MEM")),
      dut.openpa_cn1(openpa_pst_BOARD_MODES_row));
  endtask
  initial begin
    void'(supply_on("VIN",1.0)); void'(supply_on("GND",0.0));
    void'(supply_on("CPU",1.0)); void'(supply_on("MEM",0.8)); sample("start");
    void'(supply_off("CPU")); sample("park");
    void'(supply_off("MEM")); sample("cold");
    void'(supply_on("CPU",1.0)); void'(supply_on("MEM",0.8)); sample("shortcut");
    void'(supply_off("MEM")); sample("missing");
    $finish;
  end
endmodule
Read included file: pa_pmu_soc.sv
// pa_pmu_soc.sv: power-aware copy of pmu_soc, generated by OpenPA from board.upf.
// Do not edit: regenerate. Simulators: Icarus 12 (4-state, X corruption) or Verilator 5 with --timing (2-state).
// Build with -Wno-fatal on Verilator: forced registers raise MULTIDRIVEN warnings.
`timescale 1ns/1ps
// ---------------------------------------------------------------------------
// package UPF: generated by OpenPA. Supply types, supply_on/supply_off and the power
// state of the design. Names starting with openpa_ are internal.
// ---------------------------------------------------------------------------
package UPF;
  typedef string upfStringT; typedef int upfIntegerT; typedef bit upfBooleanT; typedef logic upfLogicT; typedef real upfRealT; typedef int upfHandleT;
  typedef enum { OFF, FULL_ON, PARTIAL_ON, UNDETERMINED } upfSupplyStateE;
  typedef struct packed { upfSupplyStateE state; int voltage; } upfSupplyTypeT;  // voltage in microvolts
  typedef upfSupplyTypeT supply_net_type;
  bit openpa_armed;        // set by the first call that drives a supply
  bit openpa_kick;         // pulsed once at time 0 to evaluate everything
  bit openpa_xmode;        // 1: corrupt to X; 0: seeded 2-state values
  int unsigned openpa_seed = 1;
  int openpa_cmode;        // 2-state corruption: 0 random, 1 all zero, 2 all one
  supply_net_type openpa_port_VIN;   // supply port VIN (board.upf:4)
  supply_net_type openpa_port_CPU;   // supply port CPU (board.upf:7)
  supply_net_type openpa_port_MEM;   // supply port MEM (board.upf:10)
  supply_net_type openpa_port_GND;   // supply port GND (board.upf:13)
  supply_net_type openpa_net_VIN_N;   // supply net VIN_N
  supply_net_type openpa_net_CPU_N;   // supply net CPU_N
  supply_net_type openpa_net_MEM_N;   // supply net MEM_N
  supply_net_type openpa_net_GND_N;   // supply net GND_N
  bit openpa_ss_BOARD_ok; int unsigned openpa_ss_BOARD_ep; int openpa_ss_BOARD_st = -1; bit openpa_ss_BOARD_multi; int openpa_ss_BOARD_sim = 5;   // supply set BOARD
  bit openpa_dom_SYSTEM_ok; int unsigned openpa_dom_SYSTEM_ep; int openpa_dom_SYSTEM_sim = 5;   // power domain SYSTEM: ok = powered (simstate not CORRUPT); sim = simstate code (board.upf:3)
  // simstate codes, by IEEE 1801-2024 4.8 precedence: 0 NORMAL, 1 CORRUPT_STATE_ON_CHANGE, 2 CORRUPT_STATE_ON_ACTIVITY,
  // 3 CORRUPT_ON_CHANGE, 4 CORRUPT_ON_ACTIVITY, 5 CORRUPT (and NOT_NORMAL, 9.5.8); README "Simstates"
  int openpa_pst_BOARD_MODES_row = -1;   // PST BOARD_MODES (board.upf:22)
  function automatic logic [63:0] openpa_mix(int unsigned id, int unsigned ep, int unsigned lane);
    logic [63:0] z;
    if (openpa_cmode == 1) return 64'd0;
    if (openpa_cmode == 2) return ~64'd0;
    z = {32'd0, openpa_seed} * 64'h9E3779B97F4A7C15 + {32'd0, id} * 64'hC2B2AE3D27D4EB4F + {32'd0, ep} * 64'h165667B19E3779F9 + {32'd0, lane} * 64'hD6E8FEB86659FD93;
    z = (z ^ (z >> 30)) * 64'hBF58476D1CE4E5B9;
    z = (z ^ (z >> 27)) * 64'h94D049BB133111EB;
    return z ^ (z >> 31);
  endfunction
  function automatic bit openpa_bit(int unsigned id, int unsigned ep); logic [63:0] z; z = openpa_mix(id, ep, 0); return z[0]; endfunction
  function automatic int openpa_uv(real v); return $rtoi(v * 1.0e6 + (v < 0.0 ? -0.5 : 0.5)); endfunction
  // supply_on: FULL_ON at the given voltage (11.2.4; default 1.0 V)
  function automatic upfBooleanT supply_on(string pad_name, real value = 1.0);
    openpa_armed = 1;
    if (pad_name == "VIN") begin openpa_port_VIN.state = FULL_ON; openpa_port_VIN.voltage = openpa_uv(value); return 1; end
    if (pad_name == "CPU") begin openpa_port_CPU.state = FULL_ON; openpa_port_CPU.voltage = openpa_uv(value); return 1; end
    if (pad_name == "MEM") begin openpa_port_MEM.state = FULL_ON; openpa_port_MEM.voltage = openpa_uv(value); return 1; end
    if (pad_name == "GND") begin openpa_port_GND.state = FULL_ON; openpa_port_GND.voltage = openpa_uv(value); return 1; end
    if (pad_name == "VIN_N") begin $display("OPENPA-ERROR supply_on(\"%s\"): VIN_N already has a driver (port VIN); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "BOARD.power") begin $display("OPENPA-ERROR supply_on(\"%s\"): BOARD.power already has a driver (port VIN); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "SYSTEM.primary.power") begin $display("OPENPA-ERROR supply_on(\"%s\"): SYSTEM.primary.power already has a driver (port VIN); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "CPU_N") begin $display("OPENPA-ERROR supply_on(\"%s\"): CPU_N already has a driver (port CPU); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "MEM_N") begin $display("OPENPA-ERROR supply_on(\"%s\"): MEM_N already has a driver (port MEM); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "GND_N") begin $display("OPENPA-ERROR supply_on(\"%s\"): GND_N already has a driver (port GND); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "BOARD.ground") begin $display("OPENPA-ERROR supply_on(\"%s\"): BOARD.ground already has a driver (port GND); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "SYSTEM.primary.ground") begin $display("OPENPA-ERROR supply_on(\"%s\"): SYSTEM.primary.ground already has a driver (port GND); drive its root supply instead", pad_name); return 0; end
    $display("OPENPA-ERROR supply_on(\"%s\"): no supply port or root supply net of that name (writable: VIN CPU MEM GND)", pad_name);
    return 0;
  endfunction
  // supply_off: OFF, voltage unchanged (9.3.1); a second argument is accepted and ignored
  function automatic upfBooleanT supply_off(string pad_name, real value = 0.0);
    openpa_armed = 1;
    if (pad_name == "VIN") begin openpa_port_VIN.state = OFF; return 1; end
    if (pad_name == "CPU") begin openpa_port_CPU.state = OFF; return 1; end
    if (pad_name == "MEM") begin openpa_port_MEM.state = OFF; return 1; end
    if (pad_name == "GND") begin openpa_port_GND.state = OFF; return 1; end
    if (pad_name == "VIN_N") begin $display("OPENPA-ERROR supply_off(\"%s\"): VIN_N already has a driver (port VIN); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "BOARD.power") begin $display("OPENPA-ERROR supply_off(\"%s\"): BOARD.power already has a driver (port VIN); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "SYSTEM.primary.power") begin $display("OPENPA-ERROR supply_off(\"%s\"): SYSTEM.primary.power already has a driver (port VIN); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "CPU_N") begin $display("OPENPA-ERROR supply_off(\"%s\"): CPU_N already has a driver (port CPU); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "MEM_N") begin $display("OPENPA-ERROR supply_off(\"%s\"): MEM_N already has a driver (port MEM); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "GND_N") begin $display("OPENPA-ERROR supply_off(\"%s\"): GND_N already has a driver (port GND); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "BOARD.ground") begin $display("OPENPA-ERROR supply_off(\"%s\"): BOARD.ground already has a driver (port GND); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "SYSTEM.primary.ground") begin $display("OPENPA-ERROR supply_off(\"%s\"): SYSTEM.primary.ground already has a driver (port GND); drive its root supply instead", pad_name); return 0; end
    $display("OPENPA-ERROR supply_off(\"%s\"): no supply port or root supply net of that name (writable: VIN CPU MEM GND)", pad_name);
    return 0;
  endfunction
  // supply_partial_on: PARTIAL_ON at the given voltage (11.2.4)
  function automatic upfBooleanT supply_partial_on(string pad_name, real value = 1.0);
    openpa_armed = 1;
    if (pad_name == "VIN") begin openpa_port_VIN.state = PARTIAL_ON; openpa_port_VIN.voltage = openpa_uv(value); return 1; end
    if (pad_name == "CPU") begin openpa_port_CPU.state = PARTIAL_ON; openpa_port_CPU.voltage = openpa_uv(value); return 1; end
    if (pad_name == "MEM") begin openpa_port_MEM.state = PARTIAL_ON; openpa_port_MEM.voltage = openpa_uv(value); return 1; end
    if (pad_name == "GND") begin openpa_port_GND.state = PARTIAL_ON; openpa_port_GND.voltage = openpa_uv(value); return 1; end
    if (pad_name == "VIN_N") begin $display("OPENPA-ERROR supply_partial_on(\"%s\"): VIN_N already has a driver (port VIN); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "BOARD.power") begin $display("OPENPA-ERROR supply_partial_on(\"%s\"): BOARD.power already has a driver (port VIN); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "SYSTEM.primary.power") begin $display("OPENPA-ERROR supply_partial_on(\"%s\"): SYSTEM.primary.power already has a driver (port VIN); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "CPU_N") begin $display("OPENPA-ERROR supply_partial_on(\"%s\"): CPU_N already has a driver (port CPU); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "MEM_N") begin $display("OPENPA-ERROR supply_partial_on(\"%s\"): MEM_N already has a driver (port MEM); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "GND_N") begin $display("OPENPA-ERROR supply_partial_on(\"%s\"): GND_N already has a driver (port GND); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "BOARD.ground") begin $display("OPENPA-ERROR supply_partial_on(\"%s\"): BOARD.ground already has a driver (port GND); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "SYSTEM.primary.ground") begin $display("OPENPA-ERROR supply_partial_on(\"%s\"): SYSTEM.primary.ground already has a driver (port GND); drive its root supply instead", pad_name); return 0; end
    $display("OPENPA-ERROR supply_partial_on(\"%s\"): no supply port or root supply net of that name (writable: VIN CPU MEM GND)", pad_name);
    return 0;
  endfunction
  // set_supply_state: the state only, voltage unchanged (9.3.1)
  function automatic upfBooleanT set_supply_state(string pad_name, upfSupplyStateE supply_state);
    openpa_armed = 1;
    if (pad_name == "VIN") begin openpa_port_VIN.state = supply_state; return 1; end
    if (pad_name == "CPU") begin openpa_port_CPU.state = supply_state; return 1; end
    if (pad_name == "MEM") begin openpa_port_MEM.state = supply_state; return 1; end
    if (pad_name == "GND") begin openpa_port_GND.state = supply_state; return 1; end
    if (pad_name == "VIN_N") begin $display("OPENPA-ERROR set_supply_state(\"%s\"): VIN_N already has a driver (port VIN); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "BOARD.power") begin $display("OPENPA-ERROR set_supply_state(\"%s\"): BOARD.power already has a driver (port VIN); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "SYSTEM.primary.power") begin $display("OPENPA-ERROR set_supply_state(\"%s\"): SYSTEM.primary.power already has a driver (port VIN); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "CPU_N") begin $display("OPENPA-ERROR set_supply_state(\"%s\"): CPU_N already has a driver (port CPU); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "MEM_N") begin $display("OPENPA-ERROR set_supply_state(\"%s\"): MEM_N already has a driver (port MEM); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "GND_N") begin $display("OPENPA-ERROR set_supply_state(\"%s\"): GND_N already has a driver (port GND); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "BOARD.ground") begin $display("OPENPA-ERROR set_supply_state(\"%s\"): BOARD.ground already has a driver (port GND); drive its root supply instead", pad_name); return 0; end
    if (pad_name == "SYSTEM.primary.ground") begin $display("OPENPA-ERROR set_supply_state(\"%s\"): SYSTEM.primary.ground already has a driver (port GND); drive its root supply instead", pad_name); return 0; end
    $display("OPENPA-ERROR set_supply_state(\"%s\"): no supply port or root supply net of that name (writable: VIN CPU MEM GND)", pad_name);
    return 0;
  endfunction
  // set_power_state (9.3.1) is not supported: OpenPA has no deferred power states. A call is reported, never ignored.
  function automatic upfBooleanT set_power_state(string object_name, string power_state);
    $display("OPENPA-ERROR set_power_state(\"%s\", \"%s\"): not supported by OpenPA; drive the supplies with supply_on, supply_off or set_supply_state", object_name, power_state);
    return 0;
  endfunction
  // Supply queries (11.2.4). Names: supply ports, supply nets and supply set functions as the UPF wrote them.
  function automatic upfSupplyTypeT get_supply_value(string name);
    if (name == "VIN" || name == "VIN_N" || name == "BOARD.power" || name == "SYSTEM.primary.power") return openpa_net_VIN_N;
    if (name == "CPU" || name == "CPU_N") return openpa_net_CPU_N;
    if (name == "MEM" || name == "MEM_N") return openpa_net_MEM_N;
    if (name == "GND" || name == "GND_N" || name == "BOARD.ground" || name == "SYSTEM.primary.ground") return openpa_net_GND_N;
    $display("OPENPA-ERROR get_supply_value(\"%s\"): no supply net, port or supply set function of that name", name);
    return 0;
  endfunction
  function automatic upfRealT get_supply_voltage(upfSupplyTypeT arg); return arg.voltage / 1.0e6; endfunction
  // 11.2.4: 1 for FULL_ON; 0 otherwise.
  function automatic upfBooleanT get_supply_on_state(upfSupplyTypeT arg); return arg.state == FULL_ON; endfunction
  function automatic upfSupplyStateE get_supply_state(upfSupplyTypeT arg); return arg.state; endfunction
endpackage
// ---------------------------------------------------------------------------
// OpenPA cells (generated; do not edit)
// ---------------------------------------------------------------------------
// openpa_corrupt: rule C2. Passes d while the driving domain is NORMAL; otherwise drives X (4-state)
// or a seeded value (2-state). The value is computed ahead for the episode the next power-down starts
// (ep + 1 while ok), so at power-down the output goes straight from d to the new value: no delta glitch
// through the previous episode's value (Icarus would turn one into a clock edge).
module openpa_corrupt #(parameter int W = 1, parameter int unsigned ID = 0) (
  input  logic [W-1:0] d,
  output logic [W-1:0] q,
  input  bit           ok,
  input  int unsigned  ep
);
  localparam int L = (W + 63) / 64;
  logic [L*64-1:0] cv;
  always @(ep or ok or UPF::openpa_kick)
    for (int i = 0; i < L; i++) cv[i*64 +: 64] = UPF::openpa_mix(ID, ok ? ep + 1 : ep, i);
  assign q = ok ? d : (UPF::openpa_xmode ? {W{1'bx}} : cv[W-1:0]);
endmodule

// openpa_corrupt_sim: rule C2 for a domain that has intermediate simstates (IEEE 1801-2024 9.5). As
// openpa_corrupt, and also corrupt while lhit is set (CORRUPT_ON_ACTIVITY after input activity), or after d
// changed while coc is set (CORRUPT_ON_CHANGE); leaving CORRUPT_ON_CHANGE clears that.
module openpa_corrupt_sim #(parameter int W = 1, parameter int unsigned ID = 0) (
  input  logic [W-1:0] d,
  output logic [W-1:0] q,
  input  bit           ok,
  input  int unsigned  ep,
  input  bit           lhit,
  input  bit           coc
);
  localparam int L = (W + 63) / 64;
  logic [L*64-1:0] cv;
  bit chg;
  always @(ep or ok or UPF::openpa_kick)
    for (int i = 0; i < L; i++) cv[i*64 +: 64] = UPF::openpa_mix(ID, ok ? ep + 1 : ep, i);
  // verilator lint_off MULTIDRIVEN
  for (genvar i = 0; i < W; i++) begin : g_chg
    always @(posedge d[i] or negedge d[i]) if (coc && ok) chg = 1'b1;
  end
  always @(negedge coc) chg = 1'b0;
  // verilator lint_on MULTIDRIVEN
  assign q = (ok && !lhit && !chg) ? d : (UPF::openpa_xmode ? {W{1'bx}} : cv[W-1:0]);
endmodule

// openpa_iso: rules I1-I4 (IEEE 1801-2024 9.8). CLAMP 0, 1, 2 (latch: the value the input had while the enable
// was inactive) or 3 (Z: high impedance on 4-state; 0 on 2-state backends, which cannot represent Z).
// sup_ok is 1 while the isolation supply is NORMAL (always, for a strategy with no supply); otherwise the output,
// and a latched value, are corrupt. An enable at X or Z corrupts the output and the latched value.
module openpa_iso #(parameter int W = 1, parameter int CLAMP = 0, parameter bit SENSE = 1'b1, parameter int unsigned ID = 0) (
  input  logic [W-1:0] d,
  output logic [W-1:0] q,
  input  logic         en,
  input  bit           sup_ok,
  input  int unsigned  sup_ep
);
  localparam int L = (W + 63) / 64;
  logic [L*64-1:0] cv;
  logic [W-1:0] held;
  always @(sup_ep or sup_ok or UPF::openpa_kick)
    for (int i = 0; i < L; i++) cv[i*64 +: 64] = UPF::openpa_mix(ID + 32'h4000_0000, sup_ok ? sup_ep + 1 : sup_ep, i);
  wire active   = (en === SENSE);
  wire inactive = (en === !SENSE);
  wire [W-1:0] bad    = UPF::openpa_xmode ? {W{1'bx}} : cv[W-1:0];
  if (CLAMP == 2) begin : g_latch
    always @(d or en or sup_ok or bad) if (!sup_ok || !(active || inactive)) held = bad; else if (inactive) held = d;
  end
  wire [W-1:0] clampv = (CLAMP == 3) ? (UPF::openpa_xmode ? {W{1'bz}} : {W{1'b0}}) : (CLAMP == 2) ? held : (CLAMP == 1) ? {W{1'b1}} : {W{1'b0}};
  assign q = !sup_ok ? bad : active ? clampv : inactive ? d : bad;
endmodule

// openpa_ls: rule L1 (IEEE 1801-2024 9.9). Passes d while every supply set of the cell is NORMAL; otherwise corrupt.
module openpa_ls #(parameter int W = 1, parameter int unsigned ID = 0) (
  input  logic [W-1:0] d,
  output logic [W-1:0] q,
  input  bit           src_ok,
  input  bit           dst_ok,
  input  int unsigned  ep
);
  localparam int L = (W + 63) / 64;
  logic [L*64-1:0] cv;
  always @(ep or src_ok or dst_ok or UPF::openpa_kick)
    for (int i = 0; i < L; i++) cv[i*64 +: 64] = UPF::openpa_mix(ID + 32'h8000_0000, (src_ok && dst_ok) ? ep + 1 : ep, i);
  assign q = (src_ok && dst_ok) ? d : (UPF::openpa_xmode ? {W{1'bx}} : cv[W-1:0]);
endmodule

`line 1 "pmu_soc.sv" 0
// pmu_soc: two power domains. The top and the controller are always on; u_core can be switched off.
// The RTL is power-unaware: no isolation cell, no supply, no retention register is written here.
module pmu_soc (
  input  logic       clk,
  input  logic       rst_n,
  input  logic       sleep_req,
  input  logic       wake_req,
  input  logic       en,
  input  logic [7:0] d,
  input  logic [1:0] rf_addr,
  input  logic       rf_we,
  output logic [7:0] total,
  output logic       led,
  output logic [7:0] rd,
  output logic [3:0] beats,
  output logic [7:0] status,
  output logic [2:0] pmu_state
);
  logic iso_en, save, restore, pwr_en, core_rst_n;
  logic [7:0] acc, rf_rd;
  logic busy;
  logic [3:0] core_beats;

  pmu u_pmu (
    .clk        (clk),
    .rst_n      (rst_n),
    .sleep_req  (sleep_req),
    .wake_req   (wake_req),
    .iso_en     (iso_en),
    .save       (save),
    .restore    (restore),
    .pwr_en     (pwr_en),
    .core_rst_n (core_rst_n),
    .state_o    (pmu_state)
  );

  core u_core (
    .clk     (clk),
    .rst_n   (core_rst_n),
    .en      (en),
    .d       (d),
    .rf_addr (rf_addr),
    .rf_we   (rf_we),
    .acc     (acc),
    .rf_rd   (rf_rd),
    .busy    (busy),
    .beats   (core_beats)
  );

  // Always-on consumers of the core's outputs.
  assign total = acc;
  assign led   = busy;
  assign rd    = rf_rd;
  assign beats = core_beats;
  // A status register: keeps the last accumulator value seen while the core was busy.
  always_ff @(posedge clk or negedge rst_n)
    if (!rst_n) status <= '0;
    else if (busy) status <= acc;

`line 1 "openpa_overlay.sv" 0
  // ===================================================================================
  // OpenPA overlay for pmu_soc: generated from board.upf. Do not edit.
  // ===================================================================================
  // verilator lint_off MULTIDRIVEN
  // verilator lint_off ENUMVALUE
  // verilator lint_off WIDTHTRUNC
  // verilator lint_off WIDTHEXPAND
  // verilator lint_off BLKSEQ
  // verilator lint_off IGNOREDRETURN
  import UPF::openpa_cmode;
  import UPF::openpa_dom_SYSTEM_ep;
  import UPF::openpa_dom_SYSTEM_ok;
  import UPF::openpa_dom_SYSTEM_sim;
  import UPF::openpa_kick;
  import UPF::openpa_net_CPU_N;
  import UPF::openpa_net_GND_N;
  import UPF::openpa_net_MEM_N;
  import UPF::openpa_net_VIN_N;
  import UPF::openpa_pst_BOARD_MODES_row;
  import UPF::openpa_seed;
  import UPF::openpa_ss_BOARD_ep;
  import UPF::openpa_ss_BOARD_multi;
  import UPF::openpa_ss_BOARD_ok;
  import UPF::openpa_ss_BOARD_sim;
  import UPF::openpa_ss_BOARD_st;
  import UPF::openpa_xmode;
  // ---- mode, seed, trace
  bit openpa_tr, openpa_obs;
  int openpa_n [1:14];
  int openpa_seq [1:1];   // good-form sequence bins (coverage)
  bit openpa_sreq; bit openpa_sp [1:2];   // deferred checks: request and pending flags
  string openpa_mode_arg;
  initial begin
  `ifdef VERILATOR
    openpa_xmode = 1'b0;
  `else
    openpa_xmode = 1'b1;
  `endif
    openpa_cmode = 0;
    if ($value$plusargs("openpa_corrupt=%s", openpa_mode_arg)) begin
      if (openpa_mode_arg == "x") openpa_xmode = 1'b1;
      else if (openpa_mode_arg == "random") openpa_xmode = 1'b0;
      else if (openpa_mode_arg == "zero") begin openpa_xmode = 1'b0; openpa_cmode = 1; end
      else if (openpa_mode_arg == "one") begin openpa_xmode = 1'b0; openpa_cmode = 2; end
      else $display("OPENPA-ERROR +openpa_corrupt=%s: use x, random, zero or one", openpa_mode_arg);
    end
    if (!$value$plusargs("openpa_seed=%d", openpa_seed)) openpa_seed = 1;
    openpa_tr = $test$plusargs("openpa_trace");
    openpa_obs = $test$plusargs("openpa_obs");
    $display("OPENPA-INFO corruption=%0s seed=%0d", openpa_xmode ? "x" : (openpa_cmode == 1 ? "zero" : openpa_cmode == 2 ? "one" : "random"), openpa_seed);
    #0 openpa_kick = 1'b1;
  end
  task automatic openpa_check(input int id, input string msg);
    openpa_n[id] = openpa_n[id] + 1;
    $display("OPENPA-CHECK D%0d @ %0t: %s", id, $time, msg);
  endtask
  task automatic openpa_t(input string msg);
    if (openpa_tr) $display("OPENPA-TRACE @ %0t: %s", $time, msg);
  endtask

  // ---- copies of the design signals the UPF names (4-state, so X is visible)

  // ---- supply network, switches, supply sets, simstates, power states (one block, evaluated in order)
  bit openpa_tg_pst_BOARD_MODES_row; int openpa_pv_pst_BOARD_MODES_row = -2;
  always @(openpa_kick or UPF::openpa_port_VIN or UPF::openpa_port_CPU or UPF::openpa_port_MEM or UPF::openpa_port_GND) begin : openpa_network
    openpa_net_VIN_N = UPF::openpa_port_VIN;   // VIN_N <- port VIN
    openpa_net_CPU_N = UPF::openpa_port_CPU;   // CPU_N <- port CPU
    openpa_net_MEM_N = UPF::openpa_port_MEM;   // MEM_N <- port MEM
    openpa_net_GND_N = UPF::openpa_port_GND;   // GND_N <- port GND
    // supply set BOARD (also SYSTEM.primary): IEEE 1801-2024 4.7.3, 4.7.4, 6.5.6, 9.3.2, 5.7.8
    begin : openpa_ss_BOARD
      bit nx; int sm;
      sm = (UPF::openpa_net_VIN_N.state == UPF::FULL_ON && UPF::openpa_net_GND_N.state == UPF::FULL_ON) ? 0 : 5;   // predefined ON (NORMAL) or OFF (CORRUPT), IEEE 1801-2024 4.7.4
      openpa_ss_BOARD_sim = sm;
      nx = sm < 5;
      if (openpa_ss_BOARD_ok && !nx) openpa_ss_BOARD_ep = openpa_ss_BOARD_ep + 1;
      openpa_ss_BOARD_ok = nx;
    end
    // domain SYSTEM: simstate of its primary supply set BOARD
    if (openpa_dom_SYSTEM_ok && !UPF::openpa_ss_BOARD_ok) openpa_dom_SYSTEM_ep = openpa_dom_SYSTEM_ep + 1;
    openpa_dom_SYSTEM_ok = UPF::openpa_ss_BOARD_ok;
    openpa_dom_SYSTEM_sim = openpa_ss_BOARD_sim;
    // power state table BOARD_MODES (board.upf:22): rule P4
    openpa_pst_BOARD_MODES_row = -1;
    if (openpa_pst_BOARD_MODES_row == -1 && (UPF::openpa_net_VIN_N.state == UPF::FULL_ON && UPF::openpa_net_VIN_N.voltage == 1000000) && (UPF::openpa_net_CPU_N.state == UPF::FULL_ON && UPF::openpa_net_CPU_N.voltage == 1000000) && (UPF::openpa_net_MEM_N.state == UPF::FULL_ON && UPF::openpa_net_MEM_N.voltage == 800000) && (UPF::openpa_net_GND_N.state == UPF::FULL_ON && UPF::openpa_net_GND_N.voltage == 0)) openpa_pst_BOARD_MODES_row = 0;   // Work
    if (openpa_pst_BOARD_MODES_row == -1 && (UPF::openpa_net_VIN_N.state == UPF::FULL_ON && UPF::openpa_net_VIN_N.voltage == 1000000) && (UPF::openpa_net_CPU_N.state == UPF::OFF) && (UPF::openpa_net_MEM_N.state == UPF::FULL_ON && UPF::openpa_net_MEM_N.voltage == 800000) && (UPF::openpa_net_GND_N.state == UPF::FULL_ON && UPF::openpa_net_GND_N.voltage == 0)) openpa_pst_BOARD_MODES_row = 1;   // Nap
    if (openpa_pst_BOARD_MODES_row == -1 && (UPF::openpa_net_VIN_N.state == UPF::FULL_ON && UPF::openpa_net_VIN_N.voltage == 1000000) && (UPF::openpa_net_CPU_N.state == UPF::OFF) && (UPF::openpa_net_MEM_N.state == UPF::OFF) && (UPF::openpa_net_GND_N.state == UPF::FULL_ON && UPF::openpa_net_GND_N.voltage == 0)) openpa_pst_BOARD_MODES_row = 2;   // Cold
    if (openpa_pst_BOARD_MODES_row != openpa_pv_pst_BOARD_MODES_row) begin openpa_tg_pst_BOARD_MODES_row = ~openpa_tg_pst_BOARD_MODES_row; openpa_pv_pst_BOARD_MODES_row = openpa_pst_BOARD_MODES_row; end
  end

  // ---- corruption: registers forced, memories overwritten (rules C1, C3)
  // domain SYSTEM (board.upf:3): 4 register(s), 1 memory(ies)
  bit openpa_SYSTEM_applied, openpa_SYSTEM_valid;
  logic [7:0] openpa_cv1;   // corruption value for status
  logic [7:0] openpa_cv2;   // corruption value for u_core.acc
  logic [3:0] openpa_cv3;   // corruption value for u_core.beats
  logic [2:0] openpa_cv4;   // corruption value for u_pmu.st
  // The first evaluation counts as a power-up from OFF: registers take the corruption value even when the
  // supplies are already on at time 0 (rule C3), so 4-state and 2-state runs start alike.
  always @(UPF::openpa_dom_SYSTEM_ok or openpa_kick) if (!openpa_SYSTEM_valid || openpa_SYSTEM_applied != UPF::openpa_dom_SYSTEM_ok) begin
    openpa_t({"SYSTEM ", UPF::openpa_dom_SYSTEM_ok ? "NORMAL" : "CORRUPT"});
    if (!UPF::openpa_dom_SYSTEM_ok || !openpa_SYSTEM_valid) begin
      if (openpa_xmode) openpa_cv1 = 'x; else openpa_cv1 = UPF::openpa_mix(1, UPF::openpa_dom_SYSTEM_ep, 0);
      force status = openpa_cv1;
      if (openpa_xmode) openpa_cv2 = 'x; else openpa_cv2 = UPF::openpa_mix(2, UPF::openpa_dom_SYSTEM_ep, 0);
      force u_core.acc = openpa_cv2;
      if (openpa_xmode) openpa_cv3 = 'x; else openpa_cv3 = UPF::openpa_mix(3, UPF::openpa_dom_SYSTEM_ep, 0);
      force u_core.beats = openpa_cv3;
      if (openpa_xmode) openpa_cv4 = 'x; else openpa_cv4 = UPF::openpa_mix(4, UPF::openpa_dom_SYSTEM_ep, 0);
      force u_pmu.st = openpa_cv4;
      for (int i = 0; i < 4; i++) u_core.rf[0 + i] = openpa_xmode ? 8'bx : UPF::openpa_mix(100000, UPF::openpa_dom_SYSTEM_ep, (i) * 1 + 0);
    end
    if (UPF::openpa_dom_SYSTEM_ok) begin
      for (int i = 0; i < 4; i++) u_core.rf[0 + i] = openpa_xmode ? 8'bx : UPF::openpa_mix(100000, UPF::openpa_dom_SYSTEM_ep, (i) * 1 + 0);
      release status;
      release u_core.acc;
      release u_core.beats;
      release u_pmu.st;
    end
    openpa_SYSTEM_valid = 1'b1; openpa_SYSTEM_applied = UPF::openpa_dom_SYSTEM_ok;
  end

  // ---- power states (D8): checked once the bench has driven a supply, after the time step settles
  always @(posedge openpa_tg_pst_BOARD_MODES_row or negedge openpa_tg_pst_BOARD_MODES_row or posedge UPF::openpa_armed) if (UPF::openpa_armed)
    begin openpa_sp[1] = 1'b1; openpa_sreq = 1'b1; end
  int openpa_cs1 [0:3]; int openpa_ct1 [0:3][0:3]; int openpa_cp1 = -1, openpa_cc1;   // coverage of pst BOARD_MODES
  function automatic string openpa_cn1(int i); case (i) 0: return "Work"; 1: return "Nap"; 2: return "Cold"; default: return "<none>"; endcase endfunction
  always @(posedge openpa_tg_pst_BOARD_MODES_row or negedge openpa_tg_pst_BOARD_MODES_row or posedge UPF::openpa_armed) if (UPF::openpa_armed)
    begin openpa_sp[2] = 1'b1; openpa_sreq = 1'b1; end

  // ---- observation for differential corruption (+openpa_obs): design-top outputs while the top domain is on
  `ifdef OPENPA_OBS
  longint openpa_obs_after;
  initial if (!$value$plusargs("openpa_obs_after=%d", openpa_obs_after)) openpa_obs_after = 0;
  always @(total) if (openpa_obs && UPF::openpa_dom_SYSTEM_ok && $time >= openpa_obs_after) $display("OPENPA-OBS @ %0t: total=%h", $time, total);
  always @(led) if (openpa_obs && UPF::openpa_dom_SYSTEM_ok && $time >= openpa_obs_after) $display("OPENPA-OBS @ %0t: led=%h", $time, led);
  always @(rd) if (openpa_obs && UPF::openpa_dom_SYSTEM_ok && $time >= openpa_obs_after) $display("OPENPA-OBS @ %0t: rd=%h", $time, rd);
  always @(beats) if (openpa_obs && UPF::openpa_dom_SYSTEM_ok && $time >= openpa_obs_after) $display("OPENPA-OBS @ %0t: beats=%h", $time, beats);
  always @(status) if (openpa_obs && UPF::openpa_dom_SYSTEM_ok && $time >= openpa_obs_after) $display("OPENPA-OBS @ %0t: status=%h", $time, status);
  always @(pmu_state) if (openpa_obs && UPF::openpa_dom_SYSTEM_ok && $time >= openpa_obs_after) $display("OPENPA-OBS @ %0t: pmu_state=%h", $time, pmu_state);
  `else
  initial if ($test$plusargs("openpa_obs")) $display("OPENPA-ERROR +openpa_obs needs the copy compiled with OPENPA_OBS defined (-DOPENPA_OBS or +define+OPENPA_OBS)");
  `endif

  // Icarus 12 runs no named block inside a final block, so the report is a function.
  function automatic void openpa_cover_report();
      int hs, ht, hq;
      hs = 0; ht = 0; hq = 0;
      $display("OPENPA-COVER state pst BOARD_MODES Work %0d", openpa_cs1[0]);
      $display("OPENPA-COVER state pst BOARD_MODES Nap %0d", openpa_cs1[1]);
      $display("OPENPA-COVER state pst BOARD_MODES Cold %0d", openpa_cs1[2]);
      if (openpa_cs1[3]) $display("OPENPA-COVER state pst BOARD_MODES <none> %0d", openpa_cs1[3]);
      for (int i = 0; i <= 3; i++) for (int j = 0; j <= 3; j++) if (openpa_ct1[i][j]) $display("OPENPA-COVER transition pst BOARD_MODES %0s -> %0s %0d", openpa_cn1(i), openpa_cn1(j), openpa_ct1[i][j]);
      if (openpa_cs1[0]) hs = hs + 1;
      if (openpa_cs1[1]) hs = hs + 1;
      if (openpa_cs1[2]) hs = hs + 1;
      $display("OPENPA-COVER-SUMMARY states=%0d/3 declared_transitions=%0d/0 sequences=%0d/0", hs, ht, hq);
  endfunction

  // ---- settle process: 2 deferred check(s), run after one #0 in a fixed order
  initial forever begin
    wait (openpa_sreq && openpa_kick);
    #0;
    openpa_sreq = 1'b0;
    if (openpa_sp[1]) begin
      openpa_sp[1] = 1'b0;
        if (!1'b0)   // suspended while a power switch is undetermined (D10 reports that)
        begin
          if (UPF::openpa_pst_BOARD_MODES_row == -1) openpa_check(8, "supplies VIN CPU MEM GND match no row of power state table BOARD_MODES (board.upf:22)");
        end
    end
    if (openpa_sp[2]) begin
      openpa_sp[2] = 1'b0;
        if (!1'b0) begin
          openpa_cc1 = (UPF::openpa_pst_BOARD_MODES_row < 0) ? 3 : UPF::openpa_pst_BOARD_MODES_row;
          if (openpa_cc1 != openpa_cp1) begin
            openpa_cs1[openpa_cc1] = openpa_cs1[openpa_cc1] + 1;
            if (openpa_cp1 >= 0) openpa_ct1[openpa_cp1][openpa_cc1] = openpa_ct1[openpa_cp1][openpa_cc1] + 1;
            openpa_cp1 = openpa_cc1;
          end
        end
    end
  end
  final begin
    $display("OPENPA-SUMMARY D1=%0d D2=%0d D3=%0d D4=%0d D5=%0d D6=%0d D7=%0d D8=%0d D9=%0d D10=%0d D11=%0d D12=%0d D13=%0d D14=%0d", openpa_n[1], openpa_n[2], openpa_n[3], openpa_n[4], openpa_n[5], openpa_n[6], openpa_n[7], openpa_n[8], openpa_n[9], openpa_n[10], openpa_n[11], openpa_n[12], openpa_n[13], openpa_n[14]);
    openpa_cover_report();
    if (!UPF::openpa_armed) $display("OPENPA-WARNING no supply was driven (supply_on/supply_off never called): every domain stayed CORRUPT");
  end
  // verilator lint_on MULTIDRIVEN
`line 59 "pmu_soc.sv" 0
endmodule

`line 1 "pmu.sv" 0
// pmu_soc: the always-on power controller. Power-unaware RTL: it only drives control signals.
// Sleep: isolate, save, switch off. Wake: switch on, reset, restore, release isolation.
module pmu (
  input  logic       clk,
  input  logic       rst_n,
  input  logic       sleep_req,
  input  logic       wake_req,
  output logic       iso_en,
  output logic       save,
  output logic       restore,
  output logic       pwr_en,
  output logic       core_rst_n,
  output logic [2:0] state_o
);
  typedef enum logic [2:0] { RUN, ISOLATE, SAVE, OFF, PWRUP, RESET, RESTORE, RELEASE } st_e;
  st_e st;
  always_ff @(posedge clk or negedge rst_n)
    if (!rst_n) st <= RUN;
    else case (st)
      RUN:     if (sleep_req) st <= ISOLATE;
      ISOLATE: st <= SAVE;
      SAVE:    st <= OFF;
      OFF:     if (wake_req) st <= PWRUP;
      PWRUP:   st <= RESET;
      RESET:   st <= RESTORE;
      RESTORE: st <= RELEASE;
      RELEASE: st <= RUN;
      default: st <= RUN;
    endcase
  assign iso_en     = (st != RUN);
  assign save       = (st == SAVE);
  assign restore    = (st == RESTORE);
  assign pwr_en     = !(st == OFF);
  assign core_rst_n = rst_n && (st != RESET);
  assign state_o    = st;
endmodule

`line 1 "core.sv" 0
// pmu_soc: the switchable core. An accumulator, a beat counter and a 4-word register file.
// Power-unaware RTL: nothing here knows about supplies.
module core (
  input  logic       clk,
  input  logic       rst_n,
  input  logic       en,
  input  logic [7:0] d,
  input  logic [1:0] rf_addr,
  input  logic       rf_we,
  output logic [7:0] acc,
  output logic [7:0] rf_rd,
  output logic       busy,
  output logic [3:0] beats
);
  logic [7:0] rf [0:3];
  always_ff @(posedge clk or negedge rst_n)
    if (!rst_n) begin
      acc   <= '0;
      beats <= '0;
    end else if (en) begin
      acc   <= acc + d;
      beats <= beats + 4'd1;
    end
  always_ff @(posedge clk)
    if (rf_we) rf[rf_addr] <= acc;
  assign rf_rd = rf[rf_addr];
  assign busy  = en;
endmodule

ConceptYou move MEM ahead of CPU in the header. How do you preserve Nap?
ConceptWhy can the converted run report two errors for one out-of-range VIN drive?
ConceptWhich board check needs a previous state?
ConceptWhat does the drawn PANEL group contribute?

Common Mistakes

Wrong Read a row by matching words to rails with similar names.

CUT can belong to either CPU or MEM. Its place in the header tells you which one.

Fix Write the column names above the row before interpreting it.

Wrong Treat the printed order of the rows as the required wake sequence.

A PST row describes simultaneous supply values. It has no predecessor field.

Fix Declare the forbidden movement separately on the object whose state changes.

Wrong Keep only the on bits when translating a table.

VIN at the wrong voltage may still be on. All three rows require NOM.

Fix Retain each voltage test, including the ones shared by every row.

Wrong Mark Work illegal to reject the direct wake from Cold.

That would also reject the ordinary return from Nap.

Fix Keep Work legal and mark the directed Cold to Work transition illegal.

Remember

  • Use the PST header to interpret each row in order.
  • Enumerate the named rail combinations after converting them.
  • Check a forbidden path separately from the legality of its endpoints.
  • Use a group to describe shared modes across objects.

Practice

Report a problem with this page