diff --git a/kevm-pyk/src/kevm_pyk/kproj/evm-semantics/evm.md b/kevm-pyk/src/kevm_pyk/kproj/evm-semantics/evm.md
index a25c2b6bd7..935cfd6ff4 100644
--- a/kevm-pyk/src/kevm_pyk/kproj/evm-semantics/evm.md
+++ b/kevm-pyk/src/kevm_pyk/kproj/evm-semantics/evm.md
@@ -63,12 +63,12 @@ In the comments next to each cell, we've marked which component of the YellowPap
               <callValue> 0        </callValue>             // I_v
 
               // \mu_*
-              <wordStack>   .WordStack </wordStack>           // \mu_s
-              <localMem>    .Bytes     </localMem>            // \mu_m
-              <pc>          0          </pc>                  // \mu_pc
-              <gas>         0:Gas      </gas>                 // \mau_g
-              <memoryUsed>  0          </memoryUsed>          // \mu_i
-              <callGas>     0:Gas      </callGas>
+              <wordStack>   .List  </wordStack>           // \mu_s
+              <localMem>    .Bytes </localMem>            // \mu_m
+              <pc>          0      </pc>                  // \mu_pc
+              <gas>         0:Gas  </gas>                 // \mau_g
+              <memoryUsed>  0      </memoryUsed>          // \mu_i
+              <callGas>     0:Gas  </callGas>
 
               <static>    false </static>
               <callDepth> 0     </callDepth>
@@ -355,11 +355,11 @@ The `#next [_]` operator initiates execution by:
 -   `#stackDelta` is the delta the stack will have after the opcode executes.
 
 ```k
-    syntax Bool ::= #stackUnderflow ( WordStack , OpCode ) [symbol(#stackUnderflow), macro]
-                  | #stackOverflow  ( WordStack , OpCode ) [symbol(#stackOverflow), macro]
- // ---------------------------------------------------------------------------------------
-    rule #stackUnderflow(WS, OP:OpCode) => #sizeWordStack(WS) <Int #stackNeeded(OP)
-    rule #stackOverflow (WS, OP) => #sizeWordStack(WS) +Int #stackDelta(OP) >Int 1024
+    syntax Bool ::= #stackUnderflow ( List , OpCode ) [symbol(#stackUnderflow), macro]
+                  | #stackOverflow  ( List , OpCode ) [symbol(#stackOverflow), macro]
+ // ----------------------------------------------------------------------------------
+    rule #stackUnderflow(WS, OP:OpCode) => size(WS) <Int #stackNeeded(OP)
+    rule #stackOverflow (WS, OP) => size(WS) +Int #stackDelta(OP) >Int 1024
 
     syntax Int ::= #stackNeeded ( OpCode ) [symbol(#stackNeeded), function]
  // -----------------------------------------------------------------------
@@ -408,12 +408,12 @@ The `#next [_]` operator initiates execution by:
 -   `#changesState` is true if the given opcode will change `<network>` state given the arguments.
 
 ```k
-    syntax Bool ::= #changesState ( OpCode , WordStack ) [symbol(#changesState), function]
- // --------------------------------------------------------------------------------------
+    syntax Bool ::= #changesState ( OpCode , List ) [symbol(#changesState), function]
+ // ---------------------------------------------------------------------------------
 ```
 
 ```k
-    rule #changesState(CALL         , _ : _ : VALUE : _) => true  requires VALUE =/=Int 0
+    rule #changesState(CALL         , ListItem(_) ListItem(_) ListItem(VALUE) _) => true  requires VALUE =/=Int 0
     rule #changesState(LOG(_)       , _)                 => true
     rule #changesState(SSTORE       , _)                 => true
     rule #changesState(CREATE       , _)                 => true
@@ -448,17 +448,17 @@ Here we load the correct number of arguments from the `wordStack` based on the s
                         | TernStackOp Int Int Int
                         | QuadStackOp Int Int Int Int
  // -------------------------------------------------
-    rule <k> #exec [ UOP:UnStackOp   ] => #gas [ UOP , UOP W0          ] ~> UOP W0          ... </k> <wordStack> W0 : WS                => WS </wordStack>
-    rule <k> #exec [ BOP:BinStackOp  ] => #gas [ BOP , BOP W0 W1       ] ~> BOP W0 W1       ... </k> <wordStack> W0 : W1 : WS           => WS </wordStack>
-    rule <k> #exec [ TOP:TernStackOp ] => #gas [ TOP , TOP W0 W1 W2    ] ~> TOP W0 W1 W2    ... </k> <wordStack> W0 : W1 : W2 : WS      => WS </wordStack>
-    rule <k> #exec [ QOP:QuadStackOp ] => #gas [ QOP , QOP W0 W1 W2 W3 ] ~> QOP W0 W1 W2 W3 ... </k> <wordStack> W0 : W1 : W2 : W3 : WS => WS </wordStack>
+    rule <k> #exec [ UOP:UnStackOp   ] => #gas [ UOP , UOP W0          ] ~> UOP W0          ... </k> <wordStack> ListItem(W0) => .List ...</wordStack>
+    rule <k> #exec [ BOP:BinStackOp  ] => #gas [ BOP , BOP W0 W1       ] ~> BOP W0 W1       ... </k> <wordStack> ListItem(W0) ListItem(W1) => .List ...</wordStack>
+    rule <k> #exec [ TOP:TernStackOp ] => #gas [ TOP , TOP W0 W1 W2    ] ~> TOP W0 W1 W2    ... </k> <wordStack> ListItem(W0) ListItem(W1) ListItem(W2) => .List ...</wordStack>
+    rule <k> #exec [ QOP:QuadStackOp ] => #gas [ QOP , QOP W0 W1 W2 W3 ] ~> QOP W0 W1 W2 W3 ... </k> <wordStack> ListItem(W0) ListItem(W1) ListItem(W2) ListItem(W3) => .List ...</wordStack>
 ```
 
 `StackOp` is used for opcodes which require a large portion of the stack.
 
 ```k
-    syntax InternalOp ::= StackOp WordStack
- // ---------------------------------------
+    syntax InternalOp ::= StackOp List
+ // ----------------------------------
     rule <k> #exec [ SO:StackOp ] => #gas [ SO , SO WS ] ~> SO WS ... </k> <wordStack> WS </wordStack>
 ```
 
@@ -468,8 +468,8 @@ The `CallOp` opcodes all interpret their second argument as an address.
     syntax InternalOp ::= CallSixOp Int Int     Int Int Int Int
                         | CallOp    Int Int Int Int Int Int Int
  // -----------------------------------------------------------
-    rule <k> #exec [ CSO:CallSixOp ] => #gas [ CSO , CSO W0 W1    W2 W3 W4 W5 ] ~> CSO W0 W1    W2 W3 W4 W5 ... </k> <wordStack> W0 : W1 : W2 : W3 : W4 : W5 : WS      => WS </wordStack>
-    rule <k> #exec [ CO:CallOp     ] => #gas [ CO  , CO  W0 W1 W2 W3 W4 W5 W6 ] ~> CO  W0 W1 W2 W3 W4 W5 W6 ... </k> <wordStack> W0 : W1 : W2 : W3 : W4 : W5 : W6 : WS => WS </wordStack>
+    rule <k> #exec [ CSO:CallSixOp ] => #gas [ CSO , CSO W0 W1    W2 W3 W4 W5 ] ~> CSO W0 W1    W2 W3 W4 W5 ... </k> <wordStack> ListItem(W0) ListItem(W1) ListItem(W2) ListItem(W3) ListItem(W4) ListItem(W5) => .List ...</wordStack>
+    rule <k> #exec [ CO:CallOp     ] => #gas [ CO  , CO  W0 W1 W2 W3 W4 W5 W6 ] ~> CO  W0 W1 W2 W3 W4 W5 W6 ... </k> <wordStack> ListItem(W0) ListItem(W1) ListItem(W2) ListItem(W3) ListItem(W4) ListItem(W5) ListItem(W6) => .List ...</wordStack>
 ```
 
 ### Address Conversion
@@ -481,11 +481,11 @@ We make sure the given arguments (to be interpreted as addresses) are with 160 b
     syntax InternalOp ::= "#addr" "[" OpCode "]"
  // --------------------------------------------
     rule <k> #addr [ OP:OpCode ] => .K ... </k>
-         <wordStack> (W0 => #addr(W0)) : _WS </wordStack>
+         <wordStack> WS => WS [ 0 <- #addr({WS [ 0 ]}:>Int) ] </wordStack>
       requires isAddr1Op(OP)
 
     rule <k> #addr [ OP:OpCode ] => .K ... </k>
-         <wordStack> _W0 : (W1 => #addr(W1)) : _WS </wordStack>
+         <wordStack> WS => WS [ 1 <- #addr({WS [ 1 ]}:>Int) ] </wordStack>
       requires isAddr2Op(OP)
 
     rule <k> #addr [ OP:OpCode ] => .K ... </k>
@@ -756,9 +756,9 @@ These are just used by the other operators for shuffling local execution state a
 -   `#setStack_` will set the current stack to the given one.
 
 ```k
-    syntax InternalOp ::= "#push" | "#setStack" WordStack
- // -----------------------------------------------------
-    rule <k> W0:Int ~> #push => .K ... </k> <wordStack> WS => W0 : WS </wordStack>
+    syntax InternalOp ::= "#push" | "#setStack" List
+ // ------------------------------------------------
+    rule <k> W0:Int ~> #push => .K ... </k> <wordStack> WS => pushList(W0, WS) </wordStack>
     rule <k> #setStack WS    => .K ... </k> <wordStack> _  => WS      </wordStack>
 ```
 
@@ -881,8 +881,8 @@ Some operators don't calculate anything, they just push the stack around a bit.
     syntax StackOp ::= DUP  ( Int ) [symbol(DUP)]
                      | SWAP ( Int ) [symbol(SWAP)]
  // ----------------------------------------------
-    rule <k> DUP(N)  WS:WordStack => #setStack ((WS [ N -Int 1 ]) : WS)                      ... </k>
-    rule <k> SWAP(N) (W0 : WS)    => #setStack ((WS [ N -Int 1 ]) : (WS [ N -Int 1 := W0 ])) ... </k>
+    rule <k> DUP(N)  WS:List => #setStack (pushList(WS [ N -Int 1 ], WS))                      ... </k>
+    rule <k> SWAP(N) (ListItem(W0) WS)    => #setStack (pushList(WS [ N -Int 1 ], (WS [ N -Int 1 <- W0 ]))) ... </k>
 
     syntax PushOp ::= "PUSHZERO"
                     | PUSH ( Int ) [symbol(PUSH)]
@@ -1155,10 +1155,10 @@ These operators query about the current return data buffer.
  // ------------------------------------------
     rule <k> LOG(N) MEMSTART MEMWIDTH => .K ... </k>
          <id> ACCT </id>
-         <wordStack> WS => #drop(N, WS) </wordStack>
+         <wordStack> WS => range(WS, N, 0) </wordStack>
          <localMem> LM </localMem>
-         <log> L => L ListItem({ ACCT | WordStack2List(#take(N, WS)) | #range(LM, MEMSTART, MEMWIDTH) }) </log>
-      requires #sizeWordStack(WS) >=Int N
+         <log> L => L ListItem({ ACCT | range(WS, 0, size(WS) -Int N) | #range(LM, MEMSTART, MEMWIDTH) }) </log>
+      requires size(WS) >=Int N
 ```
 
 Ethereum Network OpCodes
@@ -1387,12 +1387,12 @@ The various `CALL*` (and other inter-contract control flow) operations will be d
 
     syntax KItem ::= "#initVM"
  // --------------------------
-    rule <k> #initVM      => .K ...      </k>
-         <pc>           _ => 0          </pc>
-         <memoryUsed>   _ => 0          </memoryUsed>
-         <output>       _ => .Bytes     </output>
-         <wordStack>    _ => .WordStack </wordStack>
-         <localMem>     _ => .Bytes     </localMem>
+    rule <k> #initVM      => .K ... </k>
+         <pc>           _ => 0      </pc>
+         <memoryUsed>   _ => 0      </memoryUsed>
+         <output>       _ => .Bytes </output>
+         <wordStack>    _ => .List  </wordStack>
+         <localMem>     _ => .Bytes </localMem>
 
     syntax KItem ::= "#loadProgram" Bytes [symbol(loadProgram)]
  // -----------------------------------------------------------
diff --git a/kevm-pyk/src/kevm_pyk/kproj/evm-semantics/optimizations.md b/kevm-pyk/src/kevm_pyk/kproj/evm-semantics/optimizations.md
index 9809c65428..9a3d998de8 100644
--- a/kevm-pyk/src/kevm_pyk/kproj/evm-semantics/optimizations.md
+++ b/kevm-pyk/src/kevm_pyk/kproj/evm-semantics/optimizations.md
@@ -22,7 +22,7 @@ module EVM-OPTIMIZATIONS
         <evm>
           <callState>
             <wordStack>
-              ( WS => 0 : WS )
+              ( WS => pushList(0, WS) )
             </wordStack>
             <pc>
               ( PCOUNT => ( PCOUNT +Int 1 ) )
@@ -39,7 +39,7 @@ module EVM-OPTIMIZATIONS
       ...
     </kevm>
     requires ( Gbase < SCHED > <=Gas GAVAIL )
-     andBool ( #sizeWordStack( WS ) <=Int 1023 )
+     andBool ( size(WS) <=Int 1023 )
      [priority(40)]
 
   rule
@@ -58,7 +58,7 @@ module EVM-OPTIMIZATIONS
               PGM
             </program>
             <wordStack>
-              ( WS => #asWord( #range(PGM, PCOUNT +Int 1, N) ) : WS )
+              ( WS => pushList(#asWord( #range(PGM, PCOUNT +Int 1, N) ), WS) )
             </wordStack>
             <pc>
               ( PCOUNT => ( ( PCOUNT +Int N ) +Int 1 ) )
@@ -75,7 +75,7 @@ module EVM-OPTIMIZATIONS
       ...
     </kevm>
     requires ( Gverylow < SCHED > <=Gas GAVAIL )
-     andBool ( #sizeWordStack( WS ) <=Int 1023 )
+     andBool ( size( WS ) <=Int 1023 )
      [priority(40)]
 
   rule
@@ -91,7 +91,7 @@ module EVM-OPTIMIZATIONS
         <evm>
           <callState>
             <wordStack>
-              ( WS => WS [ ( N +Int -1 ) ] : WS )
+              ( WS => pushList(WS [ ( N +Int -1 ) ], WS) )
             </wordStack>
             <pc>
               ( PCOUNT => ( PCOUNT +Int 1 ) )
@@ -107,9 +107,9 @@ module EVM-OPTIMIZATIONS
       </ethereum>
       ...
     </kevm>
-    requires N <=Int #sizeWordStack(WS)
+    requires #stackNeeded(DUP(N)) <=Int size(WS)
      andBool ( Gverylow < SCHED > <=Gas GAVAIL )
-     andBool ( #sizeWordStack( WS ) <=Int 1023 )
+     andBool ( size( WS ) <=Int 1023 )
      [priority(40)]
 
   rule
@@ -125,7 +125,7 @@ module EVM-OPTIMIZATIONS
         <evm>
           <callState>
             <wordStack>
-              ( W0 : WS => WS [ ( N +Int -1 ) ] : ( WS [ ( N +Int -1 ) := W0 ] ) )
+              ( ListItem(W0) WS => pushList(WS [ ( N +Int -1 ) ], ( WS [ ( N +Int -1 ) <- W0 ] )) )
             </wordStack>
             <pc>
               ( PCOUNT => ( PCOUNT +Int 1 ) )
@@ -141,9 +141,9 @@ module EVM-OPTIMIZATIONS
       </ethereum>
       ...
     </kevm>
-    requires N <=Int #sizeWordStack(W0 : WS)
+    requires #stackNeeded(SWAP(N)) <=Int size(WS) +Int 1
      andBool ( Gverylow < SCHED > <=Gas GAVAIL )
-     andBool ( #sizeWordStack( WS ) <=Int 1023 )
+     andBool ( size( WS ) <=Int 1023 )
      [priority(40)]
 
   rule
@@ -159,7 +159,7 @@ module EVM-OPTIMIZATIONS
         <evm>
           <callState>
             <wordStack>
-              ( W0 : W1 : WS => chop( ( W0 +Int W1 ) ) : WS )
+              ( ListItem(W0) ListItem(W1) WS => pushList(chop( ( W0 +Int W1 ) ), WS) )
             </wordStack>
             <pc>
               ( PCOUNT => ( PCOUNT +Int 1 ) )
@@ -176,7 +176,7 @@ module EVM-OPTIMIZATIONS
       ...
     </kevm>
     requires ( Gverylow < SCHED > <=Gas GAVAIL )
-     andBool ( #sizeWordStack( WS ) <=Int 1023 )
+     andBool ( size( WS ) <=Int 1023 )
      [priority(40)]
 
   rule
@@ -192,7 +192,7 @@ module EVM-OPTIMIZATIONS
         <evm>
           <callState>
             <wordStack>
-              ( W0 : W1 : WS => chop( ( W0 -Int W1 ) ) : WS )
+              ( ListItem(W0) ListItem(W1) WS => pushList(chop( ( W0 -Int W1 ) ), WS) )
             </wordStack>
             <pc>
               ( PCOUNT => ( PCOUNT +Int 1 ) )
@@ -209,7 +209,7 @@ module EVM-OPTIMIZATIONS
       ...
     </kevm>
     requires ( Gverylow < SCHED > <=Gas GAVAIL )
-     andBool (#sizeWordStack( WS ) <=Int 1023 )
+     andBool ( size( WS ) <=Int 1023 )
      [priority(40)]
 
   rule
@@ -225,7 +225,7 @@ module EVM-OPTIMIZATIONS
         <evm>
           <callState>
             <wordStack>
-              ( W0 : W1 : WS => W0 &Int W1 : WS )
+              ( ListItem(W0) ListItem(W1) WS => pushList(W0 &Int W1, WS) )
             </wordStack>
             <pc>
               ( PCOUNT => ( PCOUNT +Int 1 ) )
@@ -242,7 +242,7 @@ module EVM-OPTIMIZATIONS
       ...
     </kevm>
     requires ( Gverylow < SCHED > <=Gas GAVAIL )
-     andBool ( #sizeWordStack( WS ) <=Int 1023 )
+     andBool ( size( WS ) <=Int 1023 )
      [priority(40)]
 
   rule
@@ -258,7 +258,7 @@ module EVM-OPTIMIZATIONS
         <evm>
           <callState>
             <wordStack>
-              ( W0 : W1 : WS => bool2Word( W0 <Int W1 ) : WS )
+              ( ListItem(W0) ListItem(W1) WS => pushList(bool2Word( W0 <Int W1 ), WS) )
             </wordStack>
             <pc>
               ( PCOUNT => ( PCOUNT +Int 1 ) )
@@ -275,7 +275,7 @@ module EVM-OPTIMIZATIONS
       ...
     </kevm>
     requires ( Gverylow < SCHED > <=Gas GAVAIL )
-     andBool (  #sizeWordStack( WS ) <=Int 1023 )
+     andBool ( size( WS ) <=Int 1023 )
      [priority(40)]
 
   rule
@@ -291,7 +291,7 @@ module EVM-OPTIMIZATIONS
         <evm>
           <callState>
             <wordStack>
-              ( W0 : W1 : WS => bool2Word( W1 <Int W0 ) : WS )
+              ( ListItem(W0) ListItem(W1) WS => pushList(bool2Word( W1 <Int W0 ), WS) )
             </wordStack>
             <pc>
               ( PCOUNT => ( PCOUNT +Int 1 ) )
@@ -308,7 +308,7 @@ module EVM-OPTIMIZATIONS
       ...
     </kevm>
     requires ( Gverylow < SCHED > <=Gas GAVAIL )
-     andBool ( #sizeWordStack( WS ) <=Int 1023 )
+     andBool ( size( WS ) <=Int 1023 )
      [priority(40)]
 
 
diff --git a/kevm-pyk/src/kevm_pyk/kproj/evm-semantics/state-utils.md b/kevm-pyk/src/kevm_pyk/kproj/evm-semantics/state-utils.md
index cd0f16c98a..f3e53c7b90 100644
--- a/kevm-pyk/src/kevm_pyk/kproj/evm-semantics/state-utils.md
+++ b/kevm-pyk/src/kevm_pyk/kproj/evm-semantics/state-utils.md
@@ -38,7 +38,7 @@ module STATE-UTILS
          <caller>           _ => .Account   </caller>
          <callData>         _ => .Bytes     </callData>
          <callValue>        _ => 0          </callValue>
-         <wordStack>        _ => .WordStack </wordStack>
+         <wordStack>        _ => .List      </wordStack>
          <localMem>         _ => .Bytes     </localMem>
          <pc>               _ => 0          </pc>
          <gas>              _ => 0          </gas>
diff --git a/tests/failing/ContractCreationSpam_d0g0v0.json.expected b/tests/failing/ContractCreationSpam_d0g0v0.json.expected
index 418ee98613..23cad71b7a 100644
--- a/tests/failing/ContractCreationSpam_d0g0v0.json.expected
+++ b/tests/failing/ContractCreationSpam_d0g0v0.json.expected
@@ -51,7 +51,7 @@
           0
         </callValue>
         <wordStack>
-          .WordStack
+          .List
         </wordStack>
         <localMem>
           b""
diff --git a/tests/failing/static_callcodecallcodecall_110_OOGMAfter_2_d0g0v0.json.expected b/tests/failing/static_callcodecallcodecall_110_OOGMAfter_2_d0g0v0.json.expected
index b738957f30..b8b15865bf 100644
--- a/tests/failing/static_callcodecallcodecall_110_OOGMAfter_2_d0g0v0.json.expected
+++ b/tests/failing/static_callcodecallcodecall_110_OOGMAfter_2_d0g0v0.json.expected
@@ -51,7 +51,7 @@
           0
         </callValue>
         <wordStack>
-          .WordStack
+          .List
         </wordStack>
         <localMem>
           b""
diff --git a/tests/templates/output-success-haskell.json b/tests/templates/output-success-haskell.json
index e40fedeffe..0bd2762086 100644
--- a/tests/templates/output-success-haskell.json
+++ b/tests/templates/output-success-haskell.json
@@ -48,7 +48,7 @@
           0
         </callValue>
         <wordStack>
-          .WordStack
+          .List
         </wordStack>
         <localMem>
           b""
diff --git a/tests/templates/output-success-java.json b/tests/templates/output-success-java.json
deleted file mode 100644
index f01a5ebaa1..0000000000
--- a/tests/templates/output-success-java.json
+++ /dev/null
@@ -1,173 +0,0 @@
-<kevm>
-  <k>
-    .
-  </k>
-  <exit-code>
-    0
-  </exit-code>
-  <mode>
-    SUCCESS
-  </mode>
-  <schedule>
-    HOMESTEAD
-  </schedule>
-  <useGas>
-  true
-  </useGas>
-  <ethereum>
-    <evm>
-      <output>
-        .WordStack
-      </output>
-      <statusCode>
-        .StatusCode
-      </statusCode>
-      <callStack>
-        .List
-      </callStack>
-      <interimStates>
-        .List
-      </interimStates>
-      <touchedAccounts>
-        .Set
-      </touchedAccounts>
-      <callState>
-        <program>
-          .WordStack
-        </program>
-        <jumpDests>
-          .Set
-        </jumpDests>
-        <id>
-          .Account
-        </id>
-        <caller>
-          .Account
-        </caller>
-        <callData>
-          .WordStack
-        </callData>
-        <callValue>
-          0
-        </callValue>
-        <wordStack>
-          .WordStack
-        </wordStack>
-        <localMem>
-          .Map
-        </localMem>
-        <pc>
-          0
-        </pc>
-        <gas>
-          0
-        </gas>
-        <memoryUsed>
-          0
-        </memoryUsed>
-        <callGas>
-          0
-        </callGas>
-        <static>
-          false
-        </static>
-        <callDepth>
-          0
-        </callDepth>
-      </callState>
-      <substate>
-        <selfDestruct>
-          .Set
-        </selfDestruct>
-        <log>
-          .List
-        </log>
-        <refund>
-          0
-        </refund>
-        <accessedAccounts>
-        .Set
-        </accessedAccounts>
-        <accessedStorage>
-          .Map
-        </accessedStorage>
-      </substate>
-      <gasPrice>
-        0
-      </gasPrice>
-      <origin>
-        .Account
-      </origin>
-      <blockhashes>
-        .List
-      </blockhashes>
-      <block>
-        <previousHash>
-          0
-        </previousHash>
-        <ommersHash>
-          0
-        </ommersHash>
-        <coinbase>
-          0
-        </coinbase>
-        <stateRoot>
-          0
-        </stateRoot>
-        <transactionsRoot>
-          0
-        </transactionsRoot>
-        <receiptsRoot>
-          0
-        </receiptsRoot>
-        <logsBloom>
-          .WordStack
-        </logsBloom>
-        <difficulty>
-          0
-        </difficulty>
-        <number>
-          0
-        </number>
-        <gasLimit>
-          0
-        </gasLimit>
-        <gasUsed>
-          0
-        </gasUsed>
-        <timestamp>
-          0
-        </timestamp>
-        <extraData>
-          .WordStack
-        </extraData>
-        <mixHash>
-          0
-        </mixHash>
-        <blockNonce>
-          0
-        </blockNonce>
-        <ommerBlockHeaders>
-          [ .JSONs ]
-        </ommerBlockHeaders>
-      </block>
-    </evm>
-    <network>
-      <chainID>
-        1
-      </chainID>
-      <accounts>
-        .Map
-      </accounts>
-      <txOrder>
-        .List
-      </txOrder>
-      <txPending>
-        .List
-      </txPending>
-      <messages>
-        .Map
-      </messages>
-    </network>
-  </ethereum>
-</kevm>
diff --git a/tests/templates/output-success-llvm.json b/tests/templates/output-success-llvm.json
index 8f79f3d68a..e6e5c37593 100644
--- a/tests/templates/output-success-llvm.json
+++ b/tests/templates/output-success-llvm.json
@@ -48,7 +48,7 @@
           0
         </callValue>
         <wordStack>
-          .WordStack
+          .List
         </wordStack>
         <localMem>
           b""