---input---
(*
   Copyright 2020 Microsoft Research

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
*)

module Steel.Semantics.Hoare.MST

module P = FStar.Preorder

open FStar.Tactics

open NMST


(*
 * This module provides a semantic model for a combined effect of
 * divergence, state, and parallel composition of atomic actions.
 *
 * It is built over a monotonic state effect -- so that we can give
 * lock semantics using monotonicity
 *
 * It also builds a generic separation-logic-style program logic
 * for this effect, in a partial correctness setting.

 * It is also be possible to give a variant of this semantics for
 * total correctness. However, we specifically focus on partial correctness
 * here so that this semantics can be instantiated with lock operations,
 * which may deadlock. See ParTot.fst for a total-correctness variant of
 * these semantics.
 *
 * The program logic is specified in the Hoare-style pre- and postconditions
*)


/// Disabling projectors because we don't use them and they increase the typechecking time

#push-options "--fuel  0 --ifuel 2 --z3rlimit 20 --print_implicits --print_universes \
   --using_facts_from 'Prims FStar.Pervasives FStar.Preorder MST NMST Steel.Semantics.Hoare.MST'"

(**** Begin state defn ****)


/// We start by defining some basic notions for a commutative monoid.
///
/// We could reuse FStar.Algebra.CommMonoid, but this style with
/// quanitifers was more convenient for the proof done here.


let symmetry #a (equals: a -> a -> prop) =
  forall x y. {:pattern (x `equals` y)}
    x `equals` y ==> y `equals` x

let transitive #a (equals:a -> a -> prop) =
  forall x y z. x `equals` y /\ y `equals` z ==> x `equals` z

let associative #a (equals: a -> a -> prop) (f: a -> a -> a)=
  forall x y z.
    f x (f y z) `equals` f (f x y) z

let commutative #a (equals: a -> a -> prop) (f: a -> a -> a) =
  forall x y.{:pattern f x y}
    f x y `equals` f y x

let is_unit #a (x:a) (equals: a -> a -> prop) (f:a -> a -> a) =
  forall y. {:pattern f x y \/ f y x}
    f x y `equals` y /\
    f y x `equals` y

let equals_ext #a (equals:a -> a -> prop) (f:a -> a -> a) =
  forall x1 x2 y. x1 `equals` x2 ==> f x1 y `equals` f x2 y

let fp_heap_0
       (#heap:Type)
       (#hprop:Type)
       (interp:hprop -> heap -> prop)
       (pre:hprop)
    =
  h:heap{interp pre h}

let depends_only_on_0
      (#heap:Type)
      (#hprop:Type)
      (interp:hprop -> heap -> prop)
      (disjoint: heap -> heap -> prop)
      (join: (h0:heap -> h1:heap{disjoint h0 h1} -> heap))
      (q:heap -> prop) (fp: hprop)
    =
  forall (h0:fp_heap_0 interp fp) (h1:heap{disjoint h0 h1}). q h0 <==> q (join h0 h1)

let fp_prop_0
      (#heap:Type)
      (#hprop:Type)
      (interp:hprop -> heap -> prop)
      (disjoint: heap -> heap -> prop)
      (join: (h0:heap -> h1:heap{disjoint h0 h1} -> heap))
      (fp:hprop)
    =
  p:(heap -> prop){p `(depends_only_on_0 interp disjoint join)` fp}

noeq
type st0 = {
  mem:Type u#2;
  core:mem -> mem;

  locks_preorder:P.preorder mem;
  hprop:Type u#2;
  locks_invariant: mem -> hprop;

  disjoint: mem -> mem -> prop;
  join: h0:mem -> h1:mem{disjoint h0 h1} -> mem;

  interp: hprop -> mem -> prop;

  emp:hprop;
  star: hprop -> hprop -> hprop;

  equals: hprop -> hprop -> prop;
}


/// disjointness is symmetric

let disjoint_sym (st:st0) =
  forall h0 h1. st.disjoint h0 h1 <==> st.disjoint h1 h0

let disjoint_join (st:st0) =
  forall m0 m1 m2.
    st.disjoint m1 m2 /\
    st.disjoint m0 (st.join m1 m2) ==>
    st.disjoint m0 m1 /\
    st.disjoint m0 m2 /\
    st.disjoint (st.join m0 m1) m2 /\
    st.disjoint (st.join m0 m2) m1

let join_commutative (st:st0 { disjoint_sym st }) =
  forall m0 m1.
    st.disjoint m0 m1 ==>
    st.join m0 m1 == st.join m1 m0

let join_associative (st:st0{disjoint_join st})=
  forall m0 m1 m2.
    st.disjoint m1 m2 /\
    st.disjoint m0 (st.join m1 m2) ==>
    st.join m0 (st.join m1 m2) == st.join (st.join m0 m1) m2

////////////////////////////////////////////////////////////////////////////////

let interp_extensionality #r #s (equals:r -> r -> prop) (f:r -> s -> prop) =
  forall x y h. {:pattern equals x y; f x h} equals x y /\ f x h ==> f y h

let affine (st:st0) =
  forall r0 r1 s. {:pattern (st.interp (r0 `st.star` r1) s) }
    st.interp (r0 `st.star` r1) s ==> st.interp r0 s

////////////////////////////////////////////////////////////////////////////////

let depends_only_on (#st:st0) (q:st.mem -> prop) (fp: st.hprop) =
  depends_only_on_0 st.interp st.disjoint st.join q fp

let fp_prop (#st:st0) (fp:st.hprop) =
  fp_prop_0 st.interp st.disjoint st.join fp

let lemma_weaken_depends_only_on
      (#st:st0{affine st})
      (fp0 fp1:st.hprop)
      (q:fp_prop fp0)
    : Lemma (q `depends_only_on` (fp0 `st.star` fp1))
    =
  ()

let st_laws (st:st0) =
  (* standard laws about the equality relation *)
  symmetry st.equals /\
  transitive st.equals /\
  interp_extensionality st.equals st.interp /\
  (* standard laws for star forming a CM *)
  associative st.equals st.star /\
  commutative st.equals st.star /\
  is_unit st.emp st.equals st.star /\
  equals_ext st.equals st.star /\
  (* We're working in an affine interpretation of SL *)
  affine st /\
  (* laws about disjoint and join *)
  disjoint_sym st /\
  disjoint_join st /\
  join_commutative st /\
  join_associative st

let st = s:st0 { st_laws s }

(**** End state defn ****)


(**** Begin expects, provides, requires, and ensures defns ****)


/// expects (the heap assertion expected by a computation) is simply an st.hprop
///
/// provides, or the post heap assertion, is a st.hprop on [a]-typed result

type post_t (st:st) (a:Type) = a -> st.hprop


/// requires is a heap predicate that depends only on a pre heap assertion
///   (where the notion of `depends only on` is defined above as part of the state definition)
///
/// we call the type l_pre for logical precondition

let l_pre (#st:st) (pre:st.hprop) = fp_prop pre


/// ensures is a 2-state postcondition of type heap -> a -> heap -> prop
///
/// To define ensures, we need a notion of depends_only_on_2
///
/// Essentially, in the first heap argument, postconditions depend only on the expects hprop
///   and in the second heap argument, postconditions depend only on the provides hprop
///
/// Also note that the support for depends_only_on_2 is not required from the underlying memory model


let depends_only_on_0_2
      (#a:Type)
      (#heap:Type)
      (#hprop:Type)
      (interp:hprop -> heap -> prop)
      (disjoint:heap -> heap -> prop)
      (join:(h0:heap -> h1:heap{disjoint h0 h1} -> heap))
      (q:heap -> a -> heap -> prop) (fp_pre:hprop) (fp_post:a -> hprop)

    = //can join any disjoint heap to the pre-heap and q is still valid
  (forall x (h_pre:fp_heap_0 interp fp_pre) h_post (h:heap{disjoint h_pre h}).
     q h_pre x h_post <==> q (join h_pre h) x h_post) /\
  //can join any disjoint heap to the post-heap and q is still valid
  (forall x h_pre (h_post:fp_heap_0 interp (fp_post x)) (h:heap{disjoint h_post h}).
     q h_pre x h_post <==> q h_pre x (join h_post h))

/// Abbreviations for two-state depends

let fp_prop_0_2
      (#a:Type)
      (#heap #hprop:Type)
      (interp:hprop -> heap -> prop)
      (disjoint:heap -> heap -> prop)
      (join:(h0:heap -> h1:heap{disjoint h0 h1} -> heap))
      (fp_pre:hprop)
      (fp_post:a -> hprop)
    =
  q:(heap -> a -> heap -> prop){depends_only_on_0_2 interp disjoint join q fp_pre fp_post}

let depends_only_on2
      (#st:st0)
      (#a:Type)
      (q:st.mem -> a -> st.mem -> prop)
      (fp_pre:st.hprop)
      (fp_post:a -> st.hprop)
    =
  depends_only_on_0_2 st.interp st.disjoint st.join q fp_pre fp_post

let fp_prop2 (#st:st0) (#a:Type) (fp_pre:st.hprop) (fp_post:a -> st.hprop) =
  q:(st.mem -> a -> st.mem -> prop){depends_only_on2 q fp_pre fp_post}

/// Finally the type of 2-state postconditions

let l_post (#st:st) (#a:Type) (pre:st.hprop) (post:post_t st a) = fp_prop2 pre post


(**** End expects, provides, requires,
      and ensures defns ****)

effect Mst (a:Type) (#st:st) (req:st.mem -> Type0) (ens:st.mem -> a -> st.mem -> Type0) =
  NMSTATE a st.mem st.locks_preorder req ens


(**** Begin interface of actions ****)

/// Actions are essentially state transformers that preserve frames

let preserves_frame (#st:st) (pre post:st.hprop) (m0 m1:st.mem) =
  forall (frame:st.hprop).
    st.interp ((pre `st.star` frame) `st.star` (st.locks_invariant m0)) m0 ==>
    (st.interp ((post `st.star` frame) `st.star` (st.locks_invariant m1)) m1 /\
     (forall (f_frame:fp_prop frame). f_frame (st.core m0) == f_frame (st.core m1)))

let action_t
      (#st:st)
      (#a:Type)
      (pre:st.hprop)
      (post:post_t st a)
      (lpre:l_pre pre)
      (lpost:l_post pre post)
    =
  unit ->
    Mst a
      (requires fun m0 ->
        st.interp (pre `st.star` st.locks_invariant m0) m0 /\
        lpre (st.core m0))
      (ensures fun m0 x m1 ->
        st.interp ((post x) `st.star` st.locks_invariant m1) m1 /\
        lpost (st.core m0) x (st.core m1) /\
        preserves_frame pre (post x) m0 m1)

(**** End interface of actions ****)


(**** Begin definition of the computation AST ****)


/// Gadgets for building lpre- and lpostconditions for various nodes


/// Return node is parametric in provides and ensures

let return_lpre (#st:st) (#a:Type) (#post:post_t st a) (x:a) (lpost:l_post (post x) post)
    : l_pre (post x)
    =
  fun h -> lpost h x h

let frame_lpre (#st:st) (#pre:st.hprop) (lpre:l_pre pre) (#frame:st.hprop) (f_frame:fp_prop frame)
    : l_pre (pre `st.star` frame)
    =
  fun h -> lpre h /\ f_frame h

let frame_lpost
      (#st:st)
      (#a:Type)
      (#pre:st.hprop)
      (#post:post_t st a)
      (lpre:l_pre pre)
      (lpost:l_post pre post)
      (#frame:st.hprop)
      (f_frame:fp_prop frame)
    : l_post (pre `st.star` frame) (fun x -> post x `st.star` frame)
    =
  fun h0 x h1 -> lpre h0 /\ lpost h0 x h1 /\ f_frame h1

/// The bind rule bakes in weakening of requires / ensures

let bind_lpre
      (#st:st)
      (#a:Type)
      (#pre:st.hprop)
      (#post_a:post_t st a)
      (lpre_a:l_pre pre)
      (lpost_a:l_post pre post_a)
      (lpre_b:(x:a -> l_pre (post_a x)))
    : l_pre pre
    =
  fun h -> lpre_a h /\ (forall (x:a) h1. lpost_a h x h1 ==> lpre_b x h1)

let bind_lpost
      (#st:st)
      (#a:Type)
      (#pre:st.hprop)
      (#post_a:post_t st a)
      (lpre_a:l_pre pre)
      (lpost_a:l_post pre post_a)
      (#b:Type)
      (#post_b:post_t st b)
      (lpost_b:(x:a -> l_post (post_a x) post_b))
    : l_post pre post_b
    =
  fun h0 y h2 -> lpre_a h0 /\ (exists x h1. lpost_a h0 x h1 /\ (lpost_b x) h1 y h2)

/// Parallel composition is pointwise

let par_lpre
       (#st:st)
       (#preL:st.hprop)
       (lpreL:l_pre preL)
       (#preR:st.hprop)
       (lpreR:l_pre preR)
    : l_pre (preL `st.star` preR)
    =
  fun h -> lpreL h /\ lpreR h

let par_lpost
      (#st:st)
      (#aL:Type)
      (#preL:st.hprop)
      (#postL:post_t st aL)
      (lpreL:l_pre preL)
      (lpostL:l_post preL postL)
      (#aR:Type)
      (#preR:st.hprop)
      (#postR:post_t st aR)
      (lpreR:l_pre preR)
      (lpostR:l_post preR postR)
    : l_post (preL `st.star` preR) (fun (xL, xR) -> postL xL `st.star` postR xR)
    =
  fun h0 (xL, xR) h1 -> lpreL h0 /\ lpreR h0 /\ lpostL h0 xL h1 /\ lpostR h0 xR h1

let weaker_pre (#st:st) (pre:st.hprop) (next_pre:st.hprop) =
  forall (h:st.mem) (frame:st.hprop).
    st.interp (pre `st.star` frame) h ==>
    st.interp (next_pre `st.star` frame) h

let stronger_post (#st:st) (#a:Type u#a) (post next_post:post_t st a) =
  forall (x:a) (h:st.mem) (frame:st.hprop).
    st.interp (next_post x `st.star` frame) h ==>
    st.interp (post x `st.star` frame) h

let weakening_ok
      (#st:st)
      (#a:Type u#a)
      (#pre:st.hprop)
      (#post:post_t st a)
      (lpre:l_pre pre)
      (lpost:l_post pre post)
      (#wpre:st.hprop)
      (#wpost:post_t st a)
      (wlpre:l_pre wpre)
      (wlpost:l_post wpre wpost)
    =
  weaker_pre wpre pre /\
  stronger_post wpost post /\
  (forall h. wlpre h ==> lpre h) /\
  (forall h0 x h1. lpost h0 x h1 ==> wlpost h0 x h1)


/// Setting the flag just to reduce the time to typecheck the type m

#push-options "--__temp_no_proj Steel.Semantics.Hoare.MST"
noeq
type m (st:st) :
      a:Type u#a ->
      pre:st.hprop ->
      post:post_t st a ->
      l_pre pre ->
      l_post pre post -> Type
    =
  | Ret:
    #a:Type u#a ->
    post:post_t st a ->
    x:a ->
    lpost:l_post (post x) post ->
    m st a (post x) post (return_lpre #_ #_ #post x lpost) lpost

  | Bind:
    #a:Type u#a ->
    #pre:st.hprop ->
    #post_a:post_t st a ->
    #lpre_a:l_pre pre ->
    #lpost_a:l_post pre post_a ->
    #b:Type u#a ->
    #post_b:post_t st b ->
    #lpre_b:(x:a -> l_pre (post_a x)) ->
    #lpost_b:(x:a -> l_post (post_a x) post_b) ->
    f:m st a pre post_a lpre_a lpost_a ->
    g:(x:a -> Dv (m st b (post_a x) post_b (lpre_b x) (lpost_b x))) ->
    m st b pre post_b
      (bind_lpre lpre_a lpost_a lpre_b)
      (bind_lpost lpre_a lpost_a lpost_b)

  | Act:
    #a:Type u#a ->
    #pre:st.hprop ->
    #post:post_t st a ->
    #lpre:l_pre pre ->
    #lpost:l_post pre post ->
    f:action_t #st #a pre post lpre lpost ->
    m st a pre post lpre lpost

  | Frame:
    #a:Type ->
    #pre:st.hprop ->
    #post:post_t st a ->
    #lpre:l_pre pre ->
    #lpost:l_post pre post ->
    f:m st a pre post lpre lpost ->
    frame:st.hprop ->
    f_frame:fp_prop frame ->
    m st a (pre `st.star` frame) (fun x -> post x `st.star` frame)
      (frame_lpre lpre f_frame)
      (frame_lpost lpre lpost f_frame)

  | Par:
    #aL:Type u#a ->
    #preL:st.hprop ->
    #postL:post_t st aL ->
    #lpreL:l_pre preL ->
    #lpostL:l_post preL postL ->
    mL:m st aL preL postL lpreL lpostL ->
    #aR:Type u#a ->
    #preR:st.hprop ->
    #postR:post_t st aR ->
    #lpreR:l_pre preR ->
    #lpostR:l_post preR postR ->
    mR:m st aR preR postR lpreR lpostR ->
    m st (aL & aR) (preL `st.star` preR) (fun (xL, xR) -> postL xL `st.star` postR xR)
      (par_lpre lpreL lpreR)
      (par_lpost lpreL lpostL lpreR lpostR)

  | Weaken:
    #a:Type u#a ->
    #pre:st.hprop ->
    #post:post_t st a ->
    #lpre:l_pre pre ->
    #lpost:l_post pre post ->
    #wpre:st.hprop ->
    #wpost:post_t st a ->
    wlpre:l_pre wpre ->
    wlpost:l_post wpre wpost ->
    _:squash (weakening_ok lpre lpost wlpre wlpost) ->
    m st a pre post lpre lpost ->
    m st a wpre wpost wlpre wlpost
#pop-options

(**** End definition of the computation AST ****)


(**** Stepping relation ****)

/// All steps preserve frames

noeq
type step_result (st:st) (a:Type u#a) =
  | Step:
    next_pre:st.hprop ->
    next_post:post_t st a ->
    lpre:l_pre next_pre ->
    lpost:l_post next_pre next_post ->
    m st a next_pre next_post lpre lpost ->
    step_result st a


(**** Type of the single-step interpreter ****)


/// Interpreter is setup as a Div function from computation trees to computation trees
///
/// While the requires for the Div is standard (that the expects hprop holds and requires is valid),
///   the ensures is interesting
///
/// As the computation evolves, the requires and ensures associated with the computation graph nodes
///   also evolve
/// But they evolve systematically: preconditions become weaker and postconditions become stronger
///
/// Consider { req } c | st { ens }  ~~> { req1 } c1 | st1 { ens1 }
///
/// Then, req st ==> req1 st1  /\
///       (forall x st_final. ens1 st1 x st_final ==> ens st x st_final)


unfold
let step_req
      (#st:st)
      (#a:Type u#a)
      (#pre:st.hprop)
      (#post:post_t st a)
      (#lpre:l_pre pre)
      (#lpost:l_post pre post)
      (f:m st a pre post lpre lpost)
    : st.mem -> Type0
    =
  fun m0 ->
    st.interp (pre `st.star` st.locks_invariant m0) m0 /\
    lpre (st.core m0)

let weaker_lpre
      (#st:st)
      (#pre:st.hprop)
      (lpre:l_pre pre)
      (#next_pre:st.hprop)
      (next_lpre:l_pre next_pre)
      (m0 m1:st.mem)
    =
  lpre (st.core m0) ==> next_lpre (st.core m1)

let stronger_lpost
      (#st:st)
      (#a:Type u#a)
      (#pre:st.hprop)
      (#post:post_t st a)
      (lpost:l_post pre post)
      (#next_pre:st.hprop)
      #next_post
      (next_lpost:l_post next_pre next_post)
      (m0 m1:st.mem)
    =
  forall (x:a) (h_final:st.mem).
    next_lpost (st.core m1) x h_final ==>
    lpost (st.core m0) x h_final

unfold
let step_ens
      (#st:st)
      (#a:Type u#a)
      (#pre:st.hprop)
      (#post:post_t st a)
      (#lpre:l_pre pre)
      (#lpost:l_post pre post)
      (f:m st a pre post lpre lpost)
    : st.mem -> step_result st a -> st.mem -> Type0
    =
  fun m0 r m1 ->
    let Step next_pre next_post next_lpre next_lpost _ = r in
    st.interp (next_pre `st.star` st.locks_invariant m1) m1 /\
    stronger_post post next_post /\
    next_lpre (st.core m1) /\
    preserves_frame pre next_pre m0 m1 /\
    weaker_lpre lpre next_lpre m0 m1 /\
    stronger_lpost lpost next_lpost m0 m1


/// The type of the stepping function

type step_t =
  #st:st ->
  #a:Type u#a ->
  #pre:st.hprop ->
  #post:post_t st a ->
  #lpre:l_pre pre ->
  #lpost:l_post pre post ->
  f:m st a pre post lpre lpost ->
  Mst (step_result st a) (step_req f) (step_ens f)


(**** Auxiliary lemmas ****)

/// Some AC lemmas on `st.star`

let apply_assoc (#st:st) (p q r:st.hprop)
    : Lemma (st.equals (p `st.star` (q `st.star` r)) ((p `st.star` q) `st.star` r))
    =
  ()

let equals_ext_left (#st:st) (p q r:st.hprop)
    : Lemma
      (requires p `st.equals` q)
      (ensures (p `st.star` r) `st.equals` (q `st.star` r))
    =
  ()

let equals_ext_right (#st:st) (p q r:st.hprop)
    : Lemma
      (requires q `st.equals` r)
      (ensures (p `st.star` q) `st.equals` (p `st.star` r))
    =
  calc (st.equals) {
    p `st.star` q;
       (st.equals) { }
    q `st.star` p;
       (st.equals) { }
    r `st.star` p;
       (st.equals) { }
    p `st.star` r;
  }

let commute_star_right (#st:st) (p q r:st.hprop)
    : Lemma
      ((p `st.star` (q `st.star` r)) `st.equals`
        (p `st.star` (r `st.star` q)))
    =
  calc (st.equals) {
    p `st.star` (q `st.star` r);
       (st.equals) { equals_ext_right p (q `st.star` r) (r `st.star` q) }
    p `st.star` (r `st.star` q);
  }

let assoc_star_right (#st:st) (p q r s:st.hprop)
    : Lemma
      ((p `st.star` ((q `st.star` r) `st.star` s)) `st.equals`
        (p `st.star` (q `st.star` (r `st.star` s))))
    =
  calc (st.equals) {
    p `st.star` ((q `st.star` r) `st.star` s);
       (st.equals) { equals_ext_right p ((q `st.star` r) `st.star` s)
                                        (q `st.star` (r `st.star` s)) }
    p `st.star` (q `st.star` (r `st.star` s));
  }

let commute_assoc_star_right (#st:st) (p q r s:st.hprop)
    : Lemma
      ((p `st.star` ((q `st.star` r) `st.star` s)) `st.equals`
        (p `st.star` (r `st.star` (q `st.star` s))))
    =
  calc (st.equals) {
    p `st.star` ((q `st.star` r) `st.star` s);
       (st.equals) { equals_ext_right p
                       ((q `st.star` r) `st.star` s)
                       ((r `st.star` q) `st.star` s) }
    p `st.star` ((r `st.star` q) `st.star` s);
       (st.equals) { assoc_star_right p r q s }
    p `st.star` (r `st.star` (q `st.star` s));
  }


/// Apply extensionality manually, control proofs

let apply_interp_ext (#st:st) (p q:st.hprop) (m:st.mem)
    : Lemma
      (requires (st.interp p m /\ p `st.equals` q))
      (ensures st.interp q m)
    =
  ()

let weaken_fp_prop (#st:st) (frame frame':st.hprop) (m0 m1:st.mem)
    : Lemma
      (requires
        forall (f_frame:fp_prop (frame `st.star` frame')).
          f_frame (st.core m0) == f_frame (st.core m1))
     (ensures
       forall (f_frame:fp_prop frame').
         f_frame (st.core m0) == f_frame (st.core m1))
    =
  ()

let depends_only_on_commutes_with_weaker
      (#st:st)
      (q:st.mem -> prop)
      (fp:st.hprop)
      (fp_next:st.hprop)
    : Lemma
      (requires depends_only_on q fp /\ weaker_pre fp_next fp)
      (ensures depends_only_on q fp_next)
    =
  assert (forall (h0:fp_heap_0 st.interp fp_next). st.interp (fp_next `st.star` st.emp) h0)

let depends_only_on2_commutes_with_weaker
      (#st:st)
      (#a:Type)
      (q:st.mem -> a -> st.mem -> prop)
      (fp:st.hprop)
      (fp_next:st.hprop)
      (fp_post:a -> st.hprop)
    : Lemma
      (requires depends_only_on2 q fp fp_post /\ weaker_pre fp_next fp)
      (ensures depends_only_on2 q fp_next fp_post)
    =
  assert (forall (h0:fp_heap_0 st.interp fp_next). st.interp (fp_next `st.star` st.emp) h0)

/// Lemmas about preserves_frame

let preserves_frame_trans
      (#st:st)
      (hp1 hp2 hp3:st.hprop)
      (m1 m2 m3:st.mem)
    : Lemma
      (requires preserves_frame hp1 hp2 m1 m2 /\ preserves_frame hp2 hp3 m2 m3)
      (ensures preserves_frame hp1 hp3 m1 m3)
    =
  ()

#push-options "--warn_error -271"
let preserves_frame_stronger_post
      (#st:st)
      (#a:Type)
      (pre:st.hprop)
      (post post_s:post_t st a)
      (x:a)
      (m1 m2:st.mem)
    : Lemma
      (requires preserves_frame pre (post_s x) m1 m2 /\ stronger_post post post_s)
      (ensures preserves_frame pre (post x) m1 m2)
    =
  let aux (frame:st.hprop)
      : Lemma
        (requires st.interp (st.locks_invariant m1 `st.star` (pre `st.star` frame)) m1)
        (ensures
          st.interp (st.locks_invariant m2 `st.star` (post x `st.star` frame)) m2 /\
          (forall (f_frame:fp_prop frame). f_frame (st.core m1) == f_frame (st.core m2)))
        [SMTPat ()]
      =
    assert (st.interp (st.locks_invariant m2 `st.star` (post_s x `st.star` frame)) m2);
    calc (st.equals) {
      st.locks_invariant m2 `st.star` (post_s x `st.star` frame);
         (st.equals) { }
      (st.locks_invariant m2 `st.star` post_s x) `st.star` frame;
         (st.equals) { }
      (post_s x `st.star` st.locks_invariant m2) `st.star` frame;
         (st.equals) { }
     post_s x `st.star` (st.locks_invariant m2 `st.star` frame);
    };
    assert (st.interp (post_s x `st.star` (st.locks_invariant m2 `st.star` frame)) m2);
    assert (st.interp (post x `st.star` (st.locks_invariant m2 `st.star` frame)) m2);
    calc (st.equals) {
      post x `st.star` (st.locks_invariant m2 `st.star` frame);
         (st.equals) { }
      (post x `st.star` st.locks_invariant m2) `st.star` frame;
         (st.equals) { }
      (st.locks_invariant m2 `st.star` post x) `st.star` frame;
         (st.equals) { apply_assoc (st.locks_invariant m2) (post x) frame }
      st.locks_invariant m2 `st.star` (post x `st.star` frame);
      };
    assert (st.interp (st.locks_invariant m2 `st.star` (post x `st.star` frame)) m2)
  in
  ()
#pop-options

#push-options "--z3rlimit 40 --warn_error -271"
let preserves_frame_star (#st:st) (pre post:st.hprop) (m0 m1:st.mem) (frame:st.hprop)
    : Lemma
      (requires preserves_frame pre post m0 m1)
      (ensures preserves_frame (pre `st.star` frame) (post `st.star` frame) m0 m1)
    =
  let aux (frame':st.hprop)
      : Lemma
        (requires
          st.interp (st.locks_invariant m0 `st.star` ((pre `st.star` frame) `st.star` frame')) m0)
        (ensures
          st.interp (st.locks_invariant m1 `st.star`
            ((post `st.star` frame) `st.star` frame')) m1 /\
          (forall (f_frame:fp_prop frame'). f_frame (st.core m0) == f_frame (st.core m1)))
        [SMTPat ()]
      =
    assoc_star_right (st.locks_invariant m0) pre frame frame';
    apply_interp_ext
      (st.locks_invariant m0 `st.star` ((pre `st.star` frame) `st.star` frame'))
      (st.locks_invariant m0 `st.star` (pre `st.star` (frame `st.star` frame')))
      m0;
    assoc_star_right (st.locks_invariant m1) post frame frame';
    apply_interp_ext
      (st.locks_invariant m1 `st.star` (post `st.star` (frame `st.star` frame')))
      (st.locks_invariant m1 `st.star` ((post `st.star` frame) `st.star` frame'))
      m1;
    weaken_fp_prop frame frame' m0 m1
  in
  ()

let preserves_frame_star_left (#st:st) (pre post:st.hprop) (m0 m1:st.mem) (frame:st.hprop)
    : Lemma
      (requires preserves_frame pre post m0 m1)
      (ensures preserves_frame (frame `st.star` pre) (frame `st.star` post) m0 m1)
    =
  let aux (frame':st.hprop)
      : Lemma
        (requires
          st.interp (st.locks_invariant m0 `st.star` ((frame `st.star` pre) `st.star` frame')) m0)
        (ensures
          st.interp (st.locks_invariant m1 `st.star`
            ((frame `st.star` post) `st.star` frame')) m1 /\
          (forall (f_frame:fp_prop frame'). f_frame (st.core m0) == f_frame (st.core m1)))
        [SMTPat ()]
      =
    commute_assoc_star_right (st.locks_invariant m0) frame pre frame';
    apply_interp_ext
      (st.locks_invariant m0 `st.star` ((frame `st.star` pre) `st.star` frame'))
      (st.locks_invariant m0 `st.star` (pre `st.star` (frame `st.star` frame')))
      m0;
    commute_assoc_star_right (st.locks_invariant m1) frame post frame';
    apply_interp_ext
      (st.locks_invariant m1 `st.star` (post `st.star` (frame `st.star` frame')))
      (st.locks_invariant m1 `st.star` ((frame `st.star` post) `st.star` frame'))
      m1;
    weaken_fp_prop frame frame' m0 m1
  in
  ()
#pop-options


/// Lemma frame_post_for_par is used in the par proof
///
/// E.g. in the par rule, when L takes a step, we can frame the requires of R
///   by using the preserves_frame property of the stepping relation
///
/// However we also need to frame the ensures of R, for establishing stronger_post
///
/// Basically, we need:
///
/// forall x h_final. postR prev_state x h_final <==> postR next_state x h_final
///
/// (the proof only requires the reverse implication, but we can prove iff)
///
/// To prove this, we rely on the framing of all frame fp props provides by the stepping relation
///
/// To use it, we instantiate the fp prop with inst_heap_prop_for_par

let inst_heap_prop_for_par
      (#st:st)
      (#a:Type)
      (#pre:st.hprop)
      (#post:post_t st a)
      (lpost:l_post pre post)
      (state:st.mem)
    : fp_prop pre
    =
  fun h ->
    forall x final_state.
      lpost h x final_state <==>
      lpost (st.core state) x final_state

let frame_post_for_par_tautology
      (#st:st)
      (#a:Type)
      (#pre_f:st.hprop)
      (#post_f:post_t st a)
      (lpost_f:l_post pre_f post_f)
      (m0:st.mem)
    : Lemma (inst_heap_prop_for_par lpost_f m0 (st.core m0))
    =
  ()

let frame_post_for_par_aux
      (#st:st)
      (pre_s post_s:st.hprop) (m0 m1:st.mem)
      (#a:Type) (#pre_f:st.hprop) (#post_f:post_t st a) (lpost_f:l_post pre_f post_f)
    : Lemma
      (requires
        preserves_frame pre_s post_s m0 m1 /\
        st.interp ((pre_s `st.star` pre_f) `st.star` st.locks_invariant m0) m0)
      (ensures
        inst_heap_prop_for_par lpost_f m0 (st.core m0) <==>
        inst_heap_prop_for_par lpost_f m0 (st.core m1))
    =
  ()

let frame_post_for_par
      (#st:st)
      (pre_s post_s:st.hprop)
      (m0 m1:st.mem)
      (#a:Type)
      (#pre_f:st.hprop)
      (#post_f:post_t st a)
      (lpre_f:l_pre pre_f)
      (lpost_f:l_post pre_f post_f)
    : Lemma
      (requires
        preserves_frame pre_s post_s m0 m1 /\
        st.interp ((pre_s `st.star` pre_f) `st.star` st.locks_invariant m0) m0)
      (ensures
        (lpre_f (st.core m0) <==> lpre_f (st.core m1)) /\
        (forall (x:a) (final_state:st.mem).
          lpost_f (st.core m0) x final_state <==>
          lpost_f (st.core m1) x final_state))
    =
  frame_post_for_par_tautology lpost_f m0;
  frame_post_for_par_aux pre_s post_s m0 m1 lpost_f

/// Finally lemmas for proving that in the par rules preconditions get weaker
///   and postconditions get stronger

let par_weaker_lpre_and_stronger_lpost_l
      (#st:st)
      (#preL:st.hprop)
      (lpreL:l_pre preL)
      (#aL:Type)
      (#postL:post_t st aL)
      (lpostL:l_post preL postL)
      (#next_preL:st.hprop)
      (#next_postL:post_t st aL)
      (next_lpreL:l_pre next_preL)
      (next_lpostL:l_post next_preL next_postL)
      (#preR:st.hprop)
      (lpreR:l_pre preR)
      (#aR:Type)
      (#postR:post_t st aR)
      (lpostR:l_post preR postR)
      (state next_state:st.mem)
    : Lemma
      (requires
        weaker_lpre lpreL next_lpreL state next_state /\
        stronger_lpost lpostL next_lpostL state next_state /\
        preserves_frame preL next_preL state next_state /\
        lpreL (st.core state) /\
        lpreR (st.core state) /\
        st.interp ((preL `st.star` preR) `st.star` st.locks_invariant state) state)
      (ensures
        weaker_lpre
          (par_lpre lpreL lpreR)
          (par_lpre next_lpreL lpreR)
          state next_state /\
        stronger_lpost
          (par_lpost lpreL lpostL lpreR lpostR)
          (par_lpost next_lpreL next_lpostL lpreR lpostR)
          state next_state)
    =
  frame_post_for_par preL next_preL state next_state lpreR lpostR;
  assert (weaker_lpre (par_lpre lpreL lpreR) (par_lpre next_lpreL lpreR) state next_state) by
    (norm [delta_only [`%weaker_lpre; `%par_lpre] ])

let par_weaker_lpre_and_stronger_lpost_r
      (#st:st)
      (#preL:st.hprop)
      (lpreL:l_pre preL)
      (#aL:Type)
      (#postL:post_t st aL)
      (lpostL:l_post preL postL)
      (#preR:st.hprop)
      (lpreR:l_pre preR)
      (#aR:Type)
      (#postR:post_t st aR)
      (lpostR:l_post preR postR)
      (#next_preR:st.hprop)
      (#next_postR:post_t st aR)
      (next_lpreR:l_pre next_preR)
      (next_lpostR:l_post next_preR next_postR)
      (state next_state:st.mem)
    : Lemma
      (requires
        weaker_lpre lpreR next_lpreR state next_state /\
        stronger_lpost lpostR next_lpostR state next_state /\
        preserves_frame preR next_preR state next_state /\
        lpreR (st.core state) /\
        lpreL (st.core state) /\
        st.interp ((preL `st.star` preR) `st.star` st.locks_invariant state) state)
      (ensures
        st.interp ((preL `st.star` next_preR) `st.star` st.locks_invariant next_state) next_state /\
        weaker_lpre
          (par_lpre lpreL lpreR)
          (par_lpre lpreL next_lpreR)
          state next_state /\
        stronger_lpost
          (par_lpost lpreL lpostL lpreR lpostR)
          (par_lpost lpreL lpostL next_lpreR next_lpostR)
        state next_state)
    =
  commute_star_right (st.locks_invariant state) preL preR;
  apply_interp_ext
    (st.locks_invariant state `st.star` (preL `st.star` preR))
    (st.locks_invariant state `st.star` (preR `st.star` preL))
    state;
  frame_post_for_par preR next_preR state next_state lpreL lpostL;
  assert (weaker_lpre (par_lpre lpreL lpreR) (par_lpre lpreL next_lpreR) state next_state) by
    (norm [delta_only [`%weaker_lpre; `%par_lpre] ]);
  commute_star_right (st.locks_invariant next_state) next_preR preL;
  apply_interp_ext
    (st.locks_invariant next_state `st.star` (next_preR `st.star` preL))
    (st.locks_invariant next_state `st.star` (preL `st.star` next_preR))
    next_state

#push-options "--warn_error -271"
let stronger_post_par_r
      (#st:st)
      (#aL #aR:Type u#a)
      (postL:post_t st aL)
      (postR:post_t st aR)
      (next_postR:post_t st aR)
    : Lemma
      (requires stronger_post postR next_postR)
      (ensures
        forall xL xR frame h.
          st.interp ((postL xL `st.star` next_postR xR) `st.star` frame) h ==>
          st.interp ((postL xL `st.star` postR xR) `st.star` frame) h)
    =
  let aux xL xR frame h
      : Lemma
        (requires st.interp ((postL xL `st.star` next_postR xR) `st.star` frame) h)
        (ensures st.interp ((postL xL `st.star` postR xR) `st.star` frame) h)
        [SMTPat ()]
      =
    calc (st.equals) {
      (postL xL `st.star` next_postR xR) `st.star` frame;
         (st.equals) { }
      (next_postR xR `st.star` postL xL) `st.star` frame;
         (st.equals) { }
      next_postR xR `st.star` (postL xL `st.star` frame);
    };
    assert (st.interp (next_postR xR `st.star` (postL xL `st.star` frame)) h);
    assert (st.interp (postR xR `st.star` (postL xL `st.star` frame)) h);
    calc (st.equals) {
      postR xR `st.star` (postL xL `st.star` frame);
         (st.equals) { }
      (postR xR `st.star` postL xL) `st.star` frame;
         (st.equals) { }
      (postL xL `st.star` postR xR) `st.star` frame;
    }
  in
  ()
#pop-options


(**** Begin stepping functions ****)

let step_ret
      (#st:st)
      (#a:Type u#a)
      (#pre:st.hprop)
      (#post:post_t st a)
      (#lpre:l_pre pre)
      (#lpost:l_post pre post)
      (f:m st a pre post lpre lpost{Ret? f})
    : Mst (step_result st a) (step_req f) (step_ens f)
    =
  NMSTATE?.reflect (fun (_, n) ->
    let Ret p x lp = f in
    Step (p x) p lpre lpost f, n)

let lpost_ret_act
      (#st:st)
      (#a:Type)
      (#pre:st.hprop)
      (#post:post_t st a)
      (lpost:l_post pre post)
      (x:a)
      (state:st.mem)
    : l_post (post x) post
    =
  fun _ x h1 -> lpost (st.core state) x h1

let step_act
      (#st:st)
      (#a:Type u#a)
      (#pre:st.hprop)
      (#post:post_t st a)
      (#lpre:l_pre pre)
      (#lpost:l_post pre post)
      (f:m st a pre post lpre lpost{Act? f})
    : Mst (step_result st a) (step_req f) (step_ens f)
    =
  let m0 = get () in

  let Act #_ #_ #_ #_ #_ #_ f = f in

  let x = f () in

  let lpost : l_post (post x) post = lpost_ret_act lpost x m0 in

  Step (post x) post (fun h -> lpost h x h) lpost (Ret post x lpost)

module M = MST

let step_bind_ret_aux
      (#st:st)
      (#a:Type)
      (#pre:st.hprop)
      (#post:post_t st a)
      (#lpre:l_pre pre)
      (#lpost:l_post pre post)
      (f:m st a pre post lpre lpost{Bind? f /\ Ret? (Bind?.f f)})
    : M.MSTATE (step_result st a) st.mem st.locks_preorder (step_req f) (step_ens f)
    =
  M.MSTATE?.reflect (fun m0 ->
    match f with
    | Bind #_ #_ #_ #_ #_ #_ #_ #post_b #lpre_b #lpost_b (Ret p x _) g ->
      Step (p x) post_b (lpre_b x) (lpost_b x) (g x), m0)

let step_bind_ret
      (#st:st)
      (#a:Type)
      (#pre:st.hprop)
      (#post:post_t st a)
      (#lpre:l_pre pre)
      (#lpost:l_post pre post)
      (f:m st a pre post lpre lpost{Bind? f /\ Ret? (Bind?.f f)})
    : Mst (step_result st a) (step_req f) (step_ens f)
    =
  NMSTATE?.reflect (fun (_, n) -> step_bind_ret_aux f, n)


#push-options "--z3rlimit 40"
let step_bind
      (#st:st)
      (#a:Type)
      (#pre:st.hprop)
      (#post:post_t st a)
      (#lpre:l_pre pre)
      (#lpost:l_post pre post)
      (f:m st a pre post lpre lpost{Bind? f})
      (step:step_t)
    : Mst (step_result st a) (step_req f) (step_ens f)
    =
  match f with
  | Bind (Ret _ _ _) _ -> step_bind_ret f

  | Bind #_ #b #_ #post_a #_ #_ #_ #post_b #lpre_b #lpost_b f g ->
    let Step next_pre next_post next_lpre next_lpost f = step f in

    let lpre_b : (x:b -> l_pre (next_post x)) =
      fun x ->
      depends_only_on_commutes_with_weaker (lpre_b x) (post_a x) (next_post x);
      lpre_b x in

    let lpost_b : (x:b -> l_post (next_post x) post_b) =
      fun x ->
      depends_only_on2_commutes_with_weaker (lpost_b x) (post_a x) (next_post x) post_b;
      lpost_b x in

    let g : (x:b -> Dv (m st _ (next_post x) post_b (lpre_b x) (lpost_b x))) =
      fun x ->
      Weaken (lpre_b x) (lpost_b x) () (g x) in

    let m1 = get () in

    assert ((bind_lpre next_lpre next_lpost lpre_b) (st.core m1))
      by norm ([delta_only [`%bind_lpre]]);

    Step next_pre post_b
      (bind_lpre next_lpre next_lpost lpre_b)
      (bind_lpost next_lpre next_lpost lpost_b)
      (Bind f g)
#pop-options

let step_frame_ret_aux
      (#st:st)
      (#a:Type)
      (#pre:st.hprop)
      (#p:post_t st a)
      (#lpre:l_pre pre)
      (#lpost:l_post pre p)
      (f:m st a pre p lpre lpost{Frame? f /\ Ret? (Frame?.f f)})
    : M.MSTATE (step_result st a) st.mem st.locks_preorder (step_req f) (step_ens f)
    =
  M.MSTATE?.reflect (fun m0 ->
    match f with
    | Frame (Ret p x lp) frame f_frame ->
      Step (p x `st.star` frame) (fun x -> p x `st.star` frame)
        (fun h -> lpost h x h)
        lpost
        (Ret (fun x -> p x `st.star` frame) x lpost), m0)

let step_frame_ret
      (#st:st)
      (#a:Type)
      (#pre:st.hprop)
      (#p:post_t st a)
      (#lpre:l_pre pre)
      (#lpost:l_post pre p)
      (f:m st a pre p lpre lpost{Frame? f /\ Ret? (Frame?.f f)})
    : Mst (step_result st a) (step_req f) (step_ens f)
    =
  NMSTATE?.reflect (fun (_, n) -> step_frame_ret_aux f, n)

let step_frame
      (#st:st)
      (#a:Type)
      (#pre:st.hprop)
      (#p:post_t st a)
      (#lpre:l_pre pre)
      (#lpost:l_post pre p)
      (f:m st a pre p lpre lpost{Frame? f})
      (step:step_t)
    : Mst (step_result st a) (step_req f) (step_ens f)
    =
  match f with
  | Frame (Ret p x lp) frame f_frame -> step_frame_ret f

  | Frame #_ #_ #f_pre #_ #_ #_ f frame f_frame ->
    let m0 = get () in

    let Step next_fpre next_fpost next_flpre next_flpost f = step f in

    let m1 = get () in

    preserves_frame_star f_pre next_fpre m0 m1 frame;

    assert ((frame_lpre next_flpre f_frame) (st.core m1))
      by (norm [delta_only [`%frame_lpre]]);

    Step (next_fpre `st.star` frame) (fun x -> next_fpost x `st.star` frame)
      (frame_lpre next_flpre f_frame)
      (frame_lpost next_flpre next_flpost f_frame)
      (Frame f frame f_frame)

let step_par_ret_aux
      (#st:st)
      (#a:Type)
      (#pre:st.hprop)
      (#post:post_t st a)
      (#lpre:l_pre pre)
      (#lpost:l_post pre post)
      (f:m st a pre post lpre lpost{Par? f /\ Ret? (Par?.mL f) /\ Ret? (Par?.mR f)})
    : M.MSTATE (step_result st a) st.mem st.locks_preorder (step_req f) (step_ens f)
    =
  M.MSTATE?.reflect (fun m0 ->
    match f with
    | Par #_ #aL #_ #_ #_ #_ (Ret pL xL lpL) #aR #_ #_ #_ #_ (Ret pR xR lpR) ->
      let lpost : l_post
        #st #(aL & aR)
        (pL xL `st.star` pR xR)
        (fun (xL, xR) -> pL xL `st.star` pR xR)
      =
        fun h0 (xL, xR) h1 -> lpL h0 xL h1 /\ lpR h0 xR h1
      in
      Step (pL xL `st.star` pR xR) (fun (xL, xR) -> pL xL `st.star` pR xR)
        (fun h -> lpL h xL h /\ lpR h xR h)
        lpost
        (Ret (fun (xL, xR) -> pL xL `st.star` pR xR) (xL, xR) lpost), m0)

let step_par_ret
      (#st:st)
      (#a:Type)
      (#pre:st.hprop)
      (#post:post_t st a)
      (#lpre:l_pre pre)
      (#lpost:l_post pre post)
      (f:m st a pre post lpre lpost{Par? f /\ Ret? (Par?.mL f) /\ Ret? (Par?.mR f)})
    : Mst (step_result st a) (step_req f) (step_ens f)
    =
  NMSTATE?.reflect (fun (_, n) -> step_par_ret_aux f, n)

let step_par
      (#st:st)
      (#a:Type)
      (#pre:st.hprop)
      (#post:post_t st a)
      (#lpre:l_pre pre)
      (#lpost:l_post pre post)
      (f:m st a pre post lpre lpost{Par? f})
      (step:step_t)
    : Mst (step_result st a) (step_req f) (step_ens f)
    =
  match f with
  | Par (Ret _ _ _) (Ret _ _ _) -> step_par_ret f

  | Par #_ #aL #preL #postL #lpreL #lpostL mL #aR #preR #postR #lpreR #lpostR mR ->
    let b = sample () in

    if b then begin
      let m0 = get () in

      let Step next_preL next_postL next_lpreL next_lpostL mL = step mL in

      let m1 = get () in

      preserves_frame_star preL next_preL m0 m1 preR;
      par_weaker_lpre_and_stronger_lpost_l lpreL lpostL next_lpreL next_lpostL lpreR lpostR m0 m1;

      let next_post = (fun (xL, xR) -> next_postL xL `st.star` postR xR) in

      assert (stronger_post post next_post) by (norm [delta_only [`%stronger_post]]);

      Step (next_preL `st.star` preR) next_post
        (par_lpre next_lpreL lpreR)
        (par_lpost next_lpreL next_lpostL lpreR lpostR)
        (Par mL mR)

    end
    else begin
      let m0 = get () in

      let Step next_preR next_postR next_lpreR next_lpostR mR = step mR in

      let m1 = get () in

      preserves_frame_star_left preR next_preR m0 m1 preL;
      par_weaker_lpre_and_stronger_lpost_r lpreL lpostL lpreR lpostR next_lpreR next_lpostR m0 m1;

      let next_post = (fun (xL, xR) -> postL xL `st.star` next_postR xR) in

      stronger_post_par_r postL postR next_postR;

      Step (preL `st.star` next_preR) next_post
        (par_lpre lpreL next_lpreR)
        (par_lpost lpreL lpostL next_lpreR next_lpostR)
        (Par mL mR)
    end

let step_weaken
      (#st:st)
      (#a:Type u#a)
      (#pre:st.hprop)
      (#post:post_t st a)
      (#lpre:l_pre pre)
      (#lpost:l_post pre post)
      (f:m st a pre post lpre lpost{Weaken? f})
    : Mst (step_result st a) (step_req f) (step_ens f)
    =
  NMSTATE?.reflect (fun (_, n) ->
    let Weaken #_ #_ #pre #post #lpre #lpost #_ #_ #_ #_ #_ f = f in

    Step pre post lpre lpost f, n)

/// Step function

let rec step
      (#st:st)
      (#a:Type u#a)
      (#pre:st.hprop)
      (#post:post_t st a)
      (#lpre:l_pre pre)
      (#lpost:l_post pre post)
      (f:m st a pre post lpre lpost)
    : Mst (step_result st a)
      (step_req f)
      (step_ens f)
    =
  match f with
  | Ret _ _ _ -> step_ret f
  | Bind _ _ -> step_bind f step
  | Act _ -> step_act f
  | Frame _ _ _ -> step_frame f step
  | Par _ _ -> step_par f step
  | Weaken _ _ _ _ -> step_weaken f

let rec run
      (#st:st)
      (#a:Type u#a)
      (#pre:st.hprop)
      (#post:post_t st a)
      (#lpre:l_pre pre)
      (#lpost:l_post pre post)
      (f:m st a pre post lpre lpost)
    : Mst a
      (requires fun m0 ->
        st.interp (pre `st.star` st.locks_invariant m0) m0 /\
        lpre (st.core m0))
      (ensures fun m0 x m1 ->
        st.interp (post x `st.star` st.locks_invariant m1) m1 /\
        lpost (st.core m0) x (st.core m1) /\
        preserves_frame pre (post x) m0 m1)
    =
  match f with
  | Ret _ x _ -> x

  | _ ->
    let m0 = get () in
    let Step new_pre new_post _ _ f = step f in
    let m1 = get () in
    let x = run f in
    let m2 = get () in

    preserves_frame_trans pre new_pre (new_post x) m0 m1 m2;
    preserves_frame_stronger_post pre post new_post x m0 m2;
    x

---tokens---
'(*'          Comment
'\n   Copyright 2020 Microsoft Research\n\n   Licensed under the Apache License, Version 2.0 ' Comment
'('           Comment
'the "License"' Comment
')'           Comment
';\n   you may not use this file except in compliance with the License.\n   You may obtain a copy of the License at\n\n       http://www.apache.org/licenses/LICENSE-2.0\n\n   Unless required by applicable law or agreed to in writing, software\n   distributed under the License is distributed on an "AS IS" BASIS,\n   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n   See the License for the specific language governing permissions and\n   limitations under the License.\n' Comment

'*)'          Comment
'\n\n'        Text

'module'      Keyword
' '           Text
'Steel'       Name.Namespace
'.'           Punctuation
'Semantics'   Name.Namespace
'.'           Punctuation
'Hoare'       Name.Namespace
'.'           Punctuation
'MST'         Name.Class
'\n\n'        Text

'module'      Keyword
' '           Text
'P'           Name.Class
' '           Text
'='           Operator
' '           Text
'FStar'       Name.Namespace
'.'           Punctuation
'Preorder'    Name.Class
'\n\n'        Text

'open'        Keyword
' '           Text
'FStar'       Name.Namespace
'.'           Punctuation
'Tactics'     Name.Class
'\n\n'        Text

'open'        Keyword
' '           Text
'NMST'        Name.Class
'\n\n\n'      Text

'(*'          Comment
'\n '         Comment
'*'           Comment
' This module provides a semantic model for a combined effect of\n ' Comment
'*'           Comment
' divergence, state, and parallel composition of atomic actions.\n ' Comment
'*'           Comment
'\n '         Comment
'*'           Comment
' It is built over a monotonic state effect -- so that we can give\n ' Comment
'*'           Comment
' lock semantics using monotonicity\n ' Comment
'*'           Comment
'\n '         Comment
'*'           Comment
' It also builds a generic separation-logic-style program logic\n ' Comment
'*'           Comment
' for this effect, in a partial correctness setting.\n\n ' Comment
'*'           Comment
' It is also be possible to give a variant of this semantics for\n ' Comment
'*'           Comment
' total correctness. However, we specifically focus on partial correctness\n ' Comment
'*'           Comment
' here so that this semantics can be instantiated with lock operations,\n ' Comment
'*'           Comment
' which may deadlock. See ParTot.fst for a total-correctness variant of\n ' Comment
'*'           Comment
' these semantics.\n ' Comment
'*'           Comment
'\n '         Comment
'*'           Comment
' The program logic is specified in the Hoare-style pre- and postconditions\n' Comment

'*)'          Comment
'\n\n\n'      Text

"/// Disabling projectors because we don't use them and they increase the typechecking time" Comment
'\n\n'        Text

'#'           Operator
'push'        Name
'-'           Operator
'options'     Name
' '           Text
'"'           Literal.String.Double
'--fuel  0 --ifuel 2 --z3rlimit 20 --print_implicits --print_universes ' Literal.String.Double
'\\\n'        Literal.String.Double

"   --using_facts_from 'Prims FStar.Pervasives FStar.Preorder MST NMST Steel.Semantics.Hoare.MST'" Literal.String.Double
'"'           Literal.String.Double
'\n\n'        Text

'(*'          Comment
'*'           Comment
'*'           Comment
'*'           Comment
' Begin state defn ' Comment
'*'           Comment
'*'           Comment
'*'           Comment
'*)'          Comment
'\n\n\n'      Text

'/// We start by defining some basic notions for a commutative monoid.' Comment
'\n'          Text

'///'         Comment
'\n'          Text

'/// We could reuse FStar.Algebra.CommMonoid, but this style with' Comment
'\n'          Text

'/// quanitifers was more convenient for the proof done here.' Comment
'\n\n\n'      Text

'let'         Keyword.Declaration
' '           Text
'symmetry'    Name
' '           Text
'#'           Operator
'a'           Name
' '           Text
'('           Operator
'equals'      Name
':'           Operator
' '           Text
'a'           Name
' '           Text
'->'          Operator
' '           Text
'a'           Name
' '           Text
'->'          Operator
' '           Text
'prop'        Name
')'           Operator
' '           Text
'='           Operator
'\n  '        Text
'forall'      Keyword
' '           Text
'x'           Name
' '           Text
'y'           Name
'.'           Operator
' '           Text
'{'           Operator
':'           Operator
'pattern'     Name
' '           Text
'('           Operator
'x'           Name
' '           Text
'`equals`'    Operator.Word
' '           Text
'y'           Name
')'           Operator
'}'           Operator
'\n    '      Text
'x'           Name
' '           Text
'`equals`'    Operator.Word
' '           Text
'y'           Name
' '           Text
'='           Operator
'='           Operator
'>'           Operator
' '           Text
'y'           Name
' '           Text
'`equals`'    Operator.Word
' '           Text
'x'           Name
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'transitive'  Name
' '           Text
'#'           Operator
'a'           Name
' '           Text
'('           Operator
'equals'      Name
':'           Operator
'a'           Name
' '           Text
'->'          Operator
' '           Text
'a'           Name
' '           Text
'->'          Operator
' '           Text
'prop'        Name
')'           Operator
' '           Text
'='           Operator
'\n  '        Text
'forall'      Keyword
' '           Text
'x'           Name
' '           Text
'y'           Name
' '           Text
'z'           Name
'.'           Operator
' '           Text
'x'           Name
' '           Text
'`equals`'    Operator.Word
' '           Text
'y'           Name
' '           Text
'/\\'         Operator
' '           Text
'y'           Name
' '           Text
'`equals`'    Operator.Word
' '           Text
'z'           Name
' '           Text
'='           Operator
'='           Operator
'>'           Operator
' '           Text
'x'           Name
' '           Text
'`equals`'    Operator.Word
' '           Text
'z'           Name
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'associative' Name
' '           Text
'#'           Operator
'a'           Name
' '           Text
'('           Operator
'equals'      Name
':'           Operator
' '           Text
'a'           Name
' '           Text
'->'          Operator
' '           Text
'a'           Name
' '           Text
'->'          Operator
' '           Text
'prop'        Name
')'           Operator
' '           Text
'('           Operator
'f'           Name
':'           Operator
' '           Text
'a'           Name
' '           Text
'->'          Operator
' '           Text
'a'           Name
' '           Text
'->'          Operator
' '           Text
'a'           Name
')'           Operator
'='           Operator
'\n  '        Text
'forall'      Keyword
' '           Text
'x'           Name
' '           Text
'y'           Name
' '           Text
'z'           Name
'.'           Operator
'\n    '      Text
'f'           Name
' '           Text
'x'           Name
' '           Text
'('           Operator
'f'           Name
' '           Text
'y'           Name
' '           Text
'z'           Name
')'           Operator
' '           Text
'`equals`'    Operator.Word
' '           Text
'f'           Name
' '           Text
'('           Operator
'f'           Name
' '           Text
'x'           Name
' '           Text
'y'           Name
')'           Operator
' '           Text
'z'           Name
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'commutative' Name
' '           Text
'#'           Operator
'a'           Name
' '           Text
'('           Operator
'equals'      Name
':'           Operator
' '           Text
'a'           Name
' '           Text
'->'          Operator
' '           Text
'a'           Name
' '           Text
'->'          Operator
' '           Text
'prop'        Name
')'           Operator
' '           Text
'('           Operator
'f'           Name
':'           Operator
' '           Text
'a'           Name
' '           Text
'->'          Operator
' '           Text
'a'           Name
' '           Text
'->'          Operator
' '           Text
'a'           Name
')'           Operator
' '           Text
'='           Operator
'\n  '        Text
'forall'      Keyword
' '           Text
'x'           Name
' '           Text
'y'           Name
'.'           Operator
'{'           Operator
':'           Operator
'pattern'     Name
' '           Text
'f'           Name
' '           Text
'x'           Name
' '           Text
'y'           Name
'}'           Operator
'\n    '      Text
'f'           Name
' '           Text
'x'           Name
' '           Text
'y'           Name
' '           Text
'`equals`'    Operator.Word
' '           Text
'f'           Name
' '           Text
'y'           Name
' '           Text
'x'           Name
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'is_unit'     Name
' '           Text
'#'           Operator
'a'           Name
' '           Text
'('           Operator
'x'           Name
':'           Operator
'a'           Name
')'           Operator
' '           Text
'('           Operator
'equals'      Name
':'           Operator
' '           Text
'a'           Name
' '           Text
'->'          Operator
' '           Text
'a'           Name
' '           Text
'->'          Operator
' '           Text
'prop'        Name
')'           Operator
' '           Text
'('           Operator
'f'           Name
':'           Operator
'a'           Name
' '           Text
'->'          Operator
' '           Text
'a'           Name
' '           Text
'->'          Operator
' '           Text
'a'           Name
')'           Operator
' '           Text
'='           Operator
'\n  '        Text
'forall'      Keyword
' '           Text
'y'           Name
'.'           Operator
' '           Text
'{'           Operator
':'           Operator
'pattern'     Name
' '           Text
'f'           Name
' '           Text
'x'           Name
' '           Text
'y'           Name
' '           Text
'\\/'         Operator
' '           Text
'f'           Name
' '           Text
'y'           Name
' '           Text
'x'           Name
'}'           Operator
'\n    '      Text
'f'           Name
' '           Text
'x'           Name
' '           Text
'y'           Name
' '           Text
'`equals`'    Operator.Word
' '           Text
'y'           Name
' '           Text
'/\\'         Operator
'\n    '      Text
'f'           Name
' '           Text
'y'           Name
' '           Text
'x'           Name
' '           Text
'`equals`'    Operator.Word
' '           Text
'y'           Name
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'equals_ext'  Name
' '           Text
'#'           Operator
'a'           Name
' '           Text
'('           Operator
'equals'      Name
':'           Operator
'a'           Name
' '           Text
'->'          Operator
' '           Text
'a'           Name
' '           Text
'->'          Operator
' '           Text
'prop'        Name
')'           Operator
' '           Text
'('           Operator
'f'           Name
':'           Operator
'a'           Name
' '           Text
'->'          Operator
' '           Text
'a'           Name
' '           Text
'->'          Operator
' '           Text
'a'           Name
')'           Operator
' '           Text
'='           Operator
'\n  '        Text
'forall'      Keyword
' '           Text
'x1'          Name
' '           Text
'x2'          Name
' '           Text
'y'           Name
'.'           Operator
' '           Text
'x1'          Name
' '           Text
'`equals`'    Operator.Word
' '           Text
'x2'          Name
' '           Text
'='           Operator
'='           Operator
'>'           Operator
' '           Text
'f'           Name
' '           Text
'x1'          Name
' '           Text
'y'           Name
' '           Text
'`equals`'    Operator.Word
' '           Text
'f'           Name
' '           Text
'x2'          Name
' '           Text
'y'           Name
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'fp_heap_0'   Name
'\n       '   Text
'('           Operator
'#'           Operator
'heap'        Name
':'           Operator
'Type'        Name.Class
')'           Operator
'\n       '   Text
'('           Operator
'#'           Operator
'hprop'       Name
':'           Operator
'Type'        Name.Class
')'           Operator
'\n       '   Text
'('           Operator
'interp'      Name
':'           Operator
'hprop'       Name
' '           Text
'->'          Operator
' '           Text
'heap'        Name
' '           Text
'->'          Operator
' '           Text
'prop'        Name
')'           Operator
'\n       '   Text
'('           Operator
'pre'         Name
':'           Operator
'hprop'       Name
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'h'           Name
':'           Operator
'heap'        Name
'{'           Operator
'interp'      Name
' '           Text
'pre'         Name
' '           Text
'h'           Name
'}'           Operator
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'depends_only_on_0' Name
'\n      '    Text
'('           Operator
'#'           Operator
'heap'        Name
':'           Operator
'Type'        Name.Class
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'hprop'       Name
':'           Operator
'Type'        Name.Class
')'           Operator
'\n      '    Text
'('           Operator
'interp'      Name
':'           Operator
'hprop'       Name
' '           Text
'->'          Operator
' '           Text
'heap'        Name
' '           Text
'->'          Operator
' '           Text
'prop'        Name
')'           Operator
'\n      '    Text
'('           Operator
'disjoint'    Name
':'           Operator
' '           Text
'heap'        Name
' '           Text
'->'          Operator
' '           Text
'heap'        Name
' '           Text
'->'          Operator
' '           Text
'prop'        Name
')'           Operator
'\n      '    Text
'('           Operator
'join'        Name
':'           Operator
' '           Text
'('           Operator
'h0'          Name
':'           Operator
'heap'        Name
' '           Text
'->'          Operator
' '           Text
'h1'          Name
':'           Operator
'heap'        Name
'{'           Operator
'disjoint'    Name
' '           Text
'h0'          Name
' '           Text
'h1'          Name
'}'           Operator
' '           Text
'->'          Operator
' '           Text
'heap'        Name
')'           Operator
')'           Operator
'\n      '    Text
'('           Operator
'q'           Name
':'           Operator
'heap'        Name
' '           Text
'->'          Operator
' '           Text
'prop'        Name
')'           Operator
' '           Text
'('           Operator
'fp'          Name
':'           Operator
' '           Text
'hprop'       Name
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'forall'      Keyword
' '           Text
'('           Operator
'h0'          Name
':'           Operator
'fp_heap_0'   Name
' '           Text
'interp'      Name
' '           Text
'fp'          Name
')'           Operator
' '           Text
'('           Operator
'h1'          Name
':'           Operator
'heap'        Name
'{'           Operator
'disjoint'    Name
' '           Text
'h0'          Name
' '           Text
'h1'          Name
'}'           Operator
')'           Operator
'.'           Operator
' '           Text
'q'           Name
' '           Text
'h0'          Name
' '           Text
'<==>'        Operator
' '           Text
'q'           Name
' '           Text
'('           Operator
'join'        Name
' '           Text
'h0'          Name
' '           Text
'h1'          Name
')'           Operator
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'fp_prop_0'   Name
'\n      '    Text
'('           Operator
'#'           Operator
'heap'        Name
':'           Operator
'Type'        Name.Class
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'hprop'       Name
':'           Operator
'Type'        Name.Class
')'           Operator
'\n      '    Text
'('           Operator
'interp'      Name
':'           Operator
'hprop'       Name
' '           Text
'->'          Operator
' '           Text
'heap'        Name
' '           Text
'->'          Operator
' '           Text
'prop'        Name
')'           Operator
'\n      '    Text
'('           Operator
'disjoint'    Name
':'           Operator
' '           Text
'heap'        Name
' '           Text
'->'          Operator
' '           Text
'heap'        Name
' '           Text
'->'          Operator
' '           Text
'prop'        Name
')'           Operator
'\n      '    Text
'('           Operator
'join'        Name
':'           Operator
' '           Text
'('           Operator
'h0'          Name
':'           Operator
'heap'        Name
' '           Text
'->'          Operator
' '           Text
'h1'          Name
':'           Operator
'heap'        Name
'{'           Operator
'disjoint'    Name
' '           Text
'h0'          Name
' '           Text
'h1'          Name
'}'           Operator
' '           Text
'->'          Operator
' '           Text
'heap'        Name
')'           Operator
')'           Operator
'\n      '    Text
'('           Operator
'fp'          Name
':'           Operator
'hprop'       Name
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'p'           Name
':'           Operator
'('           Operator
'heap'        Name
' '           Text
'->'          Operator
' '           Text
'prop'        Name
')'           Operator
'{'           Operator
'p'           Name
' '           Text
'`'           Keyword
'('           Operator
'depends_only_on_0' Name
' '           Text
'interp'      Name
' '           Text
'disjoint'    Name
' '           Text
'join'        Name
')'           Operator
'`'           Keyword
' '           Text
'fp'          Name
'}'           Operator
'\n\n'        Text

'noeq'        Keyword
'\n'          Text

'type'        Keyword
' '           Text
'st0'         Name
' '           Text
'='           Operator
' '           Text
'{'           Operator
'\n  '        Text
'mem'         Name
':'           Operator
'Type'        Name.Class
' '           Text
'u#'          Operator
'2'           Literal.Number.Integer
';'           Operator
'\n  '        Text
'core'        Name
':'           Operator
'mem'         Name
' '           Text
'->'          Operator
' '           Text
'mem'         Name
';'           Operator
'\n\n  '      Text
'locks_preorder' Name
':'           Operator
'P'           Name.Namespace
'.'           Punctuation
'preorder'    Name
' '           Text
'mem'         Name
';'           Operator
'\n  '        Text
'hprop'       Name
':'           Operator
'Type'        Name.Class
' '           Text
'u#'          Operator
'2'           Literal.Number.Integer
';'           Operator
'\n  '        Text
'locks_invariant' Name
':'           Operator
' '           Text
'mem'         Name
' '           Text
'->'          Operator
' '           Text
'hprop'       Name
';'           Operator
'\n\n  '      Text
'disjoint'    Name
':'           Operator
' '           Text
'mem'         Name
' '           Text
'->'          Operator
' '           Text
'mem'         Name
' '           Text
'->'          Operator
' '           Text
'prop'        Name
';'           Operator
'\n  '        Text
'join'        Name
':'           Operator
' '           Text
'h0'          Name
':'           Operator
'mem'         Name
' '           Text
'->'          Operator
' '           Text
'h1'          Name
':'           Operator
'mem'         Name
'{'           Operator
'disjoint'    Name
' '           Text
'h0'          Name
' '           Text
'h1'          Name
'}'           Operator
' '           Text
'->'          Operator
' '           Text
'mem'         Name
';'           Operator
'\n\n  '      Text
'interp'      Name
':'           Operator
' '           Text
'hprop'       Name
' '           Text
'->'          Operator
' '           Text
'mem'         Name
' '           Text
'->'          Operator
' '           Text
'prop'        Name
';'           Operator
'\n\n  '      Text
'emp'         Name
':'           Operator
'hprop'       Name
';'           Operator
'\n  '        Text
'star'        Name
':'           Operator
' '           Text
'hprop'       Name
' '           Text
'->'          Operator
' '           Text
'hprop'       Name
' '           Text
'->'          Operator
' '           Text
'hprop'       Name
';'           Operator
'\n\n  '      Text
'equals'      Name
':'           Operator
' '           Text
'hprop'       Name
' '           Text
'->'          Operator
' '           Text
'hprop'       Name
' '           Text
'->'          Operator
' '           Text
'prop'        Name
';'           Operator
'\n'          Text

'}'           Operator
'\n\n\n'      Text

'/// disjointness is symmetric' Comment
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'disjoint_sym' Name
' '           Text
'('           Operator
'st'          Name
':'           Operator
'st0'         Name
')'           Operator
' '           Text
'='           Operator
'\n  '        Text
'forall'      Keyword
' '           Text
'h0'          Name
' '           Text
'h1'          Name
'.'           Operator
' '           Text
'st'          Name
'.'           Operator
'disjoint'    Name
' '           Text
'h0'          Name
' '           Text
'h1'          Name
' '           Text
'<==>'        Operator
' '           Text
'st'          Name
'.'           Operator
'disjoint'    Name
' '           Text
'h1'          Name
' '           Text
'h0'          Name
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'disjoint_join' Name
' '           Text
'('           Operator
'st'          Name
':'           Operator
'st0'         Name
')'           Operator
' '           Text
'='           Operator
'\n  '        Text
'forall'      Keyword
' '           Text
'm0'          Name
' '           Text
'm1'          Name
' '           Text
'm2'          Name
'.'           Operator
'\n    '      Text
'st'          Name
'.'           Operator
'disjoint'    Name
' '           Text
'm1'          Name
' '           Text
'm2'          Name
' '           Text
'/\\'         Operator
'\n    '      Text
'st'          Name
'.'           Operator
'disjoint'    Name
' '           Text
'm0'          Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'join'        Name
' '           Text
'm1'          Name
' '           Text
'm2'          Name
')'           Operator
' '           Text
'='           Operator
'='           Operator
'>'           Operator
'\n    '      Text
'st'          Name
'.'           Operator
'disjoint'    Name
' '           Text
'm0'          Name
' '           Text
'm1'          Name
' '           Text
'/\\'         Operator
'\n    '      Text
'st'          Name
'.'           Operator
'disjoint'    Name
' '           Text
'm0'          Name
' '           Text
'm2'          Name
' '           Text
'/\\'         Operator
'\n    '      Text
'st'          Name
'.'           Operator
'disjoint'    Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'join'        Name
' '           Text
'm0'          Name
' '           Text
'm1'          Name
')'           Operator
' '           Text
'm2'          Name
' '           Text
'/\\'         Operator
'\n    '      Text
'st'          Name
'.'           Operator
'disjoint'    Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'join'        Name
' '           Text
'm0'          Name
' '           Text
'm2'          Name
')'           Operator
' '           Text
'm1'          Name
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'join_commutative' Name
' '           Text
'('           Operator
'st'          Name
':'           Operator
'st0'         Name
' '           Text
'{'           Operator
' '           Text
'disjoint_sym' Name
' '           Text
'st'          Name
' '           Text
'}'           Operator
')'           Operator
' '           Text
'='           Operator
'\n  '        Text
'forall'      Keyword
' '           Text
'm0'          Name
' '           Text
'm1'          Name
'.'           Operator
'\n    '      Text
'st'          Name
'.'           Operator
'disjoint'    Name
' '           Text
'm0'          Name
' '           Text
'm1'          Name
' '           Text
'='           Operator
'='           Operator
'>'           Operator
'\n    '      Text
'st'          Name
'.'           Operator
'join'        Name
' '           Text
'm0'          Name
' '           Text
'm1'          Name
' '           Text
'='           Operator
'='           Operator
' '           Text
'st'          Name
'.'           Operator
'join'        Name
' '           Text
'm1'          Name
' '           Text
'm0'          Name
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'join_associative' Name
' '           Text
'('           Operator
'st'          Name
':'           Operator
'st0'         Name
'{'           Operator
'disjoint_join' Name
' '           Text
'st'          Name
'}'           Operator
')'           Operator
'='           Operator
'\n  '        Text
'forall'      Keyword
' '           Text
'm0'          Name
' '           Text
'm1'          Name
' '           Text
'm2'          Name
'.'           Operator
'\n    '      Text
'st'          Name
'.'           Operator
'disjoint'    Name
' '           Text
'm1'          Name
' '           Text
'm2'          Name
' '           Text
'/\\'         Operator
'\n    '      Text
'st'          Name
'.'           Operator
'disjoint'    Name
' '           Text
'm0'          Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'join'        Name
' '           Text
'm1'          Name
' '           Text
'm2'          Name
')'           Operator
' '           Text
'='           Operator
'='           Operator
'>'           Operator
'\n    '      Text
'st'          Name
'.'           Operator
'join'        Name
' '           Text
'm0'          Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'join'        Name
' '           Text
'm1'          Name
' '           Text
'm2'          Name
')'           Operator
' '           Text
'='           Operator
'='           Operator
' '           Text
'st'          Name
'.'           Operator
'join'        Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'join'        Name
' '           Text
'm0'          Name
' '           Text
'm1'          Name
')'           Operator
' '           Text
'm2'          Name
'\n\n'        Text

'////////////////////////////////////////////////////////////////////////////////' Comment
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'interp_extensionality' Name
' '           Text
'#'           Operator
'r'           Name
' '           Text
'#'           Operator
's'           Name
' '           Text
'('           Operator
'equals'      Name
':'           Operator
'r'           Name
' '           Text
'->'          Operator
' '           Text
'r'           Name
' '           Text
'->'          Operator
' '           Text
'prop'        Name
')'           Operator
' '           Text
'('           Operator
'f'           Name
':'           Operator
'r'           Name
' '           Text
'->'          Operator
' '           Text
's'           Name
' '           Text
'->'          Operator
' '           Text
'prop'        Name
')'           Operator
' '           Text
'='           Operator
'\n  '        Text
'forall'      Keyword
' '           Text
'x'           Name
' '           Text
'y'           Name
' '           Text
'h'           Name
'.'           Operator
' '           Text
'{'           Operator
':'           Operator
'pattern'     Name
' '           Text
'equals'      Name
' '           Text
'x'           Name
' '           Text
'y'           Name
';'           Operator
' '           Text
'f'           Name
' '           Text
'x'           Name
' '           Text
'h'           Name
'}'           Operator
' '           Text
'equals'      Name
' '           Text
'x'           Name
' '           Text
'y'           Name
' '           Text
'/\\'         Operator
' '           Text
'f'           Name
' '           Text
'x'           Name
' '           Text
'h'           Name
' '           Text
'='           Operator
'='           Operator
'>'           Operator
' '           Text
'f'           Name
' '           Text
'y'           Name
' '           Text
'h'           Name
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'affine'      Name
' '           Text
'('           Operator
'st'          Name
':'           Operator
'st0'         Name
')'           Operator
' '           Text
'='           Operator
'\n  '        Text
'forall'      Keyword
' '           Text
'r0'          Name
' '           Text
'r1'          Name
' '           Text
's'           Name
'.'           Operator
' '           Text
'{'           Operator
':'           Operator
'pattern'     Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'('           Operator
'r0'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'r1'          Name
')'           Operator
' '           Text
's'           Name
')'           Operator
' '           Text
'}'           Operator
'\n    '      Text
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'('           Operator
'r0'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'r1'          Name
')'           Operator
' '           Text
's'           Name
' '           Text
'='           Operator
'='           Operator
'>'           Operator
' '           Text
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'r0'          Name
' '           Text
's'           Name
'\n\n'        Text

'////////////////////////////////////////////////////////////////////////////////' Comment
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'depends_only_on' Name
' '           Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st0'         Name
')'           Operator
' '           Text
'('           Operator
'q'           Name
':'           Operator
'st'          Name
'.'           Operator
'mem'         Name
' '           Text
'->'          Operator
' '           Text
'prop'        Name
')'           Operator
' '           Text
'('           Operator
'fp'          Name
':'           Operator
' '           Text
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
' '           Text
'='           Operator
'\n  '        Text
'depends_only_on_0' Name
' '           Text
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'st'          Name
'.'           Operator
'disjoint'    Name
' '           Text
'st'          Name
'.'           Operator
'join'        Name
' '           Text
'q'           Name
' '           Text
'fp'          Name
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'fp_prop'     Name
' '           Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st0'         Name
')'           Operator
' '           Text
'('           Operator
'fp'          Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
' '           Text
'='           Operator
'\n  '        Text
'fp_prop_0'   Name
' '           Text
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'st'          Name
'.'           Operator
'disjoint'    Name
' '           Text
'st'          Name
'.'           Operator
'join'        Name
' '           Text
'fp'          Name
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'lemma_weaken_depends_only_on' Name
'\n      '    Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st0'         Name
'{'           Operator
'affine'      Name
' '           Text
'st'          Name
'}'           Operator
')'           Operator
'\n      '    Text
'('           Operator
'fp0'         Name
' '           Text
'fp1'         Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'q'           Name
':'           Operator
'fp_prop'     Name
' '           Text
'fp0'         Name
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'Lemma'       Name.Class
' '           Text
'('           Operator
'q'           Name
' '           Text
'`depends_only_on`' Operator.Word
' '           Text
'('           Operator
'fp0'         Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'fp1'         Name
')'           Operator
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'()'          Name.Builtin.Pseudo
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'st_laws'     Name
' '           Text
'('           Operator
'st'          Name
':'           Operator
'st0'         Name
')'           Operator
' '           Text
'='           Operator
'\n  '        Text
'(*'          Comment
' standard laws about the equality relation ' Comment
'*)'          Comment
'\n  '        Text
'symmetry'    Name
' '           Text
'st'          Name
'.'           Operator
'equals'      Name
' '           Text
'/\\'         Operator
'\n  '        Text
'transitive'  Name
' '           Text
'st'          Name
'.'           Operator
'equals'      Name
' '           Text
'/\\'         Operator
'\n  '        Text
'interp_extensionality' Name
' '           Text
'st'          Name
'.'           Operator
'equals'      Name
' '           Text
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'/\\'         Operator
'\n  '        Text
'(*'          Comment
' standard laws for star forming a CM ' Comment
'*)'          Comment
'\n  '        Text
'associative' Name
' '           Text
'st'          Name
'.'           Operator
'equals'      Name
' '           Text
'st'          Name
'.'           Operator
'star'        Name
' '           Text
'/\\'         Operator
'\n  '        Text
'commutative' Name
' '           Text
'st'          Name
'.'           Operator
'equals'      Name
' '           Text
'st'          Name
'.'           Operator
'star'        Name
' '           Text
'/\\'         Operator
'\n  '        Text
'is_unit'     Name
' '           Text
'st'          Name
'.'           Operator
'emp'         Name
' '           Text
'st'          Name
'.'           Operator
'equals'      Name
' '           Text
'st'          Name
'.'           Operator
'star'        Name
' '           Text
'/\\'         Operator
'\n  '        Text
'equals_ext'  Name
' '           Text
'st'          Name
'.'           Operator
'equals'      Name
' '           Text
'st'          Name
'.'           Operator
'star'        Name
' '           Text
'/\\'         Operator
'\n  '        Text
'(*'          Comment
" We're working in an affine interpretation of SL " Comment
'*)'          Comment
'\n  '        Text
'affine'      Name
' '           Text
'st'          Name
' '           Text
'/\\'         Operator
'\n  '        Text
'(*'          Comment
' laws about disjoint and join ' Comment
'*)'          Comment
'\n  '        Text
'disjoint_sym' Name
' '           Text
'st'          Name
' '           Text
'/\\'         Operator
'\n  '        Text
'disjoint_join' Name
' '           Text
'st'          Name
' '           Text
'/\\'         Operator
'\n  '        Text
'join_commutative' Name
' '           Text
'st'          Name
' '           Text
'/\\'         Operator
'\n  '        Text
'join_associative' Name
' '           Text
'st'          Name
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'st'          Name
' '           Text
'='           Operator
' '           Text
's'           Name
':'           Operator
'st0'         Name
' '           Text
'{'           Operator
' '           Text
'st_laws'     Name
' '           Text
's'           Name
' '           Text
'}'           Operator
'\n\n'        Text

'(*'          Comment
'*'           Comment
'*'           Comment
'*'           Comment
' End state defn ' Comment
'*'           Comment
'*'           Comment
'*'           Comment
'*)'          Comment
'\n\n\n'      Text

'(*'          Comment
'*'           Comment
'*'           Comment
'*'           Comment
' Begin expects, provides, requires, and ensures defns ' Comment
'*'           Comment
'*'           Comment
'*'           Comment
'*)'          Comment
'\n\n\n'      Text

'/// expects (the heap assertion expected by a computation) is simply an st.hprop' Comment
'\n'          Text

'///'         Comment
'\n'          Text

'/// provides, or the post heap assertion, is a st.hprop on [a]-typed result' Comment
'\n\n'        Text

'type'        Keyword
' '           Text
'post_t'      Name
' '           Text
'('           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
' '           Text
'('           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
')'           Operator
' '           Text
'='           Operator
' '           Text
'a'           Name
' '           Text
'->'          Operator
' '           Text
'st'          Name
'.'           Operator
'hprop'       Name
'\n\n\n'      Text

'/// requires is a heap predicate that depends only on a pre heap assertion' Comment
'\n'          Text

'///   (where the notion of `depends only on` is defined above as part of the state definition)' Comment
'\n'          Text

'///'         Comment
'\n'          Text

'/// we call the type l_pre for logical precondition' Comment
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'l_pre'       Name
' '           Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
' '           Text
'('           Operator
'pre'         Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
' '           Text
'='           Operator
' '           Text
'fp_prop'     Name
' '           Text
'pre'         Name
'\n\n\n'      Text

'/// ensures is a 2-state postcondition of type heap -> a -> heap -> prop' Comment
'\n'          Text

'///'         Comment
'\n'          Text

'/// To define ensures, we need a notion of depends_only_on_2' Comment
'\n'          Text

'///'         Comment
'\n'          Text

'/// Essentially, in the first heap argument, postconditions depend only on the expects hprop' Comment
'\n'          Text

'///   and in the second heap argument, postconditions depend only on the provides hprop' Comment
'\n'          Text

'///'         Comment
'\n'          Text

'/// Also note that the support for depends_only_on_2 is not required from the underlying memory model' Comment
'\n\n\n'      Text

'let'         Keyword.Declaration
' '           Text
'depends_only_on_0_2' Name
'\n      '    Text
'('           Operator
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'heap'        Name
':'           Operator
'Type'        Name.Class
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'hprop'       Name
':'           Operator
'Type'        Name.Class
')'           Operator
'\n      '    Text
'('           Operator
'interp'      Name
':'           Operator
'hprop'       Name
' '           Text
'->'          Operator
' '           Text
'heap'        Name
' '           Text
'->'          Operator
' '           Text
'prop'        Name
')'           Operator
'\n      '    Text
'('           Operator
'disjoint'    Name
':'           Operator
'heap'        Name
' '           Text
'->'          Operator
' '           Text
'heap'        Name
' '           Text
'->'          Operator
' '           Text
'prop'        Name
')'           Operator
'\n      '    Text
'('           Operator
'join'        Name
':'           Operator
'('           Operator
'h0'          Name
':'           Operator
'heap'        Name
' '           Text
'->'          Operator
' '           Text
'h1'          Name
':'           Operator
'heap'        Name
'{'           Operator
'disjoint'    Name
' '           Text
'h0'          Name
' '           Text
'h1'          Name
'}'           Operator
' '           Text
'->'          Operator
' '           Text
'heap'        Name
')'           Operator
')'           Operator
'\n      '    Text
'('           Operator
'q'           Name
':'           Operator
'heap'        Name
' '           Text
'->'          Operator
' '           Text
'a'           Name
' '           Text
'->'          Operator
' '           Text
'heap'        Name
' '           Text
'->'          Operator
' '           Text
'prop'        Name
')'           Operator
' '           Text
'('           Operator
'fp_pre'      Name
':'           Operator
'hprop'       Name
')'           Operator
' '           Text
'('           Operator
'fp_post'     Name
':'           Operator
'a'           Name
' '           Text
'->'          Operator
' '           Text
'hprop'       Name
')'           Operator
'\n\n    '    Text
'='           Operator
' '           Text
'//'          Operator
'can'         Name
' '           Text
'join'        Name
' '           Text
'any'         Name
' '           Text
'disjoint'    Name
' '           Text
'heap'        Name
' '           Text
'to'          Name
' '           Text
'the'         Name
' '           Text
'pre'         Name
'-'           Operator
'heap'        Name
' '           Text
'and'         Name
' '           Text
'q'           Name
' '           Text
'is'          Name
' '           Text
'still'       Name
' '           Text
'valid'       Name
'\n  '        Text
'('           Operator
'forall'      Keyword
' '           Text
'x'           Name
' '           Text
'('           Operator
'h_pre'       Name
':'           Operator
'fp_heap_0'   Name
' '           Text
'interp'      Name
' '           Text
'fp_pre'      Name
')'           Operator
' '           Text
'h_post'      Name
' '           Text
'('           Operator
'h'           Name
':'           Operator
'heap'        Name
'{'           Operator
'disjoint'    Name
' '           Text
'h_pre'       Name
' '           Text
'h'           Name
'}'           Operator
')'           Operator
'.'           Operator
'\n     '     Text
'q'           Name
' '           Text
'h_pre'       Name
' '           Text
'x'           Name
' '           Text
'h_post'      Name
' '           Text
'<==>'        Operator
' '           Text
'q'           Name
' '           Text
'('           Operator
'join'        Name
' '           Text
'h_pre'       Name
' '           Text
'h'           Name
')'           Operator
' '           Text
'x'           Name
' '           Text
'h_post'      Name
')'           Operator
' '           Text
'/\\'         Operator
'\n  '        Text
'//'          Operator
'can'         Name
' '           Text
'join'        Name
' '           Text
'any'         Name
' '           Text
'disjoint'    Name
' '           Text
'heap'        Name
' '           Text
'to'          Name
' '           Text
'the'         Name
' '           Text
'post'        Name
'-'           Operator
'heap'        Name
' '           Text
'and'         Name
' '           Text
'q'           Name
' '           Text
'is'          Name
' '           Text
'still'       Name
' '           Text
'valid'       Name
'\n  '        Text
'('           Operator
'forall'      Keyword
' '           Text
'x'           Name
' '           Text
'h_pre'       Name
' '           Text
'('           Operator
'h_post'      Name
':'           Operator
'fp_heap_0'   Name
' '           Text
'interp'      Name
' '           Text
'('           Operator
'fp_post'     Name
' '           Text
'x'           Name
')'           Operator
')'           Operator
' '           Text
'('           Operator
'h'           Name
':'           Operator
'heap'        Name
'{'           Operator
'disjoint'    Name
' '           Text
'h_post'      Name
' '           Text
'h'           Name
'}'           Operator
')'           Operator
'.'           Operator
'\n     '     Text
'q'           Name
' '           Text
'h_pre'       Name
' '           Text
'x'           Name
' '           Text
'h_post'      Name
' '           Text
'<==>'        Operator
' '           Text
'q'           Name
' '           Text
'h_pre'       Name
' '           Text
'x'           Name
' '           Text
'('           Operator
'join'        Name
' '           Text
'h_post'      Name
' '           Text
'h'           Name
')'           Operator
')'           Operator
'\n\n'        Text

'/// Abbreviations for two-state depends' Comment
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'fp_prop_0_2' Name
'\n      '    Text
'('           Operator
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'heap'        Name
' '           Text
'#'           Operator
'hprop'       Name
':'           Operator
'Type'        Name.Class
')'           Operator
'\n      '    Text
'('           Operator
'interp'      Name
':'           Operator
'hprop'       Name
' '           Text
'->'          Operator
' '           Text
'heap'        Name
' '           Text
'->'          Operator
' '           Text
'prop'        Name
')'           Operator
'\n      '    Text
'('           Operator
'disjoint'    Name
':'           Operator
'heap'        Name
' '           Text
'->'          Operator
' '           Text
'heap'        Name
' '           Text
'->'          Operator
' '           Text
'prop'        Name
')'           Operator
'\n      '    Text
'('           Operator
'join'        Name
':'           Operator
'('           Operator
'h0'          Name
':'           Operator
'heap'        Name
' '           Text
'->'          Operator
' '           Text
'h1'          Name
':'           Operator
'heap'        Name
'{'           Operator
'disjoint'    Name
' '           Text
'h0'          Name
' '           Text
'h1'          Name
'}'           Operator
' '           Text
'->'          Operator
' '           Text
'heap'        Name
')'           Operator
')'           Operator
'\n      '    Text
'('           Operator
'fp_pre'      Name
':'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'fp_post'     Name
':'           Operator
'a'           Name
' '           Text
'->'          Operator
' '           Text
'hprop'       Name
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'q'           Name
':'           Operator
'('           Operator
'heap'        Name
' '           Text
'->'          Operator
' '           Text
'a'           Name
' '           Text
'->'          Operator
' '           Text
'heap'        Name
' '           Text
'->'          Operator
' '           Text
'prop'        Name
')'           Operator
'{'           Operator
'depends_only_on_0_2' Name
' '           Text
'interp'      Name
' '           Text
'disjoint'    Name
' '           Text
'join'        Name
' '           Text
'q'           Name
' '           Text
'fp_pre'      Name
' '           Text
'fp_post'     Name
'}'           Operator
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'depends_only_on2' Name
'\n      '    Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st0'         Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
')'           Operator
'\n      '    Text
'('           Operator
'q'           Name
':'           Operator
'st'          Name
'.'           Operator
'mem'         Name
' '           Text
'->'          Operator
' '           Text
'a'           Name
' '           Text
'->'          Operator
' '           Text
'st'          Name
'.'           Operator
'mem'         Name
' '           Text
'->'          Operator
' '           Text
'prop'        Name
')'           Operator
'\n      '    Text
'('           Operator
'fp_pre'      Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'fp_post'     Name
':'           Operator
'a'           Name
' '           Text
'->'          Operator
' '           Text
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'depends_only_on_0_2' Name
' '           Text
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'st'          Name
'.'           Operator
'disjoint'    Name
' '           Text
'st'          Name
'.'           Operator
'join'        Name
' '           Text
'q'           Name
' '           Text
'fp_pre'      Name
' '           Text
'fp_post'     Name
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'fp_prop2'    Name
' '           Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st0'         Name
')'           Operator
' '           Text
'('           Operator
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
')'           Operator
' '           Text
'('           Operator
'fp_pre'      Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
' '           Text
'('           Operator
'fp_post'     Name
':'           Operator
'a'           Name
' '           Text
'->'          Operator
' '           Text
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
' '           Text
'='           Operator
'\n  '        Text
'q'           Name
':'           Operator
'('           Operator
'st'          Name
'.'           Operator
'mem'         Name
' '           Text
'->'          Operator
' '           Text
'a'           Name
' '           Text
'->'          Operator
' '           Text
'st'          Name
'.'           Operator
'mem'         Name
' '           Text
'->'          Operator
' '           Text
'prop'        Name
')'           Operator
'{'           Operator
'depends_only_on2' Name
' '           Text
'q'           Name
' '           Text
'fp_pre'      Name
' '           Text
'fp_post'     Name
'}'           Operator
'\n\n'        Text

'/// Finally the type of 2-state postconditions' Comment
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'l_post'      Name
' '           Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
' '           Text
'('           Operator
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
')'           Operator
' '           Text
'('           Operator
'pre'         Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
' '           Text
'('           Operator
'post'        Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
' '           Text
'='           Operator
' '           Text
'fp_prop2'    Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
'\n\n\n'      Text

'(*'          Comment
'*'           Comment
'*'           Comment
'*'           Comment
' End expects, provides, requires,\n      and ensures defns ' Comment
'*'           Comment
'*'           Comment
'*'           Comment
'*)'          Comment
'\n\n'        Text

'effect'      Keyword
' '           Text
'Mst'         Name.Class
' '           Text
'('           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
')'           Operator
' '           Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
' '           Text
'('           Operator
'req'         Name
':'           Operator
'st'          Name
'.'           Operator
'mem'         Name
' '           Text
'->'          Operator
' '           Text
'Type0'       Name.Class
')'           Operator
' '           Text
'('           Operator
'ens'         Name
':'           Operator
'st'          Name
'.'           Operator
'mem'         Name
' '           Text
'->'          Operator
' '           Text
'a'           Name
' '           Text
'->'          Operator
' '           Text
'st'          Name
'.'           Operator
'mem'         Name
' '           Text
'->'          Operator
' '           Text
'Type0'       Name.Class
')'           Operator
' '           Text
'='           Operator
'\n  '        Text
'NMSTATE'     Name.Class
' '           Text
'a'           Name
' '           Text
'st'          Name
'.'           Operator
'mem'         Name
' '           Text
'st'          Name
'.'           Operator
'locks_preorder' Name
' '           Text
'req'         Name
' '           Text
'ens'         Name
'\n\n\n'      Text

'(*'          Comment
'*'           Comment
'*'           Comment
'*'           Comment
' Begin interface of actions ' Comment
'*'           Comment
'*'           Comment
'*'           Comment
'*)'          Comment
'\n\n'        Text

'/// Actions are essentially state transformers that preserve frames' Comment
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'preserves_frame' Name
' '           Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
' '           Text
'('           Operator
'pre'         Name
' '           Text
'post'        Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
' '           Text
'('           Operator
'm0'          Name
' '           Text
'm1'          Name
':'           Operator
'st'          Name
'.'           Operator
'mem'         Name
')'           Operator
' '           Text
'='           Operator
'\n  '        Text
'forall'      Keyword
' '           Text
'('           Operator
'frame'       Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'.'           Operator
'\n    '      Text
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'('           Operator
'('           Operator
'pre'         Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm0'          Name
')'           Operator
')'           Operator
' '           Text
'm0'          Name
' '           Text
'='           Operator
'='           Operator
'>'           Operator
'\n    '      Text
'('           Operator
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'('           Operator
'('           Operator
'post'        Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm1'          Name
')'           Operator
')'           Operator
' '           Text
'm1'          Name
' '           Text
'/\\'         Operator
'\n     '     Text
'('           Operator
'forall'      Keyword
' '           Text
'('           Operator
'f_frame'     Name
':'           Operator
'fp_prop'     Name
' '           Text
'frame'       Name
')'           Operator
'.'           Operator
' '           Text
'f_frame'     Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'core'        Name
' '           Text
'm0'          Name
')'           Operator
' '           Text
'='           Operator
'='           Operator
' '           Text
'f_frame'     Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'core'        Name
' '           Text
'm1'          Name
')'           Operator
')'           Operator
')'           Operator
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'action_t'    Name
'\n      '    Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
')'           Operator
'\n      '    Text
'('           Operator
'pre'         Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'post'        Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'lpre'        Name
':'           Operator
'l_pre'       Name
' '           Text
'pre'         Name
')'           Operator
'\n      '    Text
'('           Operator
'lpost'       Name
':'           Operator
'l_post'      Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'unit'        Keyword.Type
' '           Text
'->'          Operator
'\n    '      Text
'Mst'         Name.Class
' '           Text
'a'           Name
'\n      '    Text
'('           Operator
'requires'    Keyword
' '           Text
'fun'         Keyword
' '           Text
'm0'          Name
' '           Text
'->'          Operator
'\n        '  Text
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'('           Operator
'pre'         Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm0'          Name
')'           Operator
' '           Text
'm0'          Name
' '           Text
'/\\'         Operator
'\n        '  Text
'lpre'        Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'core'        Name
' '           Text
'm0'          Name
')'           Operator
')'           Operator
'\n      '    Text
'('           Operator
'ensures'     Keyword
' '           Text
'fun'         Keyword
' '           Text
'm0'          Name
' '           Text
'x'           Name
' '           Text
'm1'          Name
' '           Text
'->'          Operator
'\n        '  Text
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'('           Operator
'('           Operator
'post'        Name
' '           Text
'x'           Name
')'           Operator
' '           Text
'`st.star`'   Operator.Word
' '           Text
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm1'          Name
')'           Operator
' '           Text
'm1'          Name
' '           Text
'/\\'         Operator
'\n        '  Text
'lpost'       Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'core'        Name
' '           Text
'm0'          Name
')'           Operator
' '           Text
'x'           Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'core'        Name
' '           Text
'm1'          Name
')'           Operator
' '           Text
'/\\'         Operator
'\n        '  Text
'preserves_frame' Name
' '           Text
'pre'         Name
' '           Text
'('           Operator
'post'        Name
' '           Text
'x'           Name
')'           Operator
' '           Text
'm0'          Name
' '           Text
'm1'          Name
')'           Operator
'\n\n'        Text

'(*'          Comment
'*'           Comment
'*'           Comment
'*'           Comment
' End interface of actions ' Comment
'*'           Comment
'*'           Comment
'*'           Comment
'*)'          Comment
'\n\n\n'      Text

'(*'          Comment
'*'           Comment
'*'           Comment
'*'           Comment
' Begin definition of the computation AST ' Comment
'*'           Comment
'*'           Comment
'*'           Comment
'*)'          Comment
'\n\n\n'      Text

'/// Gadgets for building lpre- and lpostconditions for various nodes' Comment
'\n\n\n'      Text

'/// Return node is parametric in provides and ensures' Comment
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'return_lpre' Name
' '           Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
' '           Text
'('           Operator
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
')'           Operator
' '           Text
'('           Operator
'#'           Operator
'post'        Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
' '           Text
'('           Operator
'x'           Name
':'           Operator
'a'           Name
')'           Operator
' '           Text
'('           Operator
'lpost'       Name
':'           Operator
'l_post'      Name
' '           Text
'('           Operator
'post'        Name
' '           Text
'x'           Name
')'           Operator
' '           Text
'post'        Name
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'l_pre'       Name
' '           Text
'('           Operator
'post'        Name
' '           Text
'x'           Name
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'fun'         Keyword
' '           Text
'h'           Name
' '           Text
'->'          Operator
' '           Text
'lpost'       Name
' '           Text
'h'           Name
' '           Text
'x'           Name
' '           Text
'h'           Name
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'frame_lpre'  Name
' '           Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
' '           Text
'('           Operator
'#'           Operator
'pre'         Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
' '           Text
'('           Operator
'lpre'        Name
':'           Operator
'l_pre'       Name
' '           Text
'pre'         Name
')'           Operator
' '           Text
'('           Operator
'#'           Operator
'frame'       Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
' '           Text
'('           Operator
'f_frame'     Name
':'           Operator
'fp_prop'     Name
' '           Text
'frame'       Name
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'l_pre'       Name
' '           Text
'('           Operator
'pre'         Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'fun'         Keyword
' '           Text
'h'           Name
' '           Text
'->'          Operator
' '           Text
'lpre'        Name
' '           Text
'h'           Name
' '           Text
'/\\'         Operator
' '           Text
'f_frame'     Name
' '           Text
'h'           Name
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'frame_lpost' Name
'\n      '    Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'pre'         Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'post'        Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'lpre'        Name
':'           Operator
'l_pre'       Name
' '           Text
'pre'         Name
')'           Operator
'\n      '    Text
'('           Operator
'lpost'       Name
':'           Operator
'l_post'      Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'frame'       Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'f_frame'     Name
':'           Operator
'fp_prop'     Name
' '           Text
'frame'       Name
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'l_post'      Name
' '           Text
'('           Operator
'pre'         Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
' '           Text
'('           Operator
'fun'         Keyword
' '           Text
'x'           Name
' '           Text
'->'          Operator
' '           Text
'post'        Name
' '           Text
'x'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'fun'         Keyword
' '           Text
'h0'          Name
' '           Text
'x'           Name
' '           Text
'h1'          Name
' '           Text
'->'          Operator
' '           Text
'lpre'        Name
' '           Text
'h0'          Name
' '           Text
'/\\'         Operator
' '           Text
'lpost'       Name
' '           Text
'h0'          Name
' '           Text
'x'           Name
' '           Text
'h1'          Name
' '           Text
'/\\'         Operator
' '           Text
'f_frame'     Name
' '           Text
'h1'          Name
'\n\n'        Text

'/// The bind rule bakes in weakening of requires / ensures' Comment
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'bind_lpre'   Name
'\n      '    Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'pre'         Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'post_a'      Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'lpre_a'      Name
':'           Operator
'l_pre'       Name
' '           Text
'pre'         Name
')'           Operator
'\n      '    Text
'('           Operator
'lpost_a'     Name
':'           Operator
'l_post'      Name
' '           Text
'pre'         Name
' '           Text
'post_a'      Name
')'           Operator
'\n      '    Text
'('           Operator
'lpre_b'      Name
':'           Operator
'('           Operator
'x'           Name
':'           Operator
'a'           Name
' '           Text
'->'          Operator
' '           Text
'l_pre'       Name
' '           Text
'('           Operator
'post_a'      Name
' '           Text
'x'           Name
')'           Operator
')'           Operator
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'l_pre'       Name
' '           Text
'pre'         Name
'\n    '      Text
'='           Operator
'\n  '        Text
'fun'         Keyword
' '           Text
'h'           Name
' '           Text
'->'          Operator
' '           Text
'lpre_a'      Name
' '           Text
'h'           Name
' '           Text
'/\\'         Operator
' '           Text
'('           Operator
'forall'      Keyword
' '           Text
'('           Operator
'x'           Name
':'           Operator
'a'           Name
')'           Operator
' '           Text
'h1'          Name
'.'           Operator
' '           Text
'lpost_a'     Name
' '           Text
'h'           Name
' '           Text
'x'           Name
' '           Text
'h1'          Name
' '           Text
'='           Operator
'='           Operator
'>'           Operator
' '           Text
'lpre_b'      Name
' '           Text
'x'           Name
' '           Text
'h1'          Name
')'           Operator
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'bind_lpost'  Name
'\n      '    Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'pre'         Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'post_a'      Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'lpre_a'      Name
':'           Operator
'l_pre'       Name
' '           Text
'pre'         Name
')'           Operator
'\n      '    Text
'('           Operator
'lpost_a'     Name
':'           Operator
'l_post'      Name
' '           Text
'pre'         Name
' '           Text
'post_a'      Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'b'           Name
':'           Operator
'Type'        Name.Class
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'post_b'      Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'b'           Name
')'           Operator
'\n      '    Text
'('           Operator
'lpost_b'     Name
':'           Operator
'('           Operator
'x'           Name
':'           Operator
'a'           Name
' '           Text
'->'          Operator
' '           Text
'l_post'      Name
' '           Text
'('           Operator
'post_a'      Name
' '           Text
'x'           Name
')'           Operator
' '           Text
'post_b'      Name
')'           Operator
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'l_post'      Name
' '           Text
'pre'         Name
' '           Text
'post_b'      Name
'\n    '      Text
'='           Operator
'\n  '        Text
'fun'         Keyword
' '           Text
'h0'          Name
' '           Text
'y'           Name
' '           Text
'h2'          Name
' '           Text
'->'          Operator
' '           Text
'lpre_a'      Name
' '           Text
'h0'          Name
' '           Text
'/\\'         Operator
' '           Text
'('           Operator
'exists'      Keyword
' '           Text
'x'           Name
' '           Text
'h1'          Name
'.'           Operator
' '           Text
'lpost_a'     Name
' '           Text
'h0'          Name
' '           Text
'x'           Name
' '           Text
'h1'          Name
' '           Text
'/\\'         Operator
' '           Text
'('           Operator
'lpost_b'     Name
' '           Text
'x'           Name
')'           Operator
' '           Text
'h1'          Name
' '           Text
'y'           Name
' '           Text
'h2'          Name
')'           Operator
'\n\n'        Text

'/// Parallel composition is pointwise' Comment
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'par_lpre'    Name
'\n       '   Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
'\n       '   Text
'('           Operator
'#'           Operator
'preL'        Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n       '   Text
'('           Operator
'lpreL'       Name
':'           Operator
'l_pre'       Name
' '           Text
'preL'        Name
')'           Operator
'\n       '   Text
'('           Operator
'#'           Operator
'preR'        Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n       '   Text
'('           Operator
'lpreR'       Name
':'           Operator
'l_pre'       Name
' '           Text
'preR'        Name
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'l_pre'       Name
' '           Text
'('           Operator
'preL'        Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'preR'        Name
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'fun'         Keyword
' '           Text
'h'           Name
' '           Text
'->'          Operator
' '           Text
'lpreL'       Name
' '           Text
'h'           Name
' '           Text
'/\\'         Operator
' '           Text
'lpreR'       Name
' '           Text
'h'           Name
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'par_lpost'   Name
'\n      '    Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'aL'          Name
':'           Operator
'Type'        Name.Class
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'preL'        Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'postL'       Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'aL'          Name
')'           Operator
'\n      '    Text
'('           Operator
'lpreL'       Name
':'           Operator
'l_pre'       Name
' '           Text
'preL'        Name
')'           Operator
'\n      '    Text
'('           Operator
'lpostL'      Name
':'           Operator
'l_post'      Name
' '           Text
'preL'        Name
' '           Text
'postL'       Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'aR'          Name
':'           Operator
'Type'        Name.Class
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'preR'        Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'postR'       Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'aR'          Name
')'           Operator
'\n      '    Text
'('           Operator
'lpreR'       Name
':'           Operator
'l_pre'       Name
' '           Text
'preR'        Name
')'           Operator
'\n      '    Text
'('           Operator
'lpostR'      Name
':'           Operator
'l_post'      Name
' '           Text
'preR'        Name
' '           Text
'postR'       Name
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'l_post'      Name
' '           Text
'('           Operator
'preL'        Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'preR'        Name
')'           Operator
' '           Text
'('           Operator
'fun'         Keyword
' '           Text
'('           Operator
'xL'          Name
','           Operator
' '           Text
'xR'          Name
')'           Operator
' '           Text
'->'          Operator
' '           Text
'postL'       Name
' '           Text
'xL'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'postR'       Name
' '           Text
'xR'          Name
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'fun'         Keyword
' '           Text
'h0'          Name
' '           Text
'('           Operator
'xL'          Name
','           Operator
' '           Text
'xR'          Name
')'           Operator
' '           Text
'h1'          Name
' '           Text
'->'          Operator
' '           Text
'lpreL'       Name
' '           Text
'h0'          Name
' '           Text
'/\\'         Operator
' '           Text
'lpreR'       Name
' '           Text
'h0'          Name
' '           Text
'/\\'         Operator
' '           Text
'lpostL'      Name
' '           Text
'h0'          Name
' '           Text
'xL'          Name
' '           Text
'h1'          Name
' '           Text
'/\\'         Operator
' '           Text
'lpostR'      Name
' '           Text
'h0'          Name
' '           Text
'xR'          Name
' '           Text
'h1'          Name
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'weaker_pre'  Name
' '           Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
' '           Text
'('           Operator
'pre'         Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
' '           Text
'('           Operator
'next_pre'    Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
' '           Text
'='           Operator
'\n  '        Text
'forall'      Keyword
' '           Text
'('           Operator
'h'           Name
':'           Operator
'st'          Name
'.'           Operator
'mem'         Name
')'           Operator
' '           Text
'('           Operator
'frame'       Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'.'           Operator
'\n    '      Text
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'('           Operator
'pre'         Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
' '           Text
'h'           Name
' '           Text
'='           Operator
'='           Operator
'>'           Operator
'\n    '      Text
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'('           Operator
'next_pre'    Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
' '           Text
'h'           Name
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'stronger_post' Name
' '           Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
' '           Text
'('           Operator
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
' '           Text
'u#'          Operator
'a'           Name
')'           Operator
' '           Text
'('           Operator
'post'        Name
' '           Text
'next_post'   Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
' '           Text
'='           Operator
'\n  '        Text
'forall'      Keyword
' '           Text
'('           Operator
'x'           Name
':'           Operator
'a'           Name
')'           Operator
' '           Text
'('           Operator
'h'           Name
':'           Operator
'st'          Name
'.'           Operator
'mem'         Name
')'           Operator
' '           Text
'('           Operator
'frame'       Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'.'           Operator
'\n    '      Text
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'('           Operator
'next_post'   Name
' '           Text
'x'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
' '           Text
'h'           Name
' '           Text
'='           Operator
'='           Operator
'>'           Operator
'\n    '      Text
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'('           Operator
'post'        Name
' '           Text
'x'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
' '           Text
'h'           Name
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'weakening_ok' Name
'\n      '    Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
' '           Text
'u#'          Operator
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'pre'         Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'post'        Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'lpre'        Name
':'           Operator
'l_pre'       Name
' '           Text
'pre'         Name
')'           Operator
'\n      '    Text
'('           Operator
'lpost'       Name
':'           Operator
'l_post'      Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'wpre'        Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'wpost'       Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'wlpre'       Name
':'           Operator
'l_pre'       Name
' '           Text
'wpre'        Name
')'           Operator
'\n      '    Text
'('           Operator
'wlpost'      Name
':'           Operator
'l_post'      Name
' '           Text
'wpre'        Name
' '           Text
'wpost'       Name
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'weaker_pre'  Name
' '           Text
'wpre'        Name
' '           Text
'pre'         Name
' '           Text
'/\\'         Operator
'\n  '        Text
'stronger_post' Name
' '           Text
'wpost'       Name
' '           Text
'post'        Name
' '           Text
'/\\'         Operator
'\n  '        Text
'('           Operator
'forall'      Keyword
' '           Text
'h'           Name
'.'           Operator
' '           Text
'wlpre'       Name
' '           Text
'h'           Name
' '           Text
'='           Operator
'='           Operator
'>'           Operator
' '           Text
'lpre'        Name
' '           Text
'h'           Name
')'           Operator
' '           Text
'/\\'         Operator
'\n  '        Text
'('           Operator
'forall'      Keyword
' '           Text
'h0'          Name
' '           Text
'x'           Name
' '           Text
'h1'          Name
'.'           Operator
' '           Text
'lpost'       Name
' '           Text
'h0'          Name
' '           Text
'x'           Name
' '           Text
'h1'          Name
' '           Text
'='           Operator
'='           Operator
'>'           Operator
' '           Text
'wlpost'      Name
' '           Text
'h0'          Name
' '           Text
'x'           Name
' '           Text
'h1'          Name
')'           Operator
'\n\n\n'      Text

'/// Setting the flag just to reduce the time to typecheck the type m' Comment
'\n\n'        Text

'#'           Operator
'push'        Name
'-'           Operator
'options'     Name
' '           Text
'"'           Literal.String.Double
'--__temp_no_proj Steel.Semantics.Hoare.MST' Literal.String.Double
'"'           Literal.String.Double
'\n'          Text

'noeq'        Keyword
'\n'          Text

'type'        Keyword
' '           Text
'm'           Name
' '           Text
'('           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
' '           Text
':'           Operator
'\n      '    Text
'a'           Name
':'           Operator
'Type'        Name.Class
' '           Text
'u#'          Operator
'a'           Name
' '           Text
'->'          Operator
'\n      '    Text
'pre'         Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
' '           Text
'->'          Operator
'\n      '    Text
'post'        Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
' '           Text
'->'          Operator
'\n      '    Text
'l_pre'       Name
' '           Text
'pre'         Name
' '           Text
'->'          Operator
'\n      '    Text
'l_post'      Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
' '           Text
'->'          Operator
' '           Text
'Type'        Name.Class
'\n    '      Text
'='           Operator
'\n  '        Text
'|'           Operator
' '           Text
'Ret'         Name.Class
':'           Operator
'\n    '      Text
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
' '           Text
'u#'          Operator
'a'           Name
' '           Text
'->'          Operator
'\n    '      Text
'post'        Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
' '           Text
'->'          Operator
'\n    '      Text
'x'           Name
':'           Operator
'a'           Name
' '           Text
'->'          Operator
'\n    '      Text
'lpost'       Name
':'           Operator
'l_post'      Name
' '           Text
'('           Operator
'post'        Name
' '           Text
'x'           Name
')'           Operator
' '           Text
'post'        Name
' '           Text
'->'          Operator
'\n    '      Text
'm'           Name
' '           Text
'st'          Name
' '           Text
'a'           Name
' '           Text
'('           Operator
'post'        Name
' '           Text
'x'           Name
')'           Operator
' '           Text
'post'        Name
' '           Text
'('           Operator
'return_lpre' Name
' '           Text
'#'           Operator
'_'           Name
' '           Text
'#'           Operator
'_'           Name
' '           Text
'#'           Operator
'post'        Name
' '           Text
'x'           Name
' '           Text
'lpost'       Name
')'           Operator
' '           Text
'lpost'       Name
'\n\n  '      Text
'|'           Operator
' '           Text
'Bind'        Name.Class
':'           Operator
'\n    '      Text
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
' '           Text
'u#'          Operator
'a'           Name
' '           Text
'->'          Operator
'\n    '      Text
'#'           Operator
'pre'         Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
' '           Text
'->'          Operator
'\n    '      Text
'#'           Operator
'post_a'      Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
' '           Text
'->'          Operator
'\n    '      Text
'#'           Operator
'lpre_a'      Name
':'           Operator
'l_pre'       Name
' '           Text
'pre'         Name
' '           Text
'->'          Operator
'\n    '      Text
'#'           Operator
'lpost_a'     Name
':'           Operator
'l_post'      Name
' '           Text
'pre'         Name
' '           Text
'post_a'      Name
' '           Text
'->'          Operator
'\n    '      Text
'#'           Operator
'b'           Name
':'           Operator
'Type'        Name.Class
' '           Text
'u#'          Operator
'a'           Name
' '           Text
'->'          Operator
'\n    '      Text
'#'           Operator
'post_b'      Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'b'           Name
' '           Text
'->'          Operator
'\n    '      Text
'#'           Operator
'lpre_b'      Name
':'           Operator
'('           Operator
'x'           Name
':'           Operator
'a'           Name
' '           Text
'->'          Operator
' '           Text
'l_pre'       Name
' '           Text
'('           Operator
'post_a'      Name
' '           Text
'x'           Name
')'           Operator
')'           Operator
' '           Text
'->'          Operator
'\n    '      Text
'#'           Operator
'lpost_b'     Name
':'           Operator
'('           Operator
'x'           Name
':'           Operator
'a'           Name
' '           Text
'->'          Operator
' '           Text
'l_post'      Name
' '           Text
'('           Operator
'post_a'      Name
' '           Text
'x'           Name
')'           Operator
' '           Text
'post_b'      Name
')'           Operator
' '           Text
'->'          Operator
'\n    '      Text
'f'           Name
':'           Operator
'm'           Name
' '           Text
'st'          Name
' '           Text
'a'           Name
' '           Text
'pre'         Name
' '           Text
'post_a'      Name
' '           Text
'lpre_a'      Name
' '           Text
'lpost_a'     Name
' '           Text
'->'          Operator
'\n    '      Text
'g'           Name
':'           Operator
'('           Operator
'x'           Name
':'           Operator
'a'           Name
' '           Text
'->'          Operator
' '           Text
'Dv'          Name.Class
' '           Text
'('           Operator
'm'           Name
' '           Text
'st'          Name
' '           Text
'b'           Name
' '           Text
'('           Operator
'post_a'      Name
' '           Text
'x'           Name
')'           Operator
' '           Text
'post_b'      Name
' '           Text
'('           Operator
'lpre_b'      Name
' '           Text
'x'           Name
')'           Operator
' '           Text
'('           Operator
'lpost_b'     Name
' '           Text
'x'           Name
')'           Operator
')'           Operator
')'           Operator
' '           Text
'->'          Operator
'\n    '      Text
'm'           Name
' '           Text
'st'          Name
' '           Text
'b'           Name
' '           Text
'pre'         Name
' '           Text
'post_b'      Name
'\n      '    Text
'('           Operator
'bind_lpre'   Name
' '           Text
'lpre_a'      Name
' '           Text
'lpost_a'     Name
' '           Text
'lpre_b'      Name
')'           Operator
'\n      '    Text
'('           Operator
'bind_lpost'  Name
' '           Text
'lpre_a'      Name
' '           Text
'lpost_a'     Name
' '           Text
'lpost_b'     Name
')'           Operator
'\n\n  '      Text
'|'           Operator
' '           Text
'Act'         Name.Class
':'           Operator
'\n    '      Text
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
' '           Text
'u#'          Operator
'a'           Name
' '           Text
'->'          Operator
'\n    '      Text
'#'           Operator
'pre'         Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
' '           Text
'->'          Operator
'\n    '      Text
'#'           Operator
'post'        Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
' '           Text
'->'          Operator
'\n    '      Text
'#'           Operator
'lpre'        Name
':'           Operator
'l_pre'       Name
' '           Text
'pre'         Name
' '           Text
'->'          Operator
'\n    '      Text
'#'           Operator
'lpost'       Name
':'           Operator
'l_post'      Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
' '           Text
'->'          Operator
'\n    '      Text
'f'           Name
':'           Operator
'action_t'    Name
' '           Text
'#'           Operator
'st'          Name
' '           Text
'#'           Operator
'a'           Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
' '           Text
'lpre'        Name
' '           Text
'lpost'       Name
' '           Text
'->'          Operator
'\n    '      Text
'm'           Name
' '           Text
'st'          Name
' '           Text
'a'           Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
' '           Text
'lpre'        Name
' '           Text
'lpost'       Name
'\n\n  '      Text
'|'           Operator
' '           Text
'Frame'       Name.Class
':'           Operator
'\n    '      Text
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
' '           Text
'->'          Operator
'\n    '      Text
'#'           Operator
'pre'         Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
' '           Text
'->'          Operator
'\n    '      Text
'#'           Operator
'post'        Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
' '           Text
'->'          Operator
'\n    '      Text
'#'           Operator
'lpre'        Name
':'           Operator
'l_pre'       Name
' '           Text
'pre'         Name
' '           Text
'->'          Operator
'\n    '      Text
'#'           Operator
'lpost'       Name
':'           Operator
'l_post'      Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
' '           Text
'->'          Operator
'\n    '      Text
'f'           Name
':'           Operator
'm'           Name
' '           Text
'st'          Name
' '           Text
'a'           Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
' '           Text
'lpre'        Name
' '           Text
'lpost'       Name
' '           Text
'->'          Operator
'\n    '      Text
'frame'       Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
' '           Text
'->'          Operator
'\n    '      Text
'f_frame'     Name
':'           Operator
'fp_prop'     Name
' '           Text
'frame'       Name
' '           Text
'->'          Operator
'\n    '      Text
'm'           Name
' '           Text
'st'          Name
' '           Text
'a'           Name
' '           Text
'('           Operator
'pre'         Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
' '           Text
'('           Operator
'fun'         Keyword
' '           Text
'x'           Name
' '           Text
'->'          Operator
' '           Text
'post'        Name
' '           Text
'x'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
'\n      '    Text
'('           Operator
'frame_lpre'  Name
' '           Text
'lpre'        Name
' '           Text
'f_frame'     Name
')'           Operator
'\n      '    Text
'('           Operator
'frame_lpost' Name
' '           Text
'lpre'        Name
' '           Text
'lpost'       Name
' '           Text
'f_frame'     Name
')'           Operator
'\n\n  '      Text
'|'           Operator
' '           Text
'Par'         Name.Class
':'           Operator
'\n    '      Text
'#'           Operator
'aL'          Name
':'           Operator
'Type'        Name.Class
' '           Text
'u#'          Operator
'a'           Name
' '           Text
'->'          Operator
'\n    '      Text
'#'           Operator
'preL'        Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
' '           Text
'->'          Operator
'\n    '      Text
'#'           Operator
'postL'       Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'aL'          Name
' '           Text
'->'          Operator
'\n    '      Text
'#'           Operator
'lpreL'       Name
':'           Operator
'l_pre'       Name
' '           Text
'preL'        Name
' '           Text
'->'          Operator
'\n    '      Text
'#'           Operator
'lpostL'      Name
':'           Operator
'l_post'      Name
' '           Text
'preL'        Name
' '           Text
'postL'       Name
' '           Text
'->'          Operator
'\n    '      Text
'mL'          Name
':'           Operator
'm'           Name
' '           Text
'st'          Name
' '           Text
'aL'          Name
' '           Text
'preL'        Name
' '           Text
'postL'       Name
' '           Text
'lpreL'       Name
' '           Text
'lpostL'      Name
' '           Text
'->'          Operator
'\n    '      Text
'#'           Operator
'aR'          Name
':'           Operator
'Type'        Name.Class
' '           Text
'u#'          Operator
'a'           Name
' '           Text
'->'          Operator
'\n    '      Text
'#'           Operator
'preR'        Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
' '           Text
'->'          Operator
'\n    '      Text
'#'           Operator
'postR'       Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'aR'          Name
' '           Text
'->'          Operator
'\n    '      Text
'#'           Operator
'lpreR'       Name
':'           Operator
'l_pre'       Name
' '           Text
'preR'        Name
' '           Text
'->'          Operator
'\n    '      Text
'#'           Operator
'lpostR'      Name
':'           Operator
'l_post'      Name
' '           Text
'preR'        Name
' '           Text
'postR'       Name
' '           Text
'->'          Operator
'\n    '      Text
'mR'          Name
':'           Operator
'm'           Name
' '           Text
'st'          Name
' '           Text
'aR'          Name
' '           Text
'preR'        Name
' '           Text
'postR'       Name
' '           Text
'lpreR'       Name
' '           Text
'lpostR'      Name
' '           Text
'->'          Operator
'\n    '      Text
'm'           Name
' '           Text
'st'          Name
' '           Text
'('           Operator
'aL'          Name
' '           Text
'&'           Operator
' '           Text
'aR'          Name
')'           Operator
' '           Text
'('           Operator
'preL'        Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'preR'        Name
')'           Operator
' '           Text
'('           Operator
'fun'         Keyword
' '           Text
'('           Operator
'xL'          Name
','           Operator
' '           Text
'xR'          Name
')'           Operator
' '           Text
'->'          Operator
' '           Text
'postL'       Name
' '           Text
'xL'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'postR'       Name
' '           Text
'xR'          Name
')'           Operator
'\n      '    Text
'('           Operator
'par_lpre'    Name
' '           Text
'lpreL'       Name
' '           Text
'lpreR'       Name
')'           Operator
'\n      '    Text
'('           Operator
'par_lpost'   Name
' '           Text
'lpreL'       Name
' '           Text
'lpostL'      Name
' '           Text
'lpreR'       Name
' '           Text
'lpostR'      Name
')'           Operator
'\n\n  '      Text
'|'           Operator
' '           Text
'Weaken'      Name.Class
':'           Operator
'\n    '      Text
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
' '           Text
'u#'          Operator
'a'           Name
' '           Text
'->'          Operator
'\n    '      Text
'#'           Operator
'pre'         Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
' '           Text
'->'          Operator
'\n    '      Text
'#'           Operator
'post'        Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
' '           Text
'->'          Operator
'\n    '      Text
'#'           Operator
'lpre'        Name
':'           Operator
'l_pre'       Name
' '           Text
'pre'         Name
' '           Text
'->'          Operator
'\n    '      Text
'#'           Operator
'lpost'       Name
':'           Operator
'l_post'      Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
' '           Text
'->'          Operator
'\n    '      Text
'#'           Operator
'wpre'        Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
' '           Text
'->'          Operator
'\n    '      Text
'#'           Operator
'wpost'       Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
' '           Text
'->'          Operator
'\n    '      Text
'wlpre'       Name
':'           Operator
'l_pre'       Name
' '           Text
'wpre'        Name
' '           Text
'->'          Operator
'\n    '      Text
'wlpost'      Name
':'           Operator
'l_post'      Name
' '           Text
'wpre'        Name
' '           Text
'wpost'       Name
' '           Text
'->'          Operator
'\n    '      Text
'_'           Name
':'           Operator
'squash'      Name
' '           Text
'('           Operator
'weakening_ok' Name
' '           Text
'lpre'        Name
' '           Text
'lpost'       Name
' '           Text
'wlpre'       Name
' '           Text
'wlpost'      Name
')'           Operator
' '           Text
'->'          Operator
'\n    '      Text
'm'           Name
' '           Text
'st'          Name
' '           Text
'a'           Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
' '           Text
'lpre'        Name
' '           Text
'lpost'       Name
' '           Text
'->'          Operator
'\n    '      Text
'm'           Name
' '           Text
'st'          Name
' '           Text
'a'           Name
' '           Text
'wpre'        Name
' '           Text
'wpost'       Name
' '           Text
'wlpre'       Name
' '           Text
'wlpost'      Name
'\n'          Text

'#'           Operator
'pop'         Name
'-'           Operator
'options'     Name
'\n\n'        Text

'(*'          Comment
'*'           Comment
'*'           Comment
'*'           Comment
' End definition of the computation AST ' Comment
'*'           Comment
'*'           Comment
'*'           Comment
'*)'          Comment
'\n\n\n'      Text

'(*'          Comment
'*'           Comment
'*'           Comment
'*'           Comment
' Stepping relation ' Comment
'*'           Comment
'*'           Comment
'*'           Comment
'*)'          Comment
'\n\n'        Text

'/// All steps preserve frames' Comment
'\n\n'        Text

'noeq'        Keyword
'\n'          Text

'type'        Keyword
' '           Text
'step_result' Name
' '           Text
'('           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
' '           Text
'('           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
' '           Text
'u#'          Operator
'a'           Name
')'           Operator
' '           Text
'='           Operator
'\n  '        Text
'|'           Operator
' '           Text
'Step'        Name.Class
':'           Operator
'\n    '      Text
'next_pre'    Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
' '           Text
'->'          Operator
'\n    '      Text
'next_post'   Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
' '           Text
'->'          Operator
'\n    '      Text
'lpre'        Name
':'           Operator
'l_pre'       Name
' '           Text
'next_pre'    Name
' '           Text
'->'          Operator
'\n    '      Text
'lpost'       Name
':'           Operator
'l_post'      Name
' '           Text
'next_pre'    Name
' '           Text
'next_post'   Name
' '           Text
'->'          Operator
'\n    '      Text
'm'           Name
' '           Text
'st'          Name
' '           Text
'a'           Name
' '           Text
'next_pre'    Name
' '           Text
'next_post'   Name
' '           Text
'lpre'        Name
' '           Text
'lpost'       Name
' '           Text
'->'          Operator
'\n    '      Text
'step_result' Name
' '           Text
'st'          Name
' '           Text
'a'           Name
'\n\n\n'      Text

'(*'          Comment
'*'           Comment
'*'           Comment
'*'           Comment
' Type of the single-step interpreter ' Comment
'*'           Comment
'*'           Comment
'*'           Comment
'*)'          Comment
'\n\n\n'      Text

'/// Interpreter is setup as a Div function from computation trees to computation trees' Comment
'\n'          Text

'///'         Comment
'\n'          Text

'/// While the requires for the Div is standard (that the expects hprop holds and requires is valid),' Comment
'\n'          Text

'///   the ensures is interesting' Comment
'\n'          Text

'///'         Comment
'\n'          Text

'/// As the computation evolves, the requires and ensures associated with the computation graph nodes' Comment
'\n'          Text

'///   also evolve' Comment
'\n'          Text

'/// But they evolve systematically: preconditions become weaker and postconditions become stronger' Comment
'\n'          Text

'///'         Comment
'\n'          Text

'/// Consider { req } c | st { ens }  ~~> { req1 } c1 | st1 { ens1 }' Comment
'\n'          Text

'///'         Comment
'\n'          Text

'/// Then, req st ==> req1 st1  /\\' Comment
'\n'          Text

'///       (forall x st_final. ens1 st1 x st_final ==> ens st x st_final)' Comment
'\n\n\n'      Text

'unfold'      Keyword
'\n'          Text

'let'         Keyword.Declaration
' '           Text
'step_req'    Name
'\n      '    Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
' '           Text
'u#'          Operator
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'pre'         Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'post'        Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'lpre'        Name
':'           Operator
'l_pre'       Name
' '           Text
'pre'         Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'lpost'       Name
':'           Operator
'l_post'      Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
')'           Operator
'\n      '    Text
'('           Operator
'f'           Name
':'           Operator
'm'           Name
' '           Text
'st'          Name
' '           Text
'a'           Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
' '           Text
'lpre'        Name
' '           Text
'lpost'       Name
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'st'          Name
'.'           Operator
'mem'         Name
' '           Text
'->'          Operator
' '           Text
'Type0'       Name.Class
'\n    '      Text
'='           Operator
'\n  '        Text
'fun'         Keyword
' '           Text
'm0'          Name
' '           Text
'->'          Operator
'\n    '      Text
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'('           Operator
'pre'         Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm0'          Name
')'           Operator
' '           Text
'm0'          Name
' '           Text
'/\\'         Operator
'\n    '      Text
'lpre'        Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'core'        Name
' '           Text
'm0'          Name
')'           Operator
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'weaker_lpre' Name
'\n      '    Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'pre'         Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'lpre'        Name
':'           Operator
'l_pre'       Name
' '           Text
'pre'         Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'next_pre'    Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'next_lpre'   Name
':'           Operator
'l_pre'       Name
' '           Text
'next_pre'    Name
')'           Operator
'\n      '    Text
'('           Operator
'm0'          Name
' '           Text
'm1'          Name
':'           Operator
'st'          Name
'.'           Operator
'mem'         Name
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'lpre'        Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'core'        Name
' '           Text
'm0'          Name
')'           Operator
' '           Text
'='           Operator
'='           Operator
'>'           Operator
' '           Text
'next_lpre'   Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'core'        Name
' '           Text
'm1'          Name
')'           Operator
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'stronger_lpost' Name
'\n      '    Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
' '           Text
'u#'          Operator
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'pre'         Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'post'        Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'lpost'       Name
':'           Operator
'l_post'      Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'next_pre'    Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'#'           Operator
'next_post'   Name
'\n      '    Text
'('           Operator
'next_lpost'  Name
':'           Operator
'l_post'      Name
' '           Text
'next_pre'    Name
' '           Text
'next_post'   Name
')'           Operator
'\n      '    Text
'('           Operator
'm0'          Name
' '           Text
'm1'          Name
':'           Operator
'st'          Name
'.'           Operator
'mem'         Name
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'forall'      Keyword
' '           Text
'('           Operator
'x'           Name
':'           Operator
'a'           Name
')'           Operator
' '           Text
'('           Operator
'h_final'     Name
':'           Operator
'st'          Name
'.'           Operator
'mem'         Name
')'           Operator
'.'           Operator
'\n    '      Text
'next_lpost'  Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'core'        Name
' '           Text
'm1'          Name
')'           Operator
' '           Text
'x'           Name
' '           Text
'h_final'     Name
' '           Text
'='           Operator
'='           Operator
'>'           Operator
'\n    '      Text
'lpost'       Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'core'        Name
' '           Text
'm0'          Name
')'           Operator
' '           Text
'x'           Name
' '           Text
'h_final'     Name
'\n\n'        Text

'unfold'      Keyword
'\n'          Text

'let'         Keyword.Declaration
' '           Text
'step_ens'    Name
'\n      '    Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
' '           Text
'u#'          Operator
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'pre'         Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'post'        Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'lpre'        Name
':'           Operator
'l_pre'       Name
' '           Text
'pre'         Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'lpost'       Name
':'           Operator
'l_post'      Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
')'           Operator
'\n      '    Text
'('           Operator
'f'           Name
':'           Operator
'm'           Name
' '           Text
'st'          Name
' '           Text
'a'           Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
' '           Text
'lpre'        Name
' '           Text
'lpost'       Name
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'st'          Name
'.'           Operator
'mem'         Name
' '           Text
'->'          Operator
' '           Text
'step_result' Name
' '           Text
'st'          Name
' '           Text
'a'           Name
' '           Text
'->'          Operator
' '           Text
'st'          Name
'.'           Operator
'mem'         Name
' '           Text
'->'          Operator
' '           Text
'Type0'       Name.Class
'\n    '      Text
'='           Operator
'\n  '        Text
'fun'         Keyword
' '           Text
'm0'          Name
' '           Text
'r'           Name
' '           Text
'm1'          Name
' '           Text
'->'          Operator
'\n    '      Text
'let'         Keyword.Declaration
' '           Text
'Step'        Name.Class
' '           Text
'next_pre'    Name
' '           Text
'next_post'   Name
' '           Text
'next_lpre'   Name
' '           Text
'next_lpost'  Name
' '           Text
'_'           Name
' '           Text
'='           Operator
' '           Text
'r'           Name
' '           Text
'in'          Keyword
'\n    '      Text
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'('           Operator
'next_pre'    Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm1'          Name
')'           Operator
' '           Text
'm1'          Name
' '           Text
'/\\'         Operator
'\n    '      Text
'stronger_post' Name
' '           Text
'post'        Name
' '           Text
'next_post'   Name
' '           Text
'/\\'         Operator
'\n    '      Text
'next_lpre'   Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'core'        Name
' '           Text
'm1'          Name
')'           Operator
' '           Text
'/\\'         Operator
'\n    '      Text
'preserves_frame' Name
' '           Text
'pre'         Name
' '           Text
'next_pre'    Name
' '           Text
'm0'          Name
' '           Text
'm1'          Name
' '           Text
'/\\'         Operator
'\n    '      Text
'weaker_lpre' Name
' '           Text
'lpre'        Name
' '           Text
'next_lpre'   Name
' '           Text
'm0'          Name
' '           Text
'm1'          Name
' '           Text
'/\\'         Operator
'\n    '      Text
'stronger_lpost' Name
' '           Text
'lpost'       Name
' '           Text
'next_lpost'  Name
' '           Text
'm0'          Name
' '           Text
'm1'          Name
'\n\n\n'      Text

'/// The type of the stepping function' Comment
'\n\n'        Text

'type'        Keyword
' '           Text
'step_t'      Name
' '           Text
'='           Operator
'\n  '        Text
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
' '           Text
'->'          Operator
'\n  '        Text
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
' '           Text
'u#'          Operator
'a'           Name
' '           Text
'->'          Operator
'\n  '        Text
'#'           Operator
'pre'         Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
' '           Text
'->'          Operator
'\n  '        Text
'#'           Operator
'post'        Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
' '           Text
'->'          Operator
'\n  '        Text
'#'           Operator
'lpre'        Name
':'           Operator
'l_pre'       Name
' '           Text
'pre'         Name
' '           Text
'->'          Operator
'\n  '        Text
'#'           Operator
'lpost'       Name
':'           Operator
'l_post'      Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
' '           Text
'->'          Operator
'\n  '        Text
'f'           Name
':'           Operator
'm'           Name
' '           Text
'st'          Name
' '           Text
'a'           Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
' '           Text
'lpre'        Name
' '           Text
'lpost'       Name
' '           Text
'->'          Operator
'\n  '        Text
'Mst'         Name.Class
' '           Text
'('           Operator
'step_result' Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
' '           Text
'('           Operator
'step_req'    Name
' '           Text
'f'           Name
')'           Operator
' '           Text
'('           Operator
'step_ens'    Name
' '           Text
'f'           Name
')'           Operator
'\n\n\n'      Text

'(*'          Comment
'*'           Comment
'*'           Comment
'*'           Comment
' Auxiliary lemmas ' Comment
'*'           Comment
'*'           Comment
'*'           Comment
'*)'          Comment
'\n\n'        Text

'/// Some AC lemmas on `st.star`' Comment
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'apply_assoc' Name
' '           Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
' '           Text
'('           Operator
'p'           Name
' '           Text
'q'           Name
' '           Text
'r'           Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'Lemma'       Name.Class
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'equals'      Name
' '           Text
'('           Operator
'p'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'q'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'r'           Name
')'           Operator
')'           Operator
' '           Text
'('           Operator
'('           Operator
'p'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'q'           Name
')'           Operator
' '           Text
'`st.star`'   Operator.Word
' '           Text
'r'           Name
')'           Operator
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'()'          Name.Builtin.Pseudo
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'equals_ext_left' Name
' '           Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
' '           Text
'('           Operator
'p'           Name
' '           Text
'q'           Name
' '           Text
'r'           Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'Lemma'       Name.Class
'\n      '    Text
'('           Operator
'requires'    Keyword
' '           Text
'p'           Name
' '           Text
'`st.equals`' Operator.Word
' '           Text
'q'           Name
')'           Operator
'\n      '    Text
'('           Operator
'ensures'     Keyword
' '           Text
'('           Operator
'p'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'r'           Name
')'           Operator
' '           Text
'`st.equals`' Operator.Word
' '           Text
'('           Operator
'q'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'r'           Name
')'           Operator
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'()'          Name.Builtin.Pseudo
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'equals_ext_right' Name
' '           Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
' '           Text
'('           Operator
'p'           Name
' '           Text
'q'           Name
' '           Text
'r'           Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'Lemma'       Name.Class
'\n      '    Text
'('           Operator
'requires'    Keyword
' '           Text
'q'           Name
' '           Text
'`st.equals`' Operator.Word
' '           Text
'r'           Name
')'           Operator
'\n      '    Text
'('           Operator
'ensures'     Keyword
' '           Text
'('           Operator
'p'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'q'           Name
')'           Operator
' '           Text
'`st.equals`' Operator.Word
' '           Text
'('           Operator
'p'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'r'           Name
')'           Operator
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'calc'        Name.Exception
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'equals'      Name
')'           Operator
' '           Text
'{'           Operator
'\n    '      Text
'p'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'q'           Name
';'           Operator
'\n       '   Text
'('           Operator
'st'          Name
'.'           Operator
'equals'      Name
')'           Operator
' '           Text
'{'           Operator
' '           Text
'}'           Operator
'\n    '      Text
'q'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'p'           Name
';'           Operator
'\n       '   Text
'('           Operator
'st'          Name
'.'           Operator
'equals'      Name
')'           Operator
' '           Text
'{'           Operator
' '           Text
'}'           Operator
'\n    '      Text
'r'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'p'           Name
';'           Operator
'\n       '   Text
'('           Operator
'st'          Name
'.'           Operator
'equals'      Name
')'           Operator
' '           Text
'{'           Operator
' '           Text
'}'           Operator
'\n    '      Text
'p'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'r'           Name
';'           Operator
'\n  '        Text
'}'           Operator
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'commute_star_right' Name
' '           Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
' '           Text
'('           Operator
'p'           Name
' '           Text
'q'           Name
' '           Text
'r'           Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'Lemma'       Name.Class
'\n      '    Text
'('           Operator
'('           Operator
'p'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'q'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'r'           Name
')'           Operator
')'           Operator
' '           Text
'`st.equals`' Operator.Word
'\n        '  Text
'('           Operator
'p'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'r'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'q'           Name
')'           Operator
')'           Operator
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'calc'        Name.Exception
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'equals'      Name
')'           Operator
' '           Text
'{'           Operator
'\n    '      Text
'p'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'q'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'r'           Name
')'           Operator
';'           Operator
'\n       '   Text
'('           Operator
'st'          Name
'.'           Operator
'equals'      Name
')'           Operator
' '           Text
'{'           Operator
' '           Text
'equals_ext_right' Name
' '           Text
'p'           Name
' '           Text
'('           Operator
'q'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'r'           Name
')'           Operator
' '           Text
'('           Operator
'r'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'q'           Name
')'           Operator
' '           Text
'}'           Operator
'\n    '      Text
'p'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'r'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'q'           Name
')'           Operator
';'           Operator
'\n  '        Text
'}'           Operator
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'assoc_star_right' Name
' '           Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
' '           Text
'('           Operator
'p'           Name
' '           Text
'q'           Name
' '           Text
'r'           Name
' '           Text
's'           Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'Lemma'       Name.Class
'\n      '    Text
'('           Operator
'('           Operator
'p'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'('           Operator
'q'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'r'           Name
')'           Operator
' '           Text
'`st.star`'   Operator.Word
' '           Text
's'           Name
')'           Operator
')'           Operator
' '           Text
'`st.equals`' Operator.Word
'\n        '  Text
'('           Operator
'p'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'q'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'r'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
's'           Name
')'           Operator
')'           Operator
')'           Operator
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'calc'        Name.Exception
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'equals'      Name
')'           Operator
' '           Text
'{'           Operator
'\n    '      Text
'p'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'('           Operator
'q'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'r'           Name
')'           Operator
' '           Text
'`st.star`'   Operator.Word
' '           Text
's'           Name
')'           Operator
';'           Operator
'\n       '   Text
'('           Operator
'st'          Name
'.'           Operator
'equals'      Name
')'           Operator
' '           Text
'{'           Operator
' '           Text
'equals_ext_right' Name
' '           Text
'p'           Name
' '           Text
'('           Operator
'('           Operator
'q'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'r'           Name
')'           Operator
' '           Text
'`st.star`'   Operator.Word
' '           Text
's'           Name
')'           Operator
'\n                                        ' Text
'('           Operator
'q'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'r'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
's'           Name
')'           Operator
')'           Operator
' '           Text
'}'           Operator
'\n    '      Text
'p'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'q'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'r'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
's'           Name
')'           Operator
')'           Operator
';'           Operator
'\n  '        Text
'}'           Operator
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'commute_assoc_star_right' Name
' '           Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
' '           Text
'('           Operator
'p'           Name
' '           Text
'q'           Name
' '           Text
'r'           Name
' '           Text
's'           Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'Lemma'       Name.Class
'\n      '    Text
'('           Operator
'('           Operator
'p'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'('           Operator
'q'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'r'           Name
')'           Operator
' '           Text
'`st.star`'   Operator.Word
' '           Text
's'           Name
')'           Operator
')'           Operator
' '           Text
'`st.equals`' Operator.Word
'\n        '  Text
'('           Operator
'p'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'r'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'q'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
's'           Name
')'           Operator
')'           Operator
')'           Operator
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'calc'        Name.Exception
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'equals'      Name
')'           Operator
' '           Text
'{'           Operator
'\n    '      Text
'p'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'('           Operator
'q'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'r'           Name
')'           Operator
' '           Text
'`st.star`'   Operator.Word
' '           Text
's'           Name
')'           Operator
';'           Operator
'\n       '   Text
'('           Operator
'st'          Name
'.'           Operator
'equals'      Name
')'           Operator
' '           Text
'{'           Operator
' '           Text
'equals_ext_right' Name
' '           Text
'p'           Name
'\n                       ' Text
'('           Operator
'('           Operator
'q'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'r'           Name
')'           Operator
' '           Text
'`st.star`'   Operator.Word
' '           Text
's'           Name
')'           Operator
'\n                       ' Text
'('           Operator
'('           Operator
'r'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'q'           Name
')'           Operator
' '           Text
'`st.star`'   Operator.Word
' '           Text
's'           Name
')'           Operator
' '           Text
'}'           Operator
'\n    '      Text
'p'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'('           Operator
'r'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'q'           Name
')'           Operator
' '           Text
'`st.star`'   Operator.Word
' '           Text
's'           Name
')'           Operator
';'           Operator
'\n       '   Text
'('           Operator
'st'          Name
'.'           Operator
'equals'      Name
')'           Operator
' '           Text
'{'           Operator
' '           Text
'assoc_star_right' Name
' '           Text
'p'           Name
' '           Text
'r'           Name
' '           Text
'q'           Name
' '           Text
's'           Name
' '           Text
'}'           Operator
'\n    '      Text
'p'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'r'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'q'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
's'           Name
')'           Operator
')'           Operator
';'           Operator
'\n  '        Text
'}'           Operator
'\n\n\n'      Text

'/// Apply extensionality manually, control proofs' Comment
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'apply_interp_ext' Name
' '           Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
' '           Text
'('           Operator
'p'           Name
' '           Text
'q'           Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
' '           Text
'('           Operator
'm'           Name
':'           Operator
'st'          Name
'.'           Operator
'mem'         Name
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'Lemma'       Name.Class
'\n      '    Text
'('           Operator
'requires'    Keyword
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'p'           Name
' '           Text
'm'           Name
' '           Text
'/\\'         Operator
' '           Text
'p'           Name
' '           Text
'`st.equals`' Operator.Word
' '           Text
'q'           Name
')'           Operator
')'           Operator
'\n      '    Text
'('           Operator
'ensures'     Keyword
' '           Text
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'q'           Name
' '           Text
'm'           Name
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'()'          Name.Builtin.Pseudo
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'weaken_fp_prop' Name
' '           Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
' '           Text
'('           Operator
'frame'       Name
' '           Text
"frame'"      Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
' '           Text
'('           Operator
'm0'          Name
' '           Text
'm1'          Name
':'           Operator
'st'          Name
'.'           Operator
'mem'         Name
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'Lemma'       Name.Class
'\n      '    Text
'('           Operator
'requires'    Keyword
'\n        '  Text
'forall'      Keyword
' '           Text
'('           Operator
'f_frame'     Name
':'           Operator
'fp_prop'     Name
' '           Text
'('           Operator
'frame'       Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
"frame'"      Name
')'           Operator
')'           Operator
'.'           Operator
'\n          ' Text
'f_frame'     Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'core'        Name
' '           Text
'm0'          Name
')'           Operator
' '           Text
'='           Operator
'='           Operator
' '           Text
'f_frame'     Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'core'        Name
' '           Text
'm1'          Name
')'           Operator
')'           Operator
'\n     '     Text
'('           Operator
'ensures'     Keyword
'\n       '   Text
'forall'      Keyword
' '           Text
'('           Operator
'f_frame'     Name
':'           Operator
'fp_prop'     Name
' '           Text
"frame'"      Name
')'           Operator
'.'           Operator
'\n         ' Text
'f_frame'     Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'core'        Name
' '           Text
'm0'          Name
')'           Operator
' '           Text
'='           Operator
'='           Operator
' '           Text
'f_frame'     Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'core'        Name
' '           Text
'm1'          Name
')'           Operator
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'()'          Name.Builtin.Pseudo
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'depends_only_on_commutes_with_weaker' Name
'\n      '    Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
'\n      '    Text
'('           Operator
'q'           Name
':'           Operator
'st'          Name
'.'           Operator
'mem'         Name
' '           Text
'->'          Operator
' '           Text
'prop'        Name
')'           Operator
'\n      '    Text
'('           Operator
'fp'          Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'fp_next'     Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'Lemma'       Name.Class
'\n      '    Text
'('           Operator
'requires'    Keyword
' '           Text
'depends_only_on' Name
' '           Text
'q'           Name
' '           Text
'fp'          Name
' '           Text
'/\\'         Operator
' '           Text
'weaker_pre'  Name
' '           Text
'fp_next'     Name
' '           Text
'fp'          Name
')'           Operator
'\n      '    Text
'('           Operator
'ensures'     Keyword
' '           Text
'depends_only_on' Name
' '           Text
'q'           Name
' '           Text
'fp_next'     Name
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'assert'      Name.Exception
' '           Text
'('           Operator
'forall'      Keyword
' '           Text
'('           Operator
'h0'          Name
':'           Operator
'fp_heap_0'   Name
' '           Text
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'fp_next'     Name
')'           Operator
'.'           Operator
' '           Text
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'('           Operator
'fp_next'     Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'st'          Name
'.'           Operator
'emp'         Name
')'           Operator
' '           Text
'h0'          Name
')'           Operator
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'depends_only_on2_commutes_with_weaker' Name
'\n      '    Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
')'           Operator
'\n      '    Text
'('           Operator
'q'           Name
':'           Operator
'st'          Name
'.'           Operator
'mem'         Name
' '           Text
'->'          Operator
' '           Text
'a'           Name
' '           Text
'->'          Operator
' '           Text
'st'          Name
'.'           Operator
'mem'         Name
' '           Text
'->'          Operator
' '           Text
'prop'        Name
')'           Operator
'\n      '    Text
'('           Operator
'fp'          Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'fp_next'     Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'fp_post'     Name
':'           Operator
'a'           Name
' '           Text
'->'          Operator
' '           Text
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'Lemma'       Name.Class
'\n      '    Text
'('           Operator
'requires'    Keyword
' '           Text
'depends_only_on2' Name
' '           Text
'q'           Name
' '           Text
'fp'          Name
' '           Text
'fp_post'     Name
' '           Text
'/\\'         Operator
' '           Text
'weaker_pre'  Name
' '           Text
'fp_next'     Name
' '           Text
'fp'          Name
')'           Operator
'\n      '    Text
'('           Operator
'ensures'     Keyword
' '           Text
'depends_only_on2' Name
' '           Text
'q'           Name
' '           Text
'fp_next'     Name
' '           Text
'fp_post'     Name
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'assert'      Name.Exception
' '           Text
'('           Operator
'forall'      Keyword
' '           Text
'('           Operator
'h0'          Name
':'           Operator
'fp_heap_0'   Name
' '           Text
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'fp_next'     Name
')'           Operator
'.'           Operator
' '           Text
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'('           Operator
'fp_next'     Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'st'          Name
'.'           Operator
'emp'         Name
')'           Operator
' '           Text
'h0'          Name
')'           Operator
'\n\n'        Text

'/// Lemmas about preserves_frame' Comment
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'preserves_frame_trans' Name
'\n      '    Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
'\n      '    Text
'('           Operator
'hp1'         Name
' '           Text
'hp2'         Name
' '           Text
'hp3'         Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'm1'          Name
' '           Text
'm2'          Name
' '           Text
'm3'          Name
':'           Operator
'st'          Name
'.'           Operator
'mem'         Name
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'Lemma'       Name.Class
'\n      '    Text
'('           Operator
'requires'    Keyword
' '           Text
'preserves_frame' Name
' '           Text
'hp1'         Name
' '           Text
'hp2'         Name
' '           Text
'm1'          Name
' '           Text
'm2'          Name
' '           Text
'/\\'         Operator
' '           Text
'preserves_frame' Name
' '           Text
'hp2'         Name
' '           Text
'hp3'         Name
' '           Text
'm2'          Name
' '           Text
'm3'          Name
')'           Operator
'\n      '    Text
'('           Operator
'ensures'     Keyword
' '           Text
'preserves_frame' Name
' '           Text
'hp1'         Name
' '           Text
'hp3'         Name
' '           Text
'm1'          Name
' '           Text
'm3'          Name
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'()'          Name.Builtin.Pseudo
'\n\n'        Text

'#'           Operator
'push'        Name
'-'           Operator
'options'     Name
' '           Text
'"'           Literal.String.Double
'--warn_error -271' Literal.String.Double
'"'           Literal.String.Double
'\n'          Text

'let'         Keyword.Declaration
' '           Text
'preserves_frame_stronger_post' Name
'\n      '    Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
')'           Operator
'\n      '    Text
'('           Operator
'pre'         Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'post'        Name
' '           Text
'post_s'      Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'x'           Name
':'           Operator
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'm1'          Name
' '           Text
'm2'          Name
':'           Operator
'st'          Name
'.'           Operator
'mem'         Name
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'Lemma'       Name.Class
'\n      '    Text
'('           Operator
'requires'    Keyword
' '           Text
'preserves_frame' Name
' '           Text
'pre'         Name
' '           Text
'('           Operator
'post_s'      Name
' '           Text
'x'           Name
')'           Operator
' '           Text
'm1'          Name
' '           Text
'm2'          Name
' '           Text
'/\\'         Operator
' '           Text
'stronger_post' Name
' '           Text
'post'        Name
' '           Text
'post_s'      Name
')'           Operator
'\n      '    Text
'('           Operator
'ensures'     Keyword
' '           Text
'preserves_frame' Name
' '           Text
'pre'         Name
' '           Text
'('           Operator
'post'        Name
' '           Text
'x'           Name
')'           Operator
' '           Text
'm1'          Name
' '           Text
'm2'          Name
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'let'         Keyword.Declaration
' '           Text
'aux'         Name
' '           Text
'('           Operator
'frame'       Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
':'           Operator
' '           Text
'Lemma'       Name.Class
'\n        '  Text
'('           Operator
'requires'    Keyword
' '           Text
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm1'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'pre'         Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
')'           Operator
' '           Text
'm1'          Name
')'           Operator
'\n        '  Text
'('           Operator
'ensures'     Keyword
'\n          ' Text
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm2'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'post'        Name
' '           Text
'x'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
')'           Operator
' '           Text
'm2'          Name
' '           Text
'/\\'         Operator
'\n          ' Text
'('           Operator
'forall'      Keyword
' '           Text
'('           Operator
'f_frame'     Name
':'           Operator
'fp_prop'     Name
' '           Text
'frame'       Name
')'           Operator
'.'           Operator
' '           Text
'f_frame'     Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'core'        Name
' '           Text
'm1'          Name
')'           Operator
' '           Text
'='           Operator
'='           Operator
' '           Text
'f_frame'     Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'core'        Name
' '           Text
'm2'          Name
')'           Operator
')'           Operator
')'           Operator
'\n        '  Text
'['           Operator
'SMTPat'      Name.Class
' '           Text
'()'          Name.Builtin.Pseudo
']'           Operator
'\n      '    Text
'='           Operator
'\n    '      Text
'assert'      Name.Exception
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm2'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'post_s'      Name
' '           Text
'x'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
')'           Operator
' '           Text
'm2'          Name
')'           Operator
';'           Operator
'\n    '      Text
'calc'        Name.Exception
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'equals'      Name
')'           Operator
' '           Text
'{'           Operator
'\n      '    Text
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm2'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'post_s'      Name
' '           Text
'x'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
';'           Operator
'\n         ' Text
'('           Operator
'st'          Name
'.'           Operator
'equals'      Name
')'           Operator
' '           Text
'{'           Operator
' '           Text
'}'           Operator
'\n      '    Text
'('           Operator
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm2'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'post_s'      Name
' '           Text
'x'           Name
')'           Operator
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
';'           Operator
'\n         ' Text
'('           Operator
'st'          Name
'.'           Operator
'equals'      Name
')'           Operator
' '           Text
'{'           Operator
' '           Text
'}'           Operator
'\n      '    Text
'('           Operator
'post_s'      Name
' '           Text
'x'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm2'          Name
')'           Operator
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
';'           Operator
'\n         ' Text
'('           Operator
'st'          Name
'.'           Operator
'equals'      Name
')'           Operator
' '           Text
'{'           Operator
' '           Text
'}'           Operator
'\n     '     Text
'post_s'      Name
' '           Text
'x'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm2'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
';'           Operator
'\n    '      Text
'}'           Operator
';'           Operator
'\n    '      Text
'assert'      Name.Exception
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'('           Operator
'post_s'      Name
' '           Text
'x'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm2'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
')'           Operator
' '           Text
'm2'          Name
')'           Operator
';'           Operator
'\n    '      Text
'assert'      Name.Exception
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'('           Operator
'post'        Name
' '           Text
'x'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm2'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
')'           Operator
' '           Text
'm2'          Name
')'           Operator
';'           Operator
'\n    '      Text
'calc'        Name.Exception
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'equals'      Name
')'           Operator
' '           Text
'{'           Operator
'\n      '    Text
'post'        Name
' '           Text
'x'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm2'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
';'           Operator
'\n         ' Text
'('           Operator
'st'          Name
'.'           Operator
'equals'      Name
')'           Operator
' '           Text
'{'           Operator
' '           Text
'}'           Operator
'\n      '    Text
'('           Operator
'post'        Name
' '           Text
'x'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm2'          Name
')'           Operator
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
';'           Operator
'\n         ' Text
'('           Operator
'st'          Name
'.'           Operator
'equals'      Name
')'           Operator
' '           Text
'{'           Operator
' '           Text
'}'           Operator
'\n      '    Text
'('           Operator
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm2'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'post'        Name
' '           Text
'x'           Name
')'           Operator
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
';'           Operator
'\n         ' Text
'('           Operator
'st'          Name
'.'           Operator
'equals'      Name
')'           Operator
' '           Text
'{'           Operator
' '           Text
'apply_assoc' Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm2'          Name
')'           Operator
' '           Text
'('           Operator
'post'        Name
' '           Text
'x'           Name
')'           Operator
' '           Text
'frame'       Name
' '           Text
'}'           Operator
'\n      '    Text
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm2'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'post'        Name
' '           Text
'x'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
';'           Operator
'\n      '    Text
'}'           Operator
';'           Operator
'\n    '      Text
'assert'      Name.Exception
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm2'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'post'        Name
' '           Text
'x'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
')'           Operator
' '           Text
'm2'          Name
')'           Operator
'\n  '        Text
'in'          Keyword
'\n  '        Text
'()'          Name.Builtin.Pseudo
'\n'          Text

'#'           Operator
'pop'         Name
'-'           Operator
'options'     Name
'\n\n'        Text

'#'           Operator
'push'        Name
'-'           Operator
'options'     Name
' '           Text
'"'           Literal.String.Double
'--z3rlimit 40 --warn_error -271' Literal.String.Double
'"'           Literal.String.Double
'\n'          Text

'let'         Keyword.Declaration
' '           Text
'preserves_frame_star' Name
' '           Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
' '           Text
'('           Operator
'pre'         Name
' '           Text
'post'        Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
' '           Text
'('           Operator
'm0'          Name
' '           Text
'm1'          Name
':'           Operator
'st'          Name
'.'           Operator
'mem'         Name
')'           Operator
' '           Text
'('           Operator
'frame'       Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'Lemma'       Name.Class
'\n      '    Text
'('           Operator
'requires'    Keyword
' '           Text
'preserves_frame' Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
' '           Text
'm0'          Name
' '           Text
'm1'          Name
')'           Operator
'\n      '    Text
'('           Operator
'ensures'     Keyword
' '           Text
'preserves_frame' Name
' '           Text
'('           Operator
'pre'         Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
' '           Text
'('           Operator
'post'        Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
' '           Text
'm0'          Name
' '           Text
'm1'          Name
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'let'         Keyword.Declaration
' '           Text
'aux'         Name
' '           Text
'('           Operator
"frame'"      Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
':'           Operator
' '           Text
'Lemma'       Name.Class
'\n        '  Text
'('           Operator
'requires'    Keyword
'\n          ' Text
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm0'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'('           Operator
'pre'         Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
' '           Text
'`st.star`'   Operator.Word
' '           Text
"frame'"      Name
')'           Operator
')'           Operator
' '           Text
'm0'          Name
')'           Operator
'\n        '  Text
'('           Operator
'ensures'     Keyword
'\n          ' Text
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm1'          Name
' '           Text
'`st.star`'   Operator.Word
'\n            ' Text
'('           Operator
'('           Operator
'post'        Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
' '           Text
'`st.star`'   Operator.Word
' '           Text
"frame'"      Name
')'           Operator
')'           Operator
' '           Text
'm1'          Name
' '           Text
'/\\'         Operator
'\n          ' Text
'('           Operator
'forall'      Keyword
' '           Text
'('           Operator
'f_frame'     Name
':'           Operator
'fp_prop'     Name
' '           Text
"frame'"      Name
')'           Operator
'.'           Operator
' '           Text
'f_frame'     Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'core'        Name
' '           Text
'm0'          Name
')'           Operator
' '           Text
'='           Operator
'='           Operator
' '           Text
'f_frame'     Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'core'        Name
' '           Text
'm1'          Name
')'           Operator
')'           Operator
')'           Operator
'\n        '  Text
'['           Operator
'SMTPat'      Name.Class
' '           Text
'()'          Name.Builtin.Pseudo
']'           Operator
'\n      '    Text
'='           Operator
'\n    '      Text
'assoc_star_right' Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm0'          Name
')'           Operator
' '           Text
'pre'         Name
' '           Text
'frame'       Name
' '           Text
"frame'"      Name
';'           Operator
'\n    '      Text
'apply_interp_ext' Name
'\n      '    Text
'('           Operator
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm0'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'('           Operator
'pre'         Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
' '           Text
'`st.star`'   Operator.Word
' '           Text
"frame'"      Name
')'           Operator
')'           Operator
'\n      '    Text
'('           Operator
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm0'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'pre'         Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'frame'       Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
"frame'"      Name
')'           Operator
')'           Operator
')'           Operator
'\n      '    Text
'm0'          Name
';'           Operator
'\n    '      Text
'assoc_star_right' Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm1'          Name
')'           Operator
' '           Text
'post'        Name
' '           Text
'frame'       Name
' '           Text
"frame'"      Name
';'           Operator
'\n    '      Text
'apply_interp_ext' Name
'\n      '    Text
'('           Operator
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm1'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'post'        Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'frame'       Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
"frame'"      Name
')'           Operator
')'           Operator
')'           Operator
'\n      '    Text
'('           Operator
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm1'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'('           Operator
'post'        Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
' '           Text
'`st.star`'   Operator.Word
' '           Text
"frame'"      Name
')'           Operator
')'           Operator
'\n      '    Text
'm1'          Name
';'           Operator
'\n    '      Text
'weaken_fp_prop' Name
' '           Text
'frame'       Name
' '           Text
"frame'"      Name
' '           Text
'm0'          Name
' '           Text
'm1'          Name
'\n  '        Text
'in'          Keyword
'\n  '        Text
'()'          Name.Builtin.Pseudo
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'preserves_frame_star_left' Name
' '           Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
' '           Text
'('           Operator
'pre'         Name
' '           Text
'post'        Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
' '           Text
'('           Operator
'm0'          Name
' '           Text
'm1'          Name
':'           Operator
'st'          Name
'.'           Operator
'mem'         Name
')'           Operator
' '           Text
'('           Operator
'frame'       Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'Lemma'       Name.Class
'\n      '    Text
'('           Operator
'requires'    Keyword
' '           Text
'preserves_frame' Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
' '           Text
'm0'          Name
' '           Text
'm1'          Name
')'           Operator
'\n      '    Text
'('           Operator
'ensures'     Keyword
' '           Text
'preserves_frame' Name
' '           Text
'('           Operator
'frame'       Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'pre'         Name
')'           Operator
' '           Text
'('           Operator
'frame'       Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'post'        Name
')'           Operator
' '           Text
'm0'          Name
' '           Text
'm1'          Name
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'let'         Keyword.Declaration
' '           Text
'aux'         Name
' '           Text
'('           Operator
"frame'"      Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
':'           Operator
' '           Text
'Lemma'       Name.Class
'\n        '  Text
'('           Operator
'requires'    Keyword
'\n          ' Text
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm0'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'('           Operator
'frame'       Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'pre'         Name
')'           Operator
' '           Text
'`st.star`'   Operator.Word
' '           Text
"frame'"      Name
')'           Operator
')'           Operator
' '           Text
'm0'          Name
')'           Operator
'\n        '  Text
'('           Operator
'ensures'     Keyword
'\n          ' Text
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm1'          Name
' '           Text
'`st.star`'   Operator.Word
'\n            ' Text
'('           Operator
'('           Operator
'frame'       Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'post'        Name
')'           Operator
' '           Text
'`st.star`'   Operator.Word
' '           Text
"frame'"      Name
')'           Operator
')'           Operator
' '           Text
'm1'          Name
' '           Text
'/\\'         Operator
'\n          ' Text
'('           Operator
'forall'      Keyword
' '           Text
'('           Operator
'f_frame'     Name
':'           Operator
'fp_prop'     Name
' '           Text
"frame'"      Name
')'           Operator
'.'           Operator
' '           Text
'f_frame'     Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'core'        Name
' '           Text
'm0'          Name
')'           Operator
' '           Text
'='           Operator
'='           Operator
' '           Text
'f_frame'     Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'core'        Name
' '           Text
'm1'          Name
')'           Operator
')'           Operator
')'           Operator
'\n        '  Text
'['           Operator
'SMTPat'      Name.Class
' '           Text
'()'          Name.Builtin.Pseudo
']'           Operator
'\n      '    Text
'='           Operator
'\n    '      Text
'commute_assoc_star_right' Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm0'          Name
')'           Operator
' '           Text
'frame'       Name
' '           Text
'pre'         Name
' '           Text
"frame'"      Name
';'           Operator
'\n    '      Text
'apply_interp_ext' Name
'\n      '    Text
'('           Operator
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm0'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'('           Operator
'frame'       Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'pre'         Name
')'           Operator
' '           Text
'`st.star`'   Operator.Word
' '           Text
"frame'"      Name
')'           Operator
')'           Operator
'\n      '    Text
'('           Operator
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm0'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'pre'         Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'frame'       Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
"frame'"      Name
')'           Operator
')'           Operator
')'           Operator
'\n      '    Text
'm0'          Name
';'           Operator
'\n    '      Text
'commute_assoc_star_right' Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm1'          Name
')'           Operator
' '           Text
'frame'       Name
' '           Text
'post'        Name
' '           Text
"frame'"      Name
';'           Operator
'\n    '      Text
'apply_interp_ext' Name
'\n      '    Text
'('           Operator
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm1'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'post'        Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'frame'       Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
"frame'"      Name
')'           Operator
')'           Operator
')'           Operator
'\n      '    Text
'('           Operator
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm1'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'('           Operator
'frame'       Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'post'        Name
')'           Operator
' '           Text
'`st.star`'   Operator.Word
' '           Text
"frame'"      Name
')'           Operator
')'           Operator
'\n      '    Text
'm1'          Name
';'           Operator
'\n    '      Text
'weaken_fp_prop' Name
' '           Text
'frame'       Name
' '           Text
"frame'"      Name
' '           Text
'm0'          Name
' '           Text
'm1'          Name
'\n  '        Text
'in'          Keyword
'\n  '        Text
'()'          Name.Builtin.Pseudo
'\n'          Text

'#'           Operator
'pop'         Name
'-'           Operator
'options'     Name
'\n\n\n'      Text

'/// Lemma frame_post_for_par is used in the par proof' Comment
'\n'          Text

'///'         Comment
'\n'          Text

'/// E.g. in the par rule, when L takes a step, we can frame the requires of R' Comment
'\n'          Text

'///   by using the preserves_frame property of the stepping relation' Comment
'\n'          Text

'///'         Comment
'\n'          Text

'/// However we also need to frame the ensures of R, for establishing stronger_post' Comment
'\n'          Text

'///'         Comment
'\n'          Text

'/// Basically, we need:' Comment
'\n'          Text

'///'         Comment
'\n'          Text

'/// forall x h_final. postR prev_state x h_final <==> postR next_state x h_final' Comment
'\n'          Text

'///'         Comment
'\n'          Text

'/// (the proof only requires the reverse implication, but we can prove iff)' Comment
'\n'          Text

'///'         Comment
'\n'          Text

'/// To prove this, we rely on the framing of all frame fp props provides by the stepping relation' Comment
'\n'          Text

'///'         Comment
'\n'          Text

'/// To use it, we instantiate the fp prop with inst_heap_prop_for_par' Comment
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'inst_heap_prop_for_par' Name
'\n      '    Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'pre'         Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'post'        Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'lpost'       Name
':'           Operator
'l_post'      Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
')'           Operator
'\n      '    Text
'('           Operator
'state'       Name
':'           Operator
'st'          Name
'.'           Operator
'mem'         Name
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'fp_prop'     Name
' '           Text
'pre'         Name
'\n    '      Text
'='           Operator
'\n  '        Text
'fun'         Keyword
' '           Text
'h'           Name
' '           Text
'->'          Operator
'\n    '      Text
'forall'      Keyword
' '           Text
'x'           Name
' '           Text
'final_state' Name
'.'           Operator
'\n      '    Text
'lpost'       Name
' '           Text
'h'           Name
' '           Text
'x'           Name
' '           Text
'final_state' Name
' '           Text
'<==>'        Operator
'\n      '    Text
'lpost'       Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'core'        Name
' '           Text
'state'       Name
')'           Operator
' '           Text
'x'           Name
' '           Text
'final_state' Name
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'frame_post_for_par_tautology' Name
'\n      '    Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'pre_f'       Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'post_f'      Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'lpost_f'     Name
':'           Operator
'l_post'      Name
' '           Text
'pre_f'       Name
' '           Text
'post_f'      Name
')'           Operator
'\n      '    Text
'('           Operator
'm0'          Name
':'           Operator
'st'          Name
'.'           Operator
'mem'         Name
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'Lemma'       Name.Class
' '           Text
'('           Operator
'inst_heap_prop_for_par' Name
' '           Text
'lpost_f'     Name
' '           Text
'm0'          Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'core'        Name
' '           Text
'm0'          Name
')'           Operator
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'()'          Name.Builtin.Pseudo
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'frame_post_for_par_aux' Name
'\n      '    Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
'\n      '    Text
'('           Operator
'pre_s'       Name
' '           Text
'post_s'      Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
' '           Text
'('           Operator
'm0'          Name
' '           Text
'm1'          Name
':'           Operator
'st'          Name
'.'           Operator
'mem'         Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
')'           Operator
' '           Text
'('           Operator
'#'           Operator
'pre_f'       Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
' '           Text
'('           Operator
'#'           Operator
'post_f'      Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
' '           Text
'('           Operator
'lpost_f'     Name
':'           Operator
'l_post'      Name
' '           Text
'pre_f'       Name
' '           Text
'post_f'      Name
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'Lemma'       Name.Class
'\n      '    Text
'('           Operator
'requires'    Keyword
'\n        '  Text
'preserves_frame' Name
' '           Text
'pre_s'       Name
' '           Text
'post_s'      Name
' '           Text
'm0'          Name
' '           Text
'm1'          Name
' '           Text
'/\\'         Operator
'\n        '  Text
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'('           Operator
'('           Operator
'pre_s'       Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'pre_f'       Name
')'           Operator
' '           Text
'`st.star`'   Operator.Word
' '           Text
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm0'          Name
')'           Operator
' '           Text
'm0'          Name
')'           Operator
'\n      '    Text
'('           Operator
'ensures'     Keyword
'\n        '  Text
'inst_heap_prop_for_par' Name
' '           Text
'lpost_f'     Name
' '           Text
'm0'          Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'core'        Name
' '           Text
'm0'          Name
')'           Operator
' '           Text
'<==>'        Operator
'\n        '  Text
'inst_heap_prop_for_par' Name
' '           Text
'lpost_f'     Name
' '           Text
'm0'          Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'core'        Name
' '           Text
'm1'          Name
')'           Operator
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'()'          Name.Builtin.Pseudo
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'frame_post_for_par' Name
'\n      '    Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
'\n      '    Text
'('           Operator
'pre_s'       Name
' '           Text
'post_s'      Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'm0'          Name
' '           Text
'm1'          Name
':'           Operator
'st'          Name
'.'           Operator
'mem'         Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'pre_f'       Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'post_f'      Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'lpre_f'      Name
':'           Operator
'l_pre'       Name
' '           Text
'pre_f'       Name
')'           Operator
'\n      '    Text
'('           Operator
'lpost_f'     Name
':'           Operator
'l_post'      Name
' '           Text
'pre_f'       Name
' '           Text
'post_f'      Name
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'Lemma'       Name.Class
'\n      '    Text
'('           Operator
'requires'    Keyword
'\n        '  Text
'preserves_frame' Name
' '           Text
'pre_s'       Name
' '           Text
'post_s'      Name
' '           Text
'm0'          Name
' '           Text
'm1'          Name
' '           Text
'/\\'         Operator
'\n        '  Text
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'('           Operator
'('           Operator
'pre_s'       Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'pre_f'       Name
')'           Operator
' '           Text
'`st.star`'   Operator.Word
' '           Text
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm0'          Name
')'           Operator
' '           Text
'm0'          Name
')'           Operator
'\n      '    Text
'('           Operator
'ensures'     Keyword
'\n        '  Text
'('           Operator
'lpre_f'      Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'core'        Name
' '           Text
'm0'          Name
')'           Operator
' '           Text
'<==>'        Operator
' '           Text
'lpre_f'      Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'core'        Name
' '           Text
'm1'          Name
')'           Operator
')'           Operator
' '           Text
'/\\'         Operator
'\n        '  Text
'('           Operator
'forall'      Keyword
' '           Text
'('           Operator
'x'           Name
':'           Operator
'a'           Name
')'           Operator
' '           Text
'('           Operator
'final_state' Name
':'           Operator
'st'          Name
'.'           Operator
'mem'         Name
')'           Operator
'.'           Operator
'\n          ' Text
'lpost_f'     Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'core'        Name
' '           Text
'm0'          Name
')'           Operator
' '           Text
'x'           Name
' '           Text
'final_state' Name
' '           Text
'<==>'        Operator
'\n          ' Text
'lpost_f'     Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'core'        Name
' '           Text
'm1'          Name
')'           Operator
' '           Text
'x'           Name
' '           Text
'final_state' Name
')'           Operator
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'frame_post_for_par_tautology' Name
' '           Text
'lpost_f'     Name
' '           Text
'm0'          Name
';'           Operator
'\n  '        Text
'frame_post_for_par_aux' Name
' '           Text
'pre_s'       Name
' '           Text
'post_s'      Name
' '           Text
'm0'          Name
' '           Text
'm1'          Name
' '           Text
'lpost_f'     Name
'\n\n'        Text

'/// Finally lemmas for proving that in the par rules preconditions get weaker' Comment
'\n'          Text

'///   and postconditions get stronger' Comment
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'par_weaker_lpre_and_stronger_lpost_l' Name
'\n      '    Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'preL'        Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'lpreL'       Name
':'           Operator
'l_pre'       Name
' '           Text
'preL'        Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'aL'          Name
':'           Operator
'Type'        Name.Class
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'postL'       Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'aL'          Name
')'           Operator
'\n      '    Text
'('           Operator
'lpostL'      Name
':'           Operator
'l_post'      Name
' '           Text
'preL'        Name
' '           Text
'postL'       Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'next_preL'   Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'next_postL'  Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'aL'          Name
')'           Operator
'\n      '    Text
'('           Operator
'next_lpreL'  Name
':'           Operator
'l_pre'       Name
' '           Text
'next_preL'   Name
')'           Operator
'\n      '    Text
'('           Operator
'next_lpostL' Name
':'           Operator
'l_post'      Name
' '           Text
'next_preL'   Name
' '           Text
'next_postL'  Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'preR'        Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'lpreR'       Name
':'           Operator
'l_pre'       Name
' '           Text
'preR'        Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'aR'          Name
':'           Operator
'Type'        Name.Class
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'postR'       Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'aR'          Name
')'           Operator
'\n      '    Text
'('           Operator
'lpostR'      Name
':'           Operator
'l_post'      Name
' '           Text
'preR'        Name
' '           Text
'postR'       Name
')'           Operator
'\n      '    Text
'('           Operator
'state'       Name
' '           Text
'next_state'  Name
':'           Operator
'st'          Name
'.'           Operator
'mem'         Name
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'Lemma'       Name.Class
'\n      '    Text
'('           Operator
'requires'    Keyword
'\n        '  Text
'weaker_lpre' Name
' '           Text
'lpreL'       Name
' '           Text
'next_lpreL'  Name
' '           Text
'state'       Name
' '           Text
'next_state'  Name
' '           Text
'/\\'         Operator
'\n        '  Text
'stronger_lpost' Name
' '           Text
'lpostL'      Name
' '           Text
'next_lpostL' Name
' '           Text
'state'       Name
' '           Text
'next_state'  Name
' '           Text
'/\\'         Operator
'\n        '  Text
'preserves_frame' Name
' '           Text
'preL'        Name
' '           Text
'next_preL'   Name
' '           Text
'state'       Name
' '           Text
'next_state'  Name
' '           Text
'/\\'         Operator
'\n        '  Text
'lpreL'       Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'core'        Name
' '           Text
'state'       Name
')'           Operator
' '           Text
'/\\'         Operator
'\n        '  Text
'lpreR'       Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'core'        Name
' '           Text
'state'       Name
')'           Operator
' '           Text
'/\\'         Operator
'\n        '  Text
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'('           Operator
'('           Operator
'preL'        Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'preR'        Name
')'           Operator
' '           Text
'`st.star`'   Operator.Word
' '           Text
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'state'       Name
')'           Operator
' '           Text
'state'       Name
')'           Operator
'\n      '    Text
'('           Operator
'ensures'     Keyword
'\n        '  Text
'weaker_lpre' Name
'\n          ' Text
'('           Operator
'par_lpre'    Name
' '           Text
'lpreL'       Name
' '           Text
'lpreR'       Name
')'           Operator
'\n          ' Text
'('           Operator
'par_lpre'    Name
' '           Text
'next_lpreL'  Name
' '           Text
'lpreR'       Name
')'           Operator
'\n          ' Text
'state'       Name
' '           Text
'next_state'  Name
' '           Text
'/\\'         Operator
'\n        '  Text
'stronger_lpost' Name
'\n          ' Text
'('           Operator
'par_lpost'   Name
' '           Text
'lpreL'       Name
' '           Text
'lpostL'      Name
' '           Text
'lpreR'       Name
' '           Text
'lpostR'      Name
')'           Operator
'\n          ' Text
'('           Operator
'par_lpost'   Name
' '           Text
'next_lpreL'  Name
' '           Text
'next_lpostL' Name
' '           Text
'lpreR'       Name
' '           Text
'lpostR'      Name
')'           Operator
'\n          ' Text
'state'       Name
' '           Text
'next_state'  Name
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'frame_post_for_par' Name
' '           Text
'preL'        Name
' '           Text
'next_preL'   Name
' '           Text
'state'       Name
' '           Text
'next_state'  Name
' '           Text
'lpreR'       Name
' '           Text
'lpostR'      Name
';'           Operator
'\n  '        Text
'assert'      Name.Exception
' '           Text
'('           Operator
'weaker_lpre' Name
' '           Text
'('           Operator
'par_lpre'    Name
' '           Text
'lpreL'       Name
' '           Text
'lpreR'       Name
')'           Operator
' '           Text
'('           Operator
'par_lpre'    Name
' '           Text
'next_lpreL'  Name
' '           Text
'lpreR'       Name
')'           Operator
' '           Text
'state'       Name
' '           Text
'next_state'  Name
')'           Operator
' '           Text
'by'          Keyword
'\n    '      Text
'('           Operator
'norm'        Name
' '           Text
'['           Operator
'delta_only'  Name
' '           Text
'['           Operator
'`'           Keyword
'%'           Operator
'weaker_lpre' Name
';'           Operator
' '           Text
'`'           Keyword
'%'           Operator
'par_lpre'    Name
']'           Operator
' '           Text
']'           Operator
')'           Operator
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'par_weaker_lpre_and_stronger_lpost_r' Name
'\n      '    Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'preL'        Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'lpreL'       Name
':'           Operator
'l_pre'       Name
' '           Text
'preL'        Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'aL'          Name
':'           Operator
'Type'        Name.Class
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'postL'       Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'aL'          Name
')'           Operator
'\n      '    Text
'('           Operator
'lpostL'      Name
':'           Operator
'l_post'      Name
' '           Text
'preL'        Name
' '           Text
'postL'       Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'preR'        Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'lpreR'       Name
':'           Operator
'l_pre'       Name
' '           Text
'preR'        Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'aR'          Name
':'           Operator
'Type'        Name.Class
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'postR'       Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'aR'          Name
')'           Operator
'\n      '    Text
'('           Operator
'lpostR'      Name
':'           Operator
'l_post'      Name
' '           Text
'preR'        Name
' '           Text
'postR'       Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'next_preR'   Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'next_postR'  Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'aR'          Name
')'           Operator
'\n      '    Text
'('           Operator
'next_lpreR'  Name
':'           Operator
'l_pre'       Name
' '           Text
'next_preR'   Name
')'           Operator
'\n      '    Text
'('           Operator
'next_lpostR' Name
':'           Operator
'l_post'      Name
' '           Text
'next_preR'   Name
' '           Text
'next_postR'  Name
')'           Operator
'\n      '    Text
'('           Operator
'state'       Name
' '           Text
'next_state'  Name
':'           Operator
'st'          Name
'.'           Operator
'mem'         Name
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'Lemma'       Name.Class
'\n      '    Text
'('           Operator
'requires'    Keyword
'\n        '  Text
'weaker_lpre' Name
' '           Text
'lpreR'       Name
' '           Text
'next_lpreR'  Name
' '           Text
'state'       Name
' '           Text
'next_state'  Name
' '           Text
'/\\'         Operator
'\n        '  Text
'stronger_lpost' Name
' '           Text
'lpostR'      Name
' '           Text
'next_lpostR' Name
' '           Text
'state'       Name
' '           Text
'next_state'  Name
' '           Text
'/\\'         Operator
'\n        '  Text
'preserves_frame' Name
' '           Text
'preR'        Name
' '           Text
'next_preR'   Name
' '           Text
'state'       Name
' '           Text
'next_state'  Name
' '           Text
'/\\'         Operator
'\n        '  Text
'lpreR'       Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'core'        Name
' '           Text
'state'       Name
')'           Operator
' '           Text
'/\\'         Operator
'\n        '  Text
'lpreL'       Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'core'        Name
' '           Text
'state'       Name
')'           Operator
' '           Text
'/\\'         Operator
'\n        '  Text
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'('           Operator
'('           Operator
'preL'        Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'preR'        Name
')'           Operator
' '           Text
'`st.star`'   Operator.Word
' '           Text
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'state'       Name
')'           Operator
' '           Text
'state'       Name
')'           Operator
'\n      '    Text
'('           Operator
'ensures'     Keyword
'\n        '  Text
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'('           Operator
'('           Operator
'preL'        Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'next_preR'   Name
')'           Operator
' '           Text
'`st.star`'   Operator.Word
' '           Text
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'next_state'  Name
')'           Operator
' '           Text
'next_state'  Name
' '           Text
'/\\'         Operator
'\n        '  Text
'weaker_lpre' Name
'\n          ' Text
'('           Operator
'par_lpre'    Name
' '           Text
'lpreL'       Name
' '           Text
'lpreR'       Name
')'           Operator
'\n          ' Text
'('           Operator
'par_lpre'    Name
' '           Text
'lpreL'       Name
' '           Text
'next_lpreR'  Name
')'           Operator
'\n          ' Text
'state'       Name
' '           Text
'next_state'  Name
' '           Text
'/\\'         Operator
'\n        '  Text
'stronger_lpost' Name
'\n          ' Text
'('           Operator
'par_lpost'   Name
' '           Text
'lpreL'       Name
' '           Text
'lpostL'      Name
' '           Text
'lpreR'       Name
' '           Text
'lpostR'      Name
')'           Operator
'\n          ' Text
'('           Operator
'par_lpost'   Name
' '           Text
'lpreL'       Name
' '           Text
'lpostL'      Name
' '           Text
'next_lpreR'  Name
' '           Text
'next_lpostR' Name
')'           Operator
'\n        '  Text
'state'       Name
' '           Text
'next_state'  Name
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'commute_star_right' Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'state'       Name
')'           Operator
' '           Text
'preL'        Name
' '           Text
'preR'        Name
';'           Operator
'\n  '        Text
'apply_interp_ext' Name
'\n    '      Text
'('           Operator
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'state'       Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'preL'        Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'preR'        Name
')'           Operator
')'           Operator
'\n    '      Text
'('           Operator
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'state'       Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'preR'        Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'preL'        Name
')'           Operator
')'           Operator
'\n    '      Text
'state'       Name
';'           Operator
'\n  '        Text
'frame_post_for_par' Name
' '           Text
'preR'        Name
' '           Text
'next_preR'   Name
' '           Text
'state'       Name
' '           Text
'next_state'  Name
' '           Text
'lpreL'       Name
' '           Text
'lpostL'      Name
';'           Operator
'\n  '        Text
'assert'      Name.Exception
' '           Text
'('           Operator
'weaker_lpre' Name
' '           Text
'('           Operator
'par_lpre'    Name
' '           Text
'lpreL'       Name
' '           Text
'lpreR'       Name
')'           Operator
' '           Text
'('           Operator
'par_lpre'    Name
' '           Text
'lpreL'       Name
' '           Text
'next_lpreR'  Name
')'           Operator
' '           Text
'state'       Name
' '           Text
'next_state'  Name
')'           Operator
' '           Text
'by'          Keyword
'\n    '      Text
'('           Operator
'norm'        Name
' '           Text
'['           Operator
'delta_only'  Name
' '           Text
'['           Operator
'`'           Keyword
'%'           Operator
'weaker_lpre' Name
';'           Operator
' '           Text
'`'           Keyword
'%'           Operator
'par_lpre'    Name
']'           Operator
' '           Text
']'           Operator
')'           Operator
';'           Operator
'\n  '        Text
'commute_star_right' Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'next_state'  Name
')'           Operator
' '           Text
'next_preR'   Name
' '           Text
'preL'        Name
';'           Operator
'\n  '        Text
'apply_interp_ext' Name
'\n    '      Text
'('           Operator
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'next_state'  Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'next_preR'   Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'preL'        Name
')'           Operator
')'           Operator
'\n    '      Text
'('           Operator
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'next_state'  Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'preL'        Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'next_preR'   Name
')'           Operator
')'           Operator
'\n    '      Text
'next_state'  Name
'\n\n'        Text

'#'           Operator
'push'        Name
'-'           Operator
'options'     Name
' '           Text
'"'           Literal.String.Double
'--warn_error -271' Literal.String.Double
'"'           Literal.String.Double
'\n'          Text

'let'         Keyword.Declaration
' '           Text
'stronger_post_par_r' Name
'\n      '    Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'aL'          Name
' '           Text
'#'           Operator
'aR'          Name
':'           Operator
'Type'        Name.Class
' '           Text
'u#'          Operator
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'postL'       Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'aL'          Name
')'           Operator
'\n      '    Text
'('           Operator
'postR'       Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'aR'          Name
')'           Operator
'\n      '    Text
'('           Operator
'next_postR'  Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'aR'          Name
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'Lemma'       Name.Class
'\n      '    Text
'('           Operator
'requires'    Keyword
' '           Text
'stronger_post' Name
' '           Text
'postR'       Name
' '           Text
'next_postR'  Name
')'           Operator
'\n      '    Text
'('           Operator
'ensures'     Keyword
'\n        '  Text
'forall'      Keyword
' '           Text
'xL'          Name
' '           Text
'xR'          Name
' '           Text
'frame'       Name
' '           Text
'h'           Name
'.'           Operator
'\n          ' Text
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'('           Operator
'('           Operator
'postL'       Name
' '           Text
'xL'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'next_postR'  Name
' '           Text
'xR'          Name
')'           Operator
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
' '           Text
'h'           Name
' '           Text
'='           Operator
'='           Operator
'>'           Operator
'\n          ' Text
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'('           Operator
'('           Operator
'postL'       Name
' '           Text
'xL'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'postR'       Name
' '           Text
'xR'          Name
')'           Operator
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
' '           Text
'h'           Name
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'let'         Keyword.Declaration
' '           Text
'aux'         Name
' '           Text
'xL'          Name
' '           Text
'xR'          Name
' '           Text
'frame'       Name
' '           Text
'h'           Name
'\n      '    Text
':'           Operator
' '           Text
'Lemma'       Name.Class
'\n        '  Text
'('           Operator
'requires'    Keyword
' '           Text
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'('           Operator
'('           Operator
'postL'       Name
' '           Text
'xL'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'next_postR'  Name
' '           Text
'xR'          Name
')'           Operator
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
' '           Text
'h'           Name
')'           Operator
'\n        '  Text
'('           Operator
'ensures'     Keyword
' '           Text
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'('           Operator
'('           Operator
'postL'       Name
' '           Text
'xL'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'postR'       Name
' '           Text
'xR'          Name
')'           Operator
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
' '           Text
'h'           Name
')'           Operator
'\n        '  Text
'['           Operator
'SMTPat'      Name.Class
' '           Text
'()'          Name.Builtin.Pseudo
']'           Operator
'\n      '    Text
'='           Operator
'\n    '      Text
'calc'        Name.Exception
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'equals'      Name
')'           Operator
' '           Text
'{'           Operator
'\n      '    Text
'('           Operator
'postL'       Name
' '           Text
'xL'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'next_postR'  Name
' '           Text
'xR'          Name
')'           Operator
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
';'           Operator
'\n         ' Text
'('           Operator
'st'          Name
'.'           Operator
'equals'      Name
')'           Operator
' '           Text
'{'           Operator
' '           Text
'}'           Operator
'\n      '    Text
'('           Operator
'next_postR'  Name
' '           Text
'xR'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'postL'       Name
' '           Text
'xL'          Name
')'           Operator
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
';'           Operator
'\n         ' Text
'('           Operator
'st'          Name
'.'           Operator
'equals'      Name
')'           Operator
' '           Text
'{'           Operator
' '           Text
'}'           Operator
'\n      '    Text
'next_postR'  Name
' '           Text
'xR'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'postL'       Name
' '           Text
'xL'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
';'           Operator
'\n    '      Text
'}'           Operator
';'           Operator
'\n    '      Text
'assert'      Name.Exception
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'('           Operator
'next_postR'  Name
' '           Text
'xR'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'postL'       Name
' '           Text
'xL'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
')'           Operator
' '           Text
'h'           Name
')'           Operator
';'           Operator
'\n    '      Text
'assert'      Name.Exception
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'('           Operator
'postR'       Name
' '           Text
'xR'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'postL'       Name
' '           Text
'xL'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
')'           Operator
' '           Text
'h'           Name
')'           Operator
';'           Operator
'\n    '      Text
'calc'        Name.Exception
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'equals'      Name
')'           Operator
' '           Text
'{'           Operator
'\n      '    Text
'postR'       Name
' '           Text
'xR'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'('           Operator
'postL'       Name
' '           Text
'xL'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
';'           Operator
'\n         ' Text
'('           Operator
'st'          Name
'.'           Operator
'equals'      Name
')'           Operator
' '           Text
'{'           Operator
' '           Text
'}'           Operator
'\n      '    Text
'('           Operator
'postR'       Name
' '           Text
'xR'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'postL'       Name
' '           Text
'xL'          Name
')'           Operator
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
';'           Operator
'\n         ' Text
'('           Operator
'st'          Name
'.'           Operator
'equals'      Name
')'           Operator
' '           Text
'{'           Operator
' '           Text
'}'           Operator
'\n      '    Text
'('           Operator
'postL'       Name
' '           Text
'xL'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'postR'       Name
' '           Text
'xR'          Name
')'           Operator
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
';'           Operator
'\n    '      Text
'}'           Operator
'\n  '        Text
'in'          Keyword
'\n  '        Text
'()'          Name.Builtin.Pseudo
'\n'          Text

'#'           Operator
'pop'         Name
'-'           Operator
'options'     Name
'\n\n\n'      Text

'(*'          Comment
'*'           Comment
'*'           Comment
'*'           Comment
' Begin stepping functions ' Comment
'*'           Comment
'*'           Comment
'*'           Comment
'*)'          Comment
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'step_ret'    Name
'\n      '    Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
' '           Text
'u#'          Operator
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'pre'         Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'post'        Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'lpre'        Name
':'           Operator
'l_pre'       Name
' '           Text
'pre'         Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'lpost'       Name
':'           Operator
'l_post'      Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
')'           Operator
'\n      '    Text
'('           Operator
'f'           Name
':'           Operator
'm'           Name
' '           Text
'st'          Name
' '           Text
'a'           Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
' '           Text
'lpre'        Name
' '           Text
'lpost'       Name
'{'           Operator
'Ret'         Name.Class
'?'           Operator
' '           Text
'f'           Name
'}'           Operator
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'Mst'         Name.Class
' '           Text
'('           Operator
'step_result' Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
' '           Text
'('           Operator
'step_req'    Name
' '           Text
'f'           Name
')'           Operator
' '           Text
'('           Operator
'step_ens'    Name
' '           Text
'f'           Name
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'NMSTATE'     Name.Class
'?.'          Operator
'reflect'     Name
' '           Text
'('           Operator
'fun'         Keyword
' '           Text
'('           Operator
'_'           Name
','           Operator
' '           Text
'n'           Name
')'           Operator
' '           Text
'->'          Operator
'\n    '      Text
'let'         Keyword.Declaration
' '           Text
'Ret'         Name.Class
' '           Text
'p'           Name
' '           Text
'x'           Name
' '           Text
'lp'          Name
' '           Text
'='           Operator
' '           Text
'f'           Name
' '           Text
'in'          Keyword
'\n    '      Text
'Step'        Name.Class
' '           Text
'('           Operator
'p'           Name
' '           Text
'x'           Name
')'           Operator
' '           Text
'p'           Name
' '           Text
'lpre'        Name
' '           Text
'lpost'       Name
' '           Text
'f'           Name
','           Operator
' '           Text
'n'           Name
')'           Operator
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'lpost_ret_act' Name
'\n      '    Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'pre'         Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'post'        Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'lpost'       Name
':'           Operator
'l_post'      Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
')'           Operator
'\n      '    Text
'('           Operator
'x'           Name
':'           Operator
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'state'       Name
':'           Operator
'st'          Name
'.'           Operator
'mem'         Name
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'l_post'      Name
' '           Text
'('           Operator
'post'        Name
' '           Text
'x'           Name
')'           Operator
' '           Text
'post'        Name
'\n    '      Text
'='           Operator
'\n  '        Text
'fun'         Keyword
' '           Text
'_'           Name
' '           Text
'x'           Name
' '           Text
'h1'          Name
' '           Text
'->'          Operator
' '           Text
'lpost'       Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'core'        Name
' '           Text
'state'       Name
')'           Operator
' '           Text
'x'           Name
' '           Text
'h1'          Name
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'step_act'    Name
'\n      '    Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
' '           Text
'u#'          Operator
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'pre'         Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'post'        Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'lpre'        Name
':'           Operator
'l_pre'       Name
' '           Text
'pre'         Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'lpost'       Name
':'           Operator
'l_post'      Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
')'           Operator
'\n      '    Text
'('           Operator
'f'           Name
':'           Operator
'm'           Name
' '           Text
'st'          Name
' '           Text
'a'           Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
' '           Text
'lpre'        Name
' '           Text
'lpost'       Name
'{'           Operator
'Act'         Name.Class
'?'           Operator
' '           Text
'f'           Name
'}'           Operator
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'Mst'         Name.Class
' '           Text
'('           Operator
'step_result' Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
' '           Text
'('           Operator
'step_req'    Name
' '           Text
'f'           Name
')'           Operator
' '           Text
'('           Operator
'step_ens'    Name
' '           Text
'f'           Name
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'let'         Keyword.Declaration
' '           Text
'm0'          Name
' '           Text
'='           Operator
' '           Text
'get'         Name
' '           Text
'()'          Name.Builtin.Pseudo
' '           Text
'in'          Keyword
'\n\n  '      Text
'let'         Keyword.Declaration
' '           Text
'Act'         Name.Class
' '           Text
'#'           Operator
'_'           Name
' '           Text
'#'           Operator
'_'           Name
' '           Text
'#'           Operator
'_'           Name
' '           Text
'#'           Operator
'_'           Name
' '           Text
'#'           Operator
'_'           Name
' '           Text
'#'           Operator
'_'           Name
' '           Text
'f'           Name
' '           Text
'='           Operator
' '           Text
'f'           Name
' '           Text
'in'          Keyword
'\n\n  '      Text
'let'         Keyword.Declaration
' '           Text
'x'           Name
' '           Text
'='           Operator
' '           Text
'f'           Name
' '           Text
'()'          Name.Builtin.Pseudo
' '           Text
'in'          Keyword
'\n\n  '      Text
'let'         Keyword.Declaration
' '           Text
'lpost'       Name
' '           Text
':'           Operator
' '           Text
'l_post'      Name
' '           Text
'('           Operator
'post'        Name
' '           Text
'x'           Name
')'           Operator
' '           Text
'post'        Name
' '           Text
'='           Operator
' '           Text
'lpost_ret_act' Name
' '           Text
'lpost'       Name
' '           Text
'x'           Name
' '           Text
'm0'          Name
' '           Text
'in'          Keyword
'\n\n  '      Text
'Step'        Name.Class
' '           Text
'('           Operator
'post'        Name
' '           Text
'x'           Name
')'           Operator
' '           Text
'post'        Name
' '           Text
'('           Operator
'fun'         Keyword
' '           Text
'h'           Name
' '           Text
'->'          Operator
' '           Text
'lpost'       Name
' '           Text
'h'           Name
' '           Text
'x'           Name
' '           Text
'h'           Name
')'           Operator
' '           Text
'lpost'       Name
' '           Text
'('           Operator
'Ret'         Name.Class
' '           Text
'post'        Name
' '           Text
'x'           Name
' '           Text
'lpost'       Name
')'           Operator
'\n\n'        Text

'module'      Keyword
' '           Text
'M'           Name.Class
' '           Text
'='           Operator
' '           Text
'MST'         Name.Class
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'step_bind_ret_aux' Name
'\n      '    Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'pre'         Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'post'        Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'lpre'        Name
':'           Operator
'l_pre'       Name
' '           Text
'pre'         Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'lpost'       Name
':'           Operator
'l_post'      Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
')'           Operator
'\n      '    Text
'('           Operator
'f'           Name
':'           Operator
'm'           Name
' '           Text
'st'          Name
' '           Text
'a'           Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
' '           Text
'lpre'        Name
' '           Text
'lpost'       Name
'{'           Operator
'Bind'        Name.Class
'?'           Operator
' '           Text
'f'           Name
' '           Text
'/\\'         Operator
' '           Text
'Ret'         Name.Class
'?'           Operator
' '           Text
'('           Operator
'Bind'        Name.Class
'?.'          Operator
'f'           Name
' '           Text
'f'           Name
')'           Operator
'}'           Operator
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'M'           Name.Namespace
'.'           Punctuation
'MSTATE'      Name.Class
' '           Text
'('           Operator
'step_result' Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
' '           Text
'st'          Name
'.'           Operator
'mem'         Name
' '           Text
'st'          Name
'.'           Operator
'locks_preorder' Name
' '           Text
'('           Operator
'step_req'    Name
' '           Text
'f'           Name
')'           Operator
' '           Text
'('           Operator
'step_ens'    Name
' '           Text
'f'           Name
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'M'           Name.Namespace
'.'           Punctuation
'MSTATE'      Name.Class
'?.'          Operator
'reflect'     Name
' '           Text
'('           Operator
'fun'         Keyword
' '           Text
'm0'          Name
' '           Text
'->'          Operator
'\n    '      Text
'match'       Keyword
' '           Text
'f'           Name
' '           Text
'with'        Keyword
'\n    '      Text
'|'           Operator
' '           Text
'Bind'        Name.Class
' '           Text
'#'           Operator
'_'           Name
' '           Text
'#'           Operator
'_'           Name
' '           Text
'#'           Operator
'_'           Name
' '           Text
'#'           Operator
'_'           Name
' '           Text
'#'           Operator
'_'           Name
' '           Text
'#'           Operator
'_'           Name
' '           Text
'#'           Operator
'_'           Name
' '           Text
'#'           Operator
'post_b'      Name
' '           Text
'#'           Operator
'lpre_b'      Name
' '           Text
'#'           Operator
'lpost_b'     Name
' '           Text
'('           Operator
'Ret'         Name.Class
' '           Text
'p'           Name
' '           Text
'x'           Name
' '           Text
'_'           Name
')'           Operator
' '           Text
'g'           Name
' '           Text
'->'          Operator
'\n      '    Text
'Step'        Name.Class
' '           Text
'('           Operator
'p'           Name
' '           Text
'x'           Name
')'           Operator
' '           Text
'post_b'      Name
' '           Text
'('           Operator
'lpre_b'      Name
' '           Text
'x'           Name
')'           Operator
' '           Text
'('           Operator
'lpost_b'     Name
' '           Text
'x'           Name
')'           Operator
' '           Text
'('           Operator
'g'           Name
' '           Text
'x'           Name
')'           Operator
','           Operator
' '           Text
'm0'          Name
')'           Operator
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'step_bind_ret' Name
'\n      '    Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'pre'         Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'post'        Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'lpre'        Name
':'           Operator
'l_pre'       Name
' '           Text
'pre'         Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'lpost'       Name
':'           Operator
'l_post'      Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
')'           Operator
'\n      '    Text
'('           Operator
'f'           Name
':'           Operator
'm'           Name
' '           Text
'st'          Name
' '           Text
'a'           Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
' '           Text
'lpre'        Name
' '           Text
'lpost'       Name
'{'           Operator
'Bind'        Name.Class
'?'           Operator
' '           Text
'f'           Name
' '           Text
'/\\'         Operator
' '           Text
'Ret'         Name.Class
'?'           Operator
' '           Text
'('           Operator
'Bind'        Name.Class
'?.'          Operator
'f'           Name
' '           Text
'f'           Name
')'           Operator
'}'           Operator
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'Mst'         Name.Class
' '           Text
'('           Operator
'step_result' Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
' '           Text
'('           Operator
'step_req'    Name
' '           Text
'f'           Name
')'           Operator
' '           Text
'('           Operator
'step_ens'    Name
' '           Text
'f'           Name
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'NMSTATE'     Name.Class
'?.'          Operator
'reflect'     Name
' '           Text
'('           Operator
'fun'         Keyword
' '           Text
'('           Operator
'_'           Name
','           Operator
' '           Text
'n'           Name
')'           Operator
' '           Text
'->'          Operator
' '           Text
'step_bind_ret_aux' Name
' '           Text
'f'           Name
','           Operator
' '           Text
'n'           Name
')'           Operator
'\n\n\n'      Text

'#'           Operator
'push'        Name
'-'           Operator
'options'     Name
' '           Text
'"'           Literal.String.Double
'--z3rlimit 40' Literal.String.Double
'"'           Literal.String.Double
'\n'          Text

'let'         Keyword.Declaration
' '           Text
'step_bind'   Name
'\n      '    Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'pre'         Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'post'        Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'lpre'        Name
':'           Operator
'l_pre'       Name
' '           Text
'pre'         Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'lpost'       Name
':'           Operator
'l_post'      Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
')'           Operator
'\n      '    Text
'('           Operator
'f'           Name
':'           Operator
'm'           Name
' '           Text
'st'          Name
' '           Text
'a'           Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
' '           Text
'lpre'        Name
' '           Text
'lpost'       Name
'{'           Operator
'Bind'        Name.Class
'?'           Operator
' '           Text
'f'           Name
'}'           Operator
')'           Operator
'\n      '    Text
'('           Operator
'step'        Name
':'           Operator
'step_t'      Name
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'Mst'         Name.Class
' '           Text
'('           Operator
'step_result' Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
' '           Text
'('           Operator
'step_req'    Name
' '           Text
'f'           Name
')'           Operator
' '           Text
'('           Operator
'step_ens'    Name
' '           Text
'f'           Name
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'match'       Keyword
' '           Text
'f'           Name
' '           Text
'with'        Keyword
'\n  '        Text
'|'           Operator
' '           Text
'Bind'        Name.Class
' '           Text
'('           Operator
'Ret'         Name.Class
' '           Text
'_'           Name
' '           Text
'_'           Name
' '           Text
'_'           Name
')'           Operator
' '           Text
'_'           Name
' '           Text
'->'          Operator
' '           Text
'step_bind_ret' Name
' '           Text
'f'           Name
'\n\n  '      Text
'|'           Operator
' '           Text
'Bind'        Name.Class
' '           Text
'#'           Operator
'_'           Name
' '           Text
'#'           Operator
'b'           Name
' '           Text
'#'           Operator
'_'           Name
' '           Text
'#'           Operator
'post_a'      Name
' '           Text
'#'           Operator
'_'           Name
' '           Text
'#'           Operator
'_'           Name
' '           Text
'#'           Operator
'_'           Name
' '           Text
'#'           Operator
'post_b'      Name
' '           Text
'#'           Operator
'lpre_b'      Name
' '           Text
'#'           Operator
'lpost_b'     Name
' '           Text
'f'           Name
' '           Text
'g'           Name
' '           Text
'->'          Operator
'\n    '      Text
'let'         Keyword.Declaration
' '           Text
'Step'        Name.Class
' '           Text
'next_pre'    Name
' '           Text
'next_post'   Name
' '           Text
'next_lpre'   Name
' '           Text
'next_lpost'  Name
' '           Text
'f'           Name
' '           Text
'='           Operator
' '           Text
'step'        Name
' '           Text
'f'           Name
' '           Text
'in'          Keyword
'\n\n    '    Text
'let'         Keyword.Declaration
' '           Text
'lpre_b'      Name
' '           Text
':'           Operator
' '           Text
'('           Operator
'x'           Name
':'           Operator
'b'           Name
' '           Text
'->'          Operator
' '           Text
'l_pre'       Name
' '           Text
'('           Operator
'next_post'   Name
' '           Text
'x'           Name
')'           Operator
')'           Operator
' '           Text
'='           Operator
'\n      '    Text
'fun'         Keyword
' '           Text
'x'           Name
' '           Text
'->'          Operator
'\n      '    Text
'depends_only_on_commutes_with_weaker' Name
' '           Text
'('           Operator
'lpre_b'      Name
' '           Text
'x'           Name
')'           Operator
' '           Text
'('           Operator
'post_a'      Name
' '           Text
'x'           Name
')'           Operator
' '           Text
'('           Operator
'next_post'   Name
' '           Text
'x'           Name
')'           Operator
';'           Operator
'\n      '    Text
'lpre_b'      Name
' '           Text
'x'           Name
' '           Text
'in'          Keyword
'\n\n    '    Text
'let'         Keyword.Declaration
' '           Text
'lpost_b'     Name
' '           Text
':'           Operator
' '           Text
'('           Operator
'x'           Name
':'           Operator
'b'           Name
' '           Text
'->'          Operator
' '           Text
'l_post'      Name
' '           Text
'('           Operator
'next_post'   Name
' '           Text
'x'           Name
')'           Operator
' '           Text
'post_b'      Name
')'           Operator
' '           Text
'='           Operator
'\n      '    Text
'fun'         Keyword
' '           Text
'x'           Name
' '           Text
'->'          Operator
'\n      '    Text
'depends_only_on2_commutes_with_weaker' Name
' '           Text
'('           Operator
'lpost_b'     Name
' '           Text
'x'           Name
')'           Operator
' '           Text
'('           Operator
'post_a'      Name
' '           Text
'x'           Name
')'           Operator
' '           Text
'('           Operator
'next_post'   Name
' '           Text
'x'           Name
')'           Operator
' '           Text
'post_b'      Name
';'           Operator
'\n      '    Text
'lpost_b'     Name
' '           Text
'x'           Name
' '           Text
'in'          Keyword
'\n\n    '    Text
'let'         Keyword.Declaration
' '           Text
'g'           Name
' '           Text
':'           Operator
' '           Text
'('           Operator
'x'           Name
':'           Operator
'b'           Name
' '           Text
'->'          Operator
' '           Text
'Dv'          Name.Class
' '           Text
'('           Operator
'm'           Name
' '           Text
'st'          Name
' '           Text
'_'           Name
' '           Text
'('           Operator
'next_post'   Name
' '           Text
'x'           Name
')'           Operator
' '           Text
'post_b'      Name
' '           Text
'('           Operator
'lpre_b'      Name
' '           Text
'x'           Name
')'           Operator
' '           Text
'('           Operator
'lpost_b'     Name
' '           Text
'x'           Name
')'           Operator
')'           Operator
')'           Operator
' '           Text
'='           Operator
'\n      '    Text
'fun'         Keyword
' '           Text
'x'           Name
' '           Text
'->'          Operator
'\n      '    Text
'Weaken'      Name.Class
' '           Text
'('           Operator
'lpre_b'      Name
' '           Text
'x'           Name
')'           Operator
' '           Text
'('           Operator
'lpost_b'     Name
' '           Text
'x'           Name
')'           Operator
' '           Text
'()'          Name.Builtin.Pseudo
' '           Text
'('           Operator
'g'           Name
' '           Text
'x'           Name
')'           Operator
' '           Text
'in'          Keyword
'\n\n    '    Text
'let'         Keyword.Declaration
' '           Text
'm1'          Name
' '           Text
'='           Operator
' '           Text
'get'         Name
' '           Text
'()'          Name.Builtin.Pseudo
' '           Text
'in'          Keyword
'\n\n    '    Text
'assert'      Name.Exception
' '           Text
'('           Operator
'('           Operator
'bind_lpre'   Name
' '           Text
'next_lpre'   Name
' '           Text
'next_lpost'  Name
' '           Text
'lpre_b'      Name
')'           Operator
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'core'        Name
' '           Text
'm1'          Name
')'           Operator
')'           Operator
'\n      '    Text
'by'          Keyword
' '           Text
'norm'        Name
' '           Text
'('           Operator
'['           Operator
'delta_only'  Name
' '           Text
'['           Operator
'`'           Keyword
'%'           Operator
'bind_lpre'   Name
']'           Operator
']'           Operator
')'           Operator
';'           Operator
'\n\n    '    Text
'Step'        Name.Class
' '           Text
'next_pre'    Name
' '           Text
'post_b'      Name
'\n      '    Text
'('           Operator
'bind_lpre'   Name
' '           Text
'next_lpre'   Name
' '           Text
'next_lpost'  Name
' '           Text
'lpre_b'      Name
')'           Operator
'\n      '    Text
'('           Operator
'bind_lpost'  Name
' '           Text
'next_lpre'   Name
' '           Text
'next_lpost'  Name
' '           Text
'lpost_b'     Name
')'           Operator
'\n      '    Text
'('           Operator
'Bind'        Name.Class
' '           Text
'f'           Name
' '           Text
'g'           Name
')'           Operator
'\n'          Text

'#'           Operator
'pop'         Name
'-'           Operator
'options'     Name
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'step_frame_ret_aux' Name
'\n      '    Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'pre'         Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'p'           Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'lpre'        Name
':'           Operator
'l_pre'       Name
' '           Text
'pre'         Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'lpost'       Name
':'           Operator
'l_post'      Name
' '           Text
'pre'         Name
' '           Text
'p'           Name
')'           Operator
'\n      '    Text
'('           Operator
'f'           Name
':'           Operator
'm'           Name
' '           Text
'st'          Name
' '           Text
'a'           Name
' '           Text
'pre'         Name
' '           Text
'p'           Name
' '           Text
'lpre'        Name
' '           Text
'lpost'       Name
'{'           Operator
'Frame'       Name.Class
'?'           Operator
' '           Text
'f'           Name
' '           Text
'/\\'         Operator
' '           Text
'Ret'         Name.Class
'?'           Operator
' '           Text
'('           Operator
'Frame'       Name.Class
'?.'          Operator
'f'           Name
' '           Text
'f'           Name
')'           Operator
'}'           Operator
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'M'           Name.Namespace
'.'           Punctuation
'MSTATE'      Name.Class
' '           Text
'('           Operator
'step_result' Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
' '           Text
'st'          Name
'.'           Operator
'mem'         Name
' '           Text
'st'          Name
'.'           Operator
'locks_preorder' Name
' '           Text
'('           Operator
'step_req'    Name
' '           Text
'f'           Name
')'           Operator
' '           Text
'('           Operator
'step_ens'    Name
' '           Text
'f'           Name
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'M'           Name.Namespace
'.'           Punctuation
'MSTATE'      Name.Class
'?.'          Operator
'reflect'     Name
' '           Text
'('           Operator
'fun'         Keyword
' '           Text
'm0'          Name
' '           Text
'->'          Operator
'\n    '      Text
'match'       Keyword
' '           Text
'f'           Name
' '           Text
'with'        Keyword
'\n    '      Text
'|'           Operator
' '           Text
'Frame'       Name.Class
' '           Text
'('           Operator
'Ret'         Name.Class
' '           Text
'p'           Name
' '           Text
'x'           Name
' '           Text
'lp'          Name
')'           Operator
' '           Text
'frame'       Name
' '           Text
'f_frame'     Name
' '           Text
'->'          Operator
'\n      '    Text
'Step'        Name.Class
' '           Text
'('           Operator
'p'           Name
' '           Text
'x'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
' '           Text
'('           Operator
'fun'         Keyword
' '           Text
'x'           Name
' '           Text
'->'          Operator
' '           Text
'p'           Name
' '           Text
'x'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
'\n        '  Text
'('           Operator
'fun'         Keyword
' '           Text
'h'           Name
' '           Text
'->'          Operator
' '           Text
'lpost'       Name
' '           Text
'h'           Name
' '           Text
'x'           Name
' '           Text
'h'           Name
')'           Operator
'\n        '  Text
'lpost'       Name
'\n        '  Text
'('           Operator
'Ret'         Name.Class
' '           Text
'('           Operator
'fun'         Keyword
' '           Text
'x'           Name
' '           Text
'->'          Operator
' '           Text
'p'           Name
' '           Text
'x'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
' '           Text
'x'           Name
' '           Text
'lpost'       Name
')'           Operator
','           Operator
' '           Text
'm0'          Name
')'           Operator
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'step_frame_ret' Name
'\n      '    Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'pre'         Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'p'           Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'lpre'        Name
':'           Operator
'l_pre'       Name
' '           Text
'pre'         Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'lpost'       Name
':'           Operator
'l_post'      Name
' '           Text
'pre'         Name
' '           Text
'p'           Name
')'           Operator
'\n      '    Text
'('           Operator
'f'           Name
':'           Operator
'm'           Name
' '           Text
'st'          Name
' '           Text
'a'           Name
' '           Text
'pre'         Name
' '           Text
'p'           Name
' '           Text
'lpre'        Name
' '           Text
'lpost'       Name
'{'           Operator
'Frame'       Name.Class
'?'           Operator
' '           Text
'f'           Name
' '           Text
'/\\'         Operator
' '           Text
'Ret'         Name.Class
'?'           Operator
' '           Text
'('           Operator
'Frame'       Name.Class
'?.'          Operator
'f'           Name
' '           Text
'f'           Name
')'           Operator
'}'           Operator
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'Mst'         Name.Class
' '           Text
'('           Operator
'step_result' Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
' '           Text
'('           Operator
'step_req'    Name
' '           Text
'f'           Name
')'           Operator
' '           Text
'('           Operator
'step_ens'    Name
' '           Text
'f'           Name
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'NMSTATE'     Name.Class
'?.'          Operator
'reflect'     Name
' '           Text
'('           Operator
'fun'         Keyword
' '           Text
'('           Operator
'_'           Name
','           Operator
' '           Text
'n'           Name
')'           Operator
' '           Text
'->'          Operator
' '           Text
'step_frame_ret_aux' Name
' '           Text
'f'           Name
','           Operator
' '           Text
'n'           Name
')'           Operator
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'step_frame'  Name
'\n      '    Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'pre'         Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'p'           Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'lpre'        Name
':'           Operator
'l_pre'       Name
' '           Text
'pre'         Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'lpost'       Name
':'           Operator
'l_post'      Name
' '           Text
'pre'         Name
' '           Text
'p'           Name
')'           Operator
'\n      '    Text
'('           Operator
'f'           Name
':'           Operator
'm'           Name
' '           Text
'st'          Name
' '           Text
'a'           Name
' '           Text
'pre'         Name
' '           Text
'p'           Name
' '           Text
'lpre'        Name
' '           Text
'lpost'       Name
'{'           Operator
'Frame'       Name.Class
'?'           Operator
' '           Text
'f'           Name
'}'           Operator
')'           Operator
'\n      '    Text
'('           Operator
'step'        Name
':'           Operator
'step_t'      Name
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'Mst'         Name.Class
' '           Text
'('           Operator
'step_result' Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
' '           Text
'('           Operator
'step_req'    Name
' '           Text
'f'           Name
')'           Operator
' '           Text
'('           Operator
'step_ens'    Name
' '           Text
'f'           Name
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'match'       Keyword
' '           Text
'f'           Name
' '           Text
'with'        Keyword
'\n  '        Text
'|'           Operator
' '           Text
'Frame'       Name.Class
' '           Text
'('           Operator
'Ret'         Name.Class
' '           Text
'p'           Name
' '           Text
'x'           Name
' '           Text
'lp'          Name
')'           Operator
' '           Text
'frame'       Name
' '           Text
'f_frame'     Name
' '           Text
'->'          Operator
' '           Text
'step_frame_ret' Name
' '           Text
'f'           Name
'\n\n  '      Text
'|'           Operator
' '           Text
'Frame'       Name.Class
' '           Text
'#'           Operator
'_'           Name
' '           Text
'#'           Operator
'_'           Name
' '           Text
'#'           Operator
'f_pre'       Name
' '           Text
'#'           Operator
'_'           Name
' '           Text
'#'           Operator
'_'           Name
' '           Text
'#'           Operator
'_'           Name
' '           Text
'f'           Name
' '           Text
'frame'       Name
' '           Text
'f_frame'     Name
' '           Text
'->'          Operator
'\n    '      Text
'let'         Keyword.Declaration
' '           Text
'm0'          Name
' '           Text
'='           Operator
' '           Text
'get'         Name
' '           Text
'()'          Name.Builtin.Pseudo
' '           Text
'in'          Keyword
'\n\n    '    Text
'let'         Keyword.Declaration
' '           Text
'Step'        Name.Class
' '           Text
'next_fpre'   Name
' '           Text
'next_fpost'  Name
' '           Text
'next_flpre'  Name
' '           Text
'next_flpost' Name
' '           Text
'f'           Name
' '           Text
'='           Operator
' '           Text
'step'        Name
' '           Text
'f'           Name
' '           Text
'in'          Keyword
'\n\n    '    Text
'let'         Keyword.Declaration
' '           Text
'm1'          Name
' '           Text
'='           Operator
' '           Text
'get'         Name
' '           Text
'()'          Name.Builtin.Pseudo
' '           Text
'in'          Keyword
'\n\n    '    Text
'preserves_frame_star' Name
' '           Text
'f_pre'       Name
' '           Text
'next_fpre'   Name
' '           Text
'm0'          Name
' '           Text
'm1'          Name
' '           Text
'frame'       Name
';'           Operator
'\n\n    '    Text
'assert'      Name.Exception
' '           Text
'('           Operator
'('           Operator
'frame_lpre'  Name
' '           Text
'next_flpre'  Name
' '           Text
'f_frame'     Name
')'           Operator
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'core'        Name
' '           Text
'm1'          Name
')'           Operator
')'           Operator
'\n      '    Text
'by'          Keyword
' '           Text
'('           Operator
'norm'        Name
' '           Text
'['           Operator
'delta_only'  Name
' '           Text
'['           Operator
'`'           Keyword
'%'           Operator
'frame_lpre'  Name
']'           Operator
']'           Operator
')'           Operator
';'           Operator
'\n\n    '    Text
'Step'        Name.Class
' '           Text
'('           Operator
'next_fpre'   Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
' '           Text
'('           Operator
'fun'         Keyword
' '           Text
'x'           Name
' '           Text
'->'          Operator
' '           Text
'next_fpost'  Name
' '           Text
'x'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'frame'       Name
')'           Operator
'\n      '    Text
'('           Operator
'frame_lpre'  Name
' '           Text
'next_flpre'  Name
' '           Text
'f_frame'     Name
')'           Operator
'\n      '    Text
'('           Operator
'frame_lpost' Name
' '           Text
'next_flpre'  Name
' '           Text
'next_flpost' Name
' '           Text
'f_frame'     Name
')'           Operator
'\n      '    Text
'('           Operator
'Frame'       Name.Class
' '           Text
'f'           Name
' '           Text
'frame'       Name
' '           Text
'f_frame'     Name
')'           Operator
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'step_par_ret_aux' Name
'\n      '    Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'pre'         Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'post'        Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'lpre'        Name
':'           Operator
'l_pre'       Name
' '           Text
'pre'         Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'lpost'       Name
':'           Operator
'l_post'      Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
')'           Operator
'\n      '    Text
'('           Operator
'f'           Name
':'           Operator
'm'           Name
' '           Text
'st'          Name
' '           Text
'a'           Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
' '           Text
'lpre'        Name
' '           Text
'lpost'       Name
'{'           Operator
'Par'         Name.Class
'?'           Operator
' '           Text
'f'           Name
' '           Text
'/\\'         Operator
' '           Text
'Ret'         Name.Class
'?'           Operator
' '           Text
'('           Operator
'Par'         Name.Class
'?.'          Operator
'mL'          Name
' '           Text
'f'           Name
')'           Operator
' '           Text
'/\\'         Operator
' '           Text
'Ret'         Name.Class
'?'           Operator
' '           Text
'('           Operator
'Par'         Name.Class
'?.'          Operator
'mR'          Name
' '           Text
'f'           Name
')'           Operator
'}'           Operator
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'M'           Name.Namespace
'.'           Punctuation
'MSTATE'      Name.Class
' '           Text
'('           Operator
'step_result' Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
' '           Text
'st'          Name
'.'           Operator
'mem'         Name
' '           Text
'st'          Name
'.'           Operator
'locks_preorder' Name
' '           Text
'('           Operator
'step_req'    Name
' '           Text
'f'           Name
')'           Operator
' '           Text
'('           Operator
'step_ens'    Name
' '           Text
'f'           Name
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'M'           Name.Namespace
'.'           Punctuation
'MSTATE'      Name.Class
'?.'          Operator
'reflect'     Name
' '           Text
'('           Operator
'fun'         Keyword
' '           Text
'm0'          Name
' '           Text
'->'          Operator
'\n    '      Text
'match'       Keyword
' '           Text
'f'           Name
' '           Text
'with'        Keyword
'\n    '      Text
'|'           Operator
' '           Text
'Par'         Name.Class
' '           Text
'#'           Operator
'_'           Name
' '           Text
'#'           Operator
'aL'          Name
' '           Text
'#'           Operator
'_'           Name
' '           Text
'#'           Operator
'_'           Name
' '           Text
'#'           Operator
'_'           Name
' '           Text
'#'           Operator
'_'           Name
' '           Text
'('           Operator
'Ret'         Name.Class
' '           Text
'pL'          Name
' '           Text
'xL'          Name
' '           Text
'lpL'         Name
')'           Operator
' '           Text
'#'           Operator
'aR'          Name
' '           Text
'#'           Operator
'_'           Name
' '           Text
'#'           Operator
'_'           Name
' '           Text
'#'           Operator
'_'           Name
' '           Text
'#'           Operator
'_'           Name
' '           Text
'('           Operator
'Ret'         Name.Class
' '           Text
'pR'          Name
' '           Text
'xR'          Name
' '           Text
'lpR'         Name
')'           Operator
' '           Text
'->'          Operator
'\n      '    Text
'let'         Keyword.Declaration
' '           Text
'lpost'       Name
' '           Text
':'           Operator
' '           Text
'l_post'      Name
'\n        '  Text
'#'           Operator
'st'          Name
' '           Text
'#'           Operator
'('           Operator
'aL'          Name
' '           Text
'&'           Operator
' '           Text
'aR'          Name
')'           Operator
'\n        '  Text
'('           Operator
'pL'          Name
' '           Text
'xL'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'pR'          Name
' '           Text
'xR'          Name
')'           Operator
'\n        '  Text
'('           Operator
'fun'         Keyword
' '           Text
'('           Operator
'xL'          Name
','           Operator
' '           Text
'xR'          Name
')'           Operator
' '           Text
'->'          Operator
' '           Text
'pL'          Name
' '           Text
'xL'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'pR'          Name
' '           Text
'xR'          Name
')'           Operator
'\n      '    Text
'='           Operator
'\n        '  Text
'fun'         Keyword
' '           Text
'h0'          Name
' '           Text
'('           Operator
'xL'          Name
','           Operator
' '           Text
'xR'          Name
')'           Operator
' '           Text
'h1'          Name
' '           Text
'->'          Operator
' '           Text
'lpL'         Name
' '           Text
'h0'          Name
' '           Text
'xL'          Name
' '           Text
'h1'          Name
' '           Text
'/\\'         Operator
' '           Text
'lpR'         Name
' '           Text
'h0'          Name
' '           Text
'xR'          Name
' '           Text
'h1'          Name
'\n      '    Text
'in'          Keyword
'\n      '    Text
'Step'        Name.Class
' '           Text
'('           Operator
'pL'          Name
' '           Text
'xL'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'pR'          Name
' '           Text
'xR'          Name
')'           Operator
' '           Text
'('           Operator
'fun'         Keyword
' '           Text
'('           Operator
'xL'          Name
','           Operator
' '           Text
'xR'          Name
')'           Operator
' '           Text
'->'          Operator
' '           Text
'pL'          Name
' '           Text
'xL'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'pR'          Name
' '           Text
'xR'          Name
')'           Operator
'\n        '  Text
'('           Operator
'fun'         Keyword
' '           Text
'h'           Name
' '           Text
'->'          Operator
' '           Text
'lpL'         Name
' '           Text
'h'           Name
' '           Text
'xL'          Name
' '           Text
'h'           Name
' '           Text
'/\\'         Operator
' '           Text
'lpR'         Name
' '           Text
'h'           Name
' '           Text
'xR'          Name
' '           Text
'h'           Name
')'           Operator
'\n        '  Text
'lpost'       Name
'\n        '  Text
'('           Operator
'Ret'         Name.Class
' '           Text
'('           Operator
'fun'         Keyword
' '           Text
'('           Operator
'xL'          Name
','           Operator
' '           Text
'xR'          Name
')'           Operator
' '           Text
'->'          Operator
' '           Text
'pL'          Name
' '           Text
'xL'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'pR'          Name
' '           Text
'xR'          Name
')'           Operator
' '           Text
'('           Operator
'xL'          Name
','           Operator
' '           Text
'xR'          Name
')'           Operator
' '           Text
'lpost'       Name
')'           Operator
','           Operator
' '           Text
'm0'          Name
')'           Operator
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'step_par_ret' Name
'\n      '    Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'pre'         Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'post'        Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'lpre'        Name
':'           Operator
'l_pre'       Name
' '           Text
'pre'         Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'lpost'       Name
':'           Operator
'l_post'      Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
')'           Operator
'\n      '    Text
'('           Operator
'f'           Name
':'           Operator
'm'           Name
' '           Text
'st'          Name
' '           Text
'a'           Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
' '           Text
'lpre'        Name
' '           Text
'lpost'       Name
'{'           Operator
'Par'         Name.Class
'?'           Operator
' '           Text
'f'           Name
' '           Text
'/\\'         Operator
' '           Text
'Ret'         Name.Class
'?'           Operator
' '           Text
'('           Operator
'Par'         Name.Class
'?.'          Operator
'mL'          Name
' '           Text
'f'           Name
')'           Operator
' '           Text
'/\\'         Operator
' '           Text
'Ret'         Name.Class
'?'           Operator
' '           Text
'('           Operator
'Par'         Name.Class
'?.'          Operator
'mR'          Name
' '           Text
'f'           Name
')'           Operator
'}'           Operator
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'Mst'         Name.Class
' '           Text
'('           Operator
'step_result' Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
' '           Text
'('           Operator
'step_req'    Name
' '           Text
'f'           Name
')'           Operator
' '           Text
'('           Operator
'step_ens'    Name
' '           Text
'f'           Name
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'NMSTATE'     Name.Class
'?.'          Operator
'reflect'     Name
' '           Text
'('           Operator
'fun'         Keyword
' '           Text
'('           Operator
'_'           Name
','           Operator
' '           Text
'n'           Name
')'           Operator
' '           Text
'->'          Operator
' '           Text
'step_par_ret_aux' Name
' '           Text
'f'           Name
','           Operator
' '           Text
'n'           Name
')'           Operator
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'step_par'    Name
'\n      '    Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'pre'         Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'post'        Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'lpre'        Name
':'           Operator
'l_pre'       Name
' '           Text
'pre'         Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'lpost'       Name
':'           Operator
'l_post'      Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
')'           Operator
'\n      '    Text
'('           Operator
'f'           Name
':'           Operator
'm'           Name
' '           Text
'st'          Name
' '           Text
'a'           Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
' '           Text
'lpre'        Name
' '           Text
'lpost'       Name
'{'           Operator
'Par'         Name.Class
'?'           Operator
' '           Text
'f'           Name
'}'           Operator
')'           Operator
'\n      '    Text
'('           Operator
'step'        Name
':'           Operator
'step_t'      Name
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'Mst'         Name.Class
' '           Text
'('           Operator
'step_result' Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
' '           Text
'('           Operator
'step_req'    Name
' '           Text
'f'           Name
')'           Operator
' '           Text
'('           Operator
'step_ens'    Name
' '           Text
'f'           Name
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'match'       Keyword
' '           Text
'f'           Name
' '           Text
'with'        Keyword
'\n  '        Text
'|'           Operator
' '           Text
'Par'         Name.Class
' '           Text
'('           Operator
'Ret'         Name.Class
' '           Text
'_'           Name
' '           Text
'_'           Name
' '           Text
'_'           Name
')'           Operator
' '           Text
'('           Operator
'Ret'         Name.Class
' '           Text
'_'           Name
' '           Text
'_'           Name
' '           Text
'_'           Name
')'           Operator
' '           Text
'->'          Operator
' '           Text
'step_par_ret' Name
' '           Text
'f'           Name
'\n\n  '      Text
'|'           Operator
' '           Text
'Par'         Name.Class
' '           Text
'#'           Operator
'_'           Name
' '           Text
'#'           Operator
'aL'          Name
' '           Text
'#'           Operator
'preL'        Name
' '           Text
'#'           Operator
'postL'       Name
' '           Text
'#'           Operator
'lpreL'       Name
' '           Text
'#'           Operator
'lpostL'      Name
' '           Text
'mL'          Name
' '           Text
'#'           Operator
'aR'          Name
' '           Text
'#'           Operator
'preR'        Name
' '           Text
'#'           Operator
'postR'       Name
' '           Text
'#'           Operator
'lpreR'       Name
' '           Text
'#'           Operator
'lpostR'      Name
' '           Text
'mR'          Name
' '           Text
'->'          Operator
'\n    '      Text
'let'         Keyword.Declaration
' '           Text
'b'           Name
' '           Text
'='           Operator
' '           Text
'sample'      Name
' '           Text
'()'          Name.Builtin.Pseudo
' '           Text
'in'          Keyword
'\n\n    '    Text
'if'          Keyword
' '           Text
'b'           Name
' '           Text
'then'        Keyword
' '           Text
'begin'       Name
'\n      '    Text
'let'         Keyword.Declaration
' '           Text
'm0'          Name
' '           Text
'='           Operator
' '           Text
'get'         Name
' '           Text
'()'          Name.Builtin.Pseudo
' '           Text
'in'          Keyword
'\n\n      '  Text
'let'         Keyword.Declaration
' '           Text
'Step'        Name.Class
' '           Text
'next_preL'   Name
' '           Text
'next_postL'  Name
' '           Text
'next_lpreL'  Name
' '           Text
'next_lpostL' Name
' '           Text
'mL'          Name
' '           Text
'='           Operator
' '           Text
'step'        Name
' '           Text
'mL'          Name
' '           Text
'in'          Keyword
'\n\n      '  Text
'let'         Keyword.Declaration
' '           Text
'm1'          Name
' '           Text
'='           Operator
' '           Text
'get'         Name
' '           Text
'()'          Name.Builtin.Pseudo
' '           Text
'in'          Keyword
'\n\n      '  Text
'preserves_frame_star' Name
' '           Text
'preL'        Name
' '           Text
'next_preL'   Name
' '           Text
'm0'          Name
' '           Text
'm1'          Name
' '           Text
'preR'        Name
';'           Operator
'\n      '    Text
'par_weaker_lpre_and_stronger_lpost_l' Name
' '           Text
'lpreL'       Name
' '           Text
'lpostL'      Name
' '           Text
'next_lpreL'  Name
' '           Text
'next_lpostL' Name
' '           Text
'lpreR'       Name
' '           Text
'lpostR'      Name
' '           Text
'm0'          Name
' '           Text
'm1'          Name
';'           Operator
'\n\n      '  Text
'let'         Keyword.Declaration
' '           Text
'next_post'   Name
' '           Text
'='           Operator
' '           Text
'('           Operator
'fun'         Keyword
' '           Text
'('           Operator
'xL'          Name
','           Operator
' '           Text
'xR'          Name
')'           Operator
' '           Text
'->'          Operator
' '           Text
'next_postL'  Name
' '           Text
'xL'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'postR'       Name
' '           Text
'xR'          Name
')'           Operator
' '           Text
'in'          Keyword
'\n\n      '  Text
'assert'      Name.Exception
' '           Text
'('           Operator
'stronger_post' Name
' '           Text
'post'        Name
' '           Text
'next_post'   Name
')'           Operator
' '           Text
'by'          Keyword
' '           Text
'('           Operator
'norm'        Name
' '           Text
'['           Operator
'delta_only'  Name
' '           Text
'['           Operator
'`'           Keyword
'%'           Operator
'stronger_post' Name
']'           Operator
']'           Operator
')'           Operator
';'           Operator
'\n\n      '  Text
'Step'        Name.Class
' '           Text
'('           Operator
'next_preL'   Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'preR'        Name
')'           Operator
' '           Text
'next_post'   Name
'\n        '  Text
'('           Operator
'par_lpre'    Name
' '           Text
'next_lpreL'  Name
' '           Text
'lpreR'       Name
')'           Operator
'\n        '  Text
'('           Operator
'par_lpost'   Name
' '           Text
'next_lpreL'  Name
' '           Text
'next_lpostL' Name
' '           Text
'lpreR'       Name
' '           Text
'lpostR'      Name
')'           Operator
'\n        '  Text
'('           Operator
'Par'         Name.Class
' '           Text
'mL'          Name
' '           Text
'mR'          Name
')'           Operator
'\n\n    '    Text
'end'         Keyword
'\n    '      Text
'else'        Keyword
' '           Text
'begin'       Name
'\n      '    Text
'let'         Keyword.Declaration
' '           Text
'm0'          Name
' '           Text
'='           Operator
' '           Text
'get'         Name
' '           Text
'()'          Name.Builtin.Pseudo
' '           Text
'in'          Keyword
'\n\n      '  Text
'let'         Keyword.Declaration
' '           Text
'Step'        Name.Class
' '           Text
'next_preR'   Name
' '           Text
'next_postR'  Name
' '           Text
'next_lpreR'  Name
' '           Text
'next_lpostR' Name
' '           Text
'mR'          Name
' '           Text
'='           Operator
' '           Text
'step'        Name
' '           Text
'mR'          Name
' '           Text
'in'          Keyword
'\n\n      '  Text
'let'         Keyword.Declaration
' '           Text
'm1'          Name
' '           Text
'='           Operator
' '           Text
'get'         Name
' '           Text
'()'          Name.Builtin.Pseudo
' '           Text
'in'          Keyword
'\n\n      '  Text
'preserves_frame_star_left' Name
' '           Text
'preR'        Name
' '           Text
'next_preR'   Name
' '           Text
'm0'          Name
' '           Text
'm1'          Name
' '           Text
'preL'        Name
';'           Operator
'\n      '    Text
'par_weaker_lpre_and_stronger_lpost_r' Name
' '           Text
'lpreL'       Name
' '           Text
'lpostL'      Name
' '           Text
'lpreR'       Name
' '           Text
'lpostR'      Name
' '           Text
'next_lpreR'  Name
' '           Text
'next_lpostR' Name
' '           Text
'm0'          Name
' '           Text
'm1'          Name
';'           Operator
'\n\n      '  Text
'let'         Keyword.Declaration
' '           Text
'next_post'   Name
' '           Text
'='           Operator
' '           Text
'('           Operator
'fun'         Keyword
' '           Text
'('           Operator
'xL'          Name
','           Operator
' '           Text
'xR'          Name
')'           Operator
' '           Text
'->'          Operator
' '           Text
'postL'       Name
' '           Text
'xL'          Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'next_postR'  Name
' '           Text
'xR'          Name
')'           Operator
' '           Text
'in'          Keyword
'\n\n      '  Text
'stronger_post_par_r' Name
' '           Text
'postL'       Name
' '           Text
'postR'       Name
' '           Text
'next_postR'  Name
';'           Operator
'\n\n      '  Text
'Step'        Name.Class
' '           Text
'('           Operator
'preL'        Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'next_preR'   Name
')'           Operator
' '           Text
'next_post'   Name
'\n        '  Text
'('           Operator
'par_lpre'    Name
' '           Text
'lpreL'       Name
' '           Text
'next_lpreR'  Name
')'           Operator
'\n        '  Text
'('           Operator
'par_lpost'   Name
' '           Text
'lpreL'       Name
' '           Text
'lpostL'      Name
' '           Text
'next_lpreR'  Name
' '           Text
'next_lpostR' Name
')'           Operator
'\n        '  Text
'('           Operator
'Par'         Name.Class
' '           Text
'mL'          Name
' '           Text
'mR'          Name
')'           Operator
'\n    '      Text
'end'         Keyword
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'step_weaken' Name
'\n      '    Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
' '           Text
'u#'          Operator
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'pre'         Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'post'        Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'lpre'        Name
':'           Operator
'l_pre'       Name
' '           Text
'pre'         Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'lpost'       Name
':'           Operator
'l_post'      Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
')'           Operator
'\n      '    Text
'('           Operator
'f'           Name
':'           Operator
'm'           Name
' '           Text
'st'          Name
' '           Text
'a'           Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
' '           Text
'lpre'        Name
' '           Text
'lpost'       Name
'{'           Operator
'Weaken'      Name.Class
'?'           Operator
' '           Text
'f'           Name
'}'           Operator
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'Mst'         Name.Class
' '           Text
'('           Operator
'step_result' Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
' '           Text
'('           Operator
'step_req'    Name
' '           Text
'f'           Name
')'           Operator
' '           Text
'('           Operator
'step_ens'    Name
' '           Text
'f'           Name
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'NMSTATE'     Name.Class
'?.'          Operator
'reflect'     Name
' '           Text
'('           Operator
'fun'         Keyword
' '           Text
'('           Operator
'_'           Name
','           Operator
' '           Text
'n'           Name
')'           Operator
' '           Text
'->'          Operator
'\n    '      Text
'let'         Keyword.Declaration
' '           Text
'Weaken'      Name.Class
' '           Text
'#'           Operator
'_'           Name
' '           Text
'#'           Operator
'_'           Name
' '           Text
'#'           Operator
'pre'         Name
' '           Text
'#'           Operator
'post'        Name
' '           Text
'#'           Operator
'lpre'        Name
' '           Text
'#'           Operator
'lpost'       Name
' '           Text
'#'           Operator
'_'           Name
' '           Text
'#'           Operator
'_'           Name
' '           Text
'#'           Operator
'_'           Name
' '           Text
'#'           Operator
'_'           Name
' '           Text
'#'           Operator
'_'           Name
' '           Text
'f'           Name
' '           Text
'='           Operator
' '           Text
'f'           Name
' '           Text
'in'          Keyword
'\n\n    '    Text
'Step'        Name.Class
' '           Text
'pre'         Name
' '           Text
'post'        Name
' '           Text
'lpre'        Name
' '           Text
'lpost'       Name
' '           Text
'f'           Name
','           Operator
' '           Text
'n'           Name
')'           Operator
'\n\n'        Text

'/// Step function' Comment
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'rec'         Keyword.Declaration
' '           Text
'step'        Name
'\n      '    Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
' '           Text
'u#'          Operator
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'pre'         Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'post'        Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'lpre'        Name
':'           Operator
'l_pre'       Name
' '           Text
'pre'         Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'lpost'       Name
':'           Operator
'l_post'      Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
')'           Operator
'\n      '    Text
'('           Operator
'f'           Name
':'           Operator
'm'           Name
' '           Text
'st'          Name
' '           Text
'a'           Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
' '           Text
'lpre'        Name
' '           Text
'lpost'       Name
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'Mst'         Name.Class
' '           Text
'('           Operator
'step_result' Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'step_req'    Name
' '           Text
'f'           Name
')'           Operator
'\n      '    Text
'('           Operator
'step_ens'    Name
' '           Text
'f'           Name
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'match'       Keyword
' '           Text
'f'           Name
' '           Text
'with'        Keyword
'\n  '        Text
'|'           Operator
' '           Text
'Ret'         Name.Class
' '           Text
'_'           Name
' '           Text
'_'           Name
' '           Text
'_'           Name
' '           Text
'->'          Operator
' '           Text
'step_ret'    Name
' '           Text
'f'           Name
'\n  '        Text
'|'           Operator
' '           Text
'Bind'        Name.Class
' '           Text
'_'           Name
' '           Text
'_'           Name
' '           Text
'->'          Operator
' '           Text
'step_bind'   Name
' '           Text
'f'           Name
' '           Text
'step'        Name
'\n  '        Text
'|'           Operator
' '           Text
'Act'         Name.Class
' '           Text
'_'           Name
' '           Text
'->'          Operator
' '           Text
'step_act'    Name
' '           Text
'f'           Name
'\n  '        Text
'|'           Operator
' '           Text
'Frame'       Name.Class
' '           Text
'_'           Name
' '           Text
'_'           Name
' '           Text
'_'           Name
' '           Text
'->'          Operator
' '           Text
'step_frame'  Name
' '           Text
'f'           Name
' '           Text
'step'        Name
'\n  '        Text
'|'           Operator
' '           Text
'Par'         Name.Class
' '           Text
'_'           Name
' '           Text
'_'           Name
' '           Text
'->'          Operator
' '           Text
'step_par'    Name
' '           Text
'f'           Name
' '           Text
'step'        Name
'\n  '        Text
'|'           Operator
' '           Text
'Weaken'      Name.Class
' '           Text
'_'           Name
' '           Text
'_'           Name
' '           Text
'_'           Name
' '           Text
'_'           Name
' '           Text
'->'          Operator
' '           Text
'step_weaken' Name
' '           Text
'f'           Name
'\n\n'        Text

'let'         Keyword.Declaration
' '           Text
'rec'         Keyword.Declaration
' '           Text
'run'         Name
'\n      '    Text
'('           Operator
'#'           Operator
'st'          Name
':'           Operator
'st'          Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'a'           Name
':'           Operator
'Type'        Name.Class
' '           Text
'u#'          Operator
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'pre'         Name
':'           Operator
'st'          Name
'.'           Operator
'hprop'       Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'post'        Name
':'           Operator
'post_t'      Name
' '           Text
'st'          Name
' '           Text
'a'           Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'lpre'        Name
':'           Operator
'l_pre'       Name
' '           Text
'pre'         Name
')'           Operator
'\n      '    Text
'('           Operator
'#'           Operator
'lpost'       Name
':'           Operator
'l_post'      Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
')'           Operator
'\n      '    Text
'('           Operator
'f'           Name
':'           Operator
'm'           Name
' '           Text
'st'          Name
' '           Text
'a'           Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
' '           Text
'lpre'        Name
' '           Text
'lpost'       Name
')'           Operator
'\n    '      Text
':'           Operator
' '           Text
'Mst'         Name.Class
' '           Text
'a'           Name
'\n      '    Text
'('           Operator
'requires'    Keyword
' '           Text
'fun'         Keyword
' '           Text
'm0'          Name
' '           Text
'->'          Operator
'\n        '  Text
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'('           Operator
'pre'         Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm0'          Name
')'           Operator
' '           Text
'm0'          Name
' '           Text
'/\\'         Operator
'\n        '  Text
'lpre'        Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'core'        Name
' '           Text
'm0'          Name
')'           Operator
')'           Operator
'\n      '    Text
'('           Operator
'ensures'     Keyword
' '           Text
'fun'         Keyword
' '           Text
'm0'          Name
' '           Text
'x'           Name
' '           Text
'm1'          Name
' '           Text
'->'          Operator
'\n        '  Text
'st'          Name
'.'           Operator
'interp'      Name
' '           Text
'('           Operator
'post'        Name
' '           Text
'x'           Name
' '           Text
'`st.star`'   Operator.Word
' '           Text
'st'          Name
'.'           Operator
'locks_invariant' Name
' '           Text
'm1'          Name
')'           Operator
' '           Text
'm1'          Name
' '           Text
'/\\'         Operator
'\n        '  Text
'lpost'       Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'core'        Name
' '           Text
'm0'          Name
')'           Operator
' '           Text
'x'           Name
' '           Text
'('           Operator
'st'          Name
'.'           Operator
'core'        Name
' '           Text
'm1'          Name
')'           Operator
' '           Text
'/\\'         Operator
'\n        '  Text
'preserves_frame' Name
' '           Text
'pre'         Name
' '           Text
'('           Operator
'post'        Name
' '           Text
'x'           Name
')'           Operator
' '           Text
'm0'          Name
' '           Text
'm1'          Name
')'           Operator
'\n    '      Text
'='           Operator
'\n  '        Text
'match'       Keyword
' '           Text
'f'           Name
' '           Text
'with'        Keyword
'\n  '        Text
'|'           Operator
' '           Text
'Ret'         Name.Class
' '           Text
'_'           Name
' '           Text
'x'           Name
' '           Text
'_'           Name
' '           Text
'->'          Operator
' '           Text
'x'           Name
'\n\n  '      Text
'|'           Operator
' '           Text
'_'           Name
' '           Text
'->'          Operator
'\n    '      Text
'let'         Keyword.Declaration
' '           Text
'm0'          Name
' '           Text
'='           Operator
' '           Text
'get'         Name
' '           Text
'()'          Name.Builtin.Pseudo
' '           Text
'in'          Keyword
'\n    '      Text
'let'         Keyword.Declaration
' '           Text
'Step'        Name.Class
' '           Text
'new_pre'     Name
' '           Text
'new_post'    Name
' '           Text
'_'           Name
' '           Text
'_'           Name
' '           Text
'f'           Name
' '           Text
'='           Operator
' '           Text
'step'        Name
' '           Text
'f'           Name
' '           Text
'in'          Keyword
'\n    '      Text
'let'         Keyword.Declaration
' '           Text
'm1'          Name
' '           Text
'='           Operator
' '           Text
'get'         Name
' '           Text
'()'          Name.Builtin.Pseudo
' '           Text
'in'          Keyword
'\n    '      Text
'let'         Keyword.Declaration
' '           Text
'x'           Name
' '           Text
'='           Operator
' '           Text
'run'         Name
' '           Text
'f'           Name
' '           Text
'in'          Keyword
'\n    '      Text
'let'         Keyword.Declaration
' '           Text
'm2'          Name
' '           Text
'='           Operator
' '           Text
'get'         Name
' '           Text
'()'          Name.Builtin.Pseudo
' '           Text
'in'          Keyword
'\n\n    '    Text
'preserves_frame_trans' Name
' '           Text
'pre'         Name
' '           Text
'new_pre'     Name
' '           Text
'('           Operator
'new_post'    Name
' '           Text
'x'           Name
')'           Operator
' '           Text
'm0'          Name
' '           Text
'm1'          Name
' '           Text
'm2'          Name
';'           Operator
'\n    '      Text
'preserves_frame_stronger_post' Name
' '           Text
'pre'         Name
' '           Text
'post'        Name
' '           Text
'new_post'    Name
' '           Text
'x'           Name
' '           Text
'm0'          Name
' '           Text
'm2'          Name
';'           Operator
'\n    '      Text
'x'           Name
'\n'          Text
