anchor.diff:      | 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 ] ))
  +        makeCAS model
  +                (mkIntLV ctx dest :> Expr)
  +                (mkIntLV ctx test :> Expr)
  +                set
       | BoolCAS (dest, test, set) ->
  -        (makeCAS model
  -                 (mkBoolLV ctx dest :> Expr)
  -                 (mkBoolLV ctx test :> Expr)
  -                 set,
  -         new Set<string> ( [ flattenLV dest
  -                             flattenLV test ] ))
  +        makeCAS model
  +                (mkBoolLV ctx dest :> Expr)
  +                (mkBoolLV ctx test :> Expr)
  +                set
       | ArithLocalSet (dest, srcE) ->
           (* By the meta-theory, this and BoolLocalSet can be modelled
            * similarly to atomic fetches.
  
positive.code:     let destE = mkBoolLV ctx dest
      let srcE = mkBoolLV ctx src
  
      ( [makeRel model srcE destE
         makeNoChange model srcE],
        new Set<string> ( [flattenLV dest
                           flattenLV src] ))
  
  /// Emits Z3 corresponding to a prim.
  /// The result is a pair of the Z3 emission, and the set of names of
  
negative.code:     (* We have to use Some and List.collect to ensure that the term
       * for dest is only included if there actually _is_ a dest.
       *)
      [// 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 =
  