anchor.diff:      (* We have to use Some and List.collect to ensure that the term
        * for dest is only included if there actually _is_ a dest.
        *)
  -    let terms = [// If dest exists, create dest!after = src!before.
  -                 Option.map (makeRel model srcE) destE
  -                 // Create src!after = F(src!before), where F is
  -                 // defined by the fetch mode.
  -                 makeFetchUpdate model srcE mode |> Some]
  -                |> List.choose id
  -
  -    // The variables whose post-states are bound are src, and, if
  -    // present, dest.
  -    let vars = [Option.map flattenLV dest
  -                Some <| flattenLV src]
  -               |> List.choose id
  -
  -    (terms, new Set<string> (vars))
  +    [// If dest exists, create dest!after = src!before.
  +     Option.map (makeRel model srcE) destE
  +     // Create src!after = F(src!before), where F is
  +     // defined by the fetch mode.
  +     makeFetchUpdate model srcE mode |> Some]
  +    |> List.choose id
   
   /// Emits a Boolean fetch.
   let makeBoolFetch model dest src =
  
positive.code:     | ArithFetch (dest, src, mode) -> makeArithFetch model dest src mode
      | BoolFetch (dest, src) -> makeBoolFetch model dest src
      | ArithCAS (dest, test, set) ->
          (makeCAS model
                   (mkIntLV ctx dest :> Expr)
                   (mkIntLV ctx test :> Expr)
                   set,
           new Set<string> ( [ flattenLV dest
                               flattenLV test ] ))
      | BoolCAS (dest, test, set) ->
          (makeCAS model
                   (mkBoolLV ctx dest :> Expr)
                   (mkBoolLV ctx test :> Expr)
                   set,
           new Set<string> ( [ flattenLV dest
                               flattenLV test ] ))
      | ArithLocalSet (dest, srcE) ->
          (* By the meta-theory, this and BoolLocalSet can be modelled
           * similarly to atomic fetches.
  
negative.code:          *)
          let ctx = model.Context
          let destE = mkIntLV ctx dest
          [makeRel model srcE destE]
      | BoolLocalSet (dest, srcE) ->
          let ctx = model.Context
          let destE = mkBoolLV ctx dest
          [makeRel model srcE destE]
      | PrimId ->
          [ctx.MkTrue ()]
      | PrimAssume (assumption) ->
          // Assumes always only refer to the pre-state.
          [subAllInModel model envVarToBefore (assumption :> Expr) :?> BoolExpr]
  