anchor.diff:          if ok >= 0 then
               okToInline.[i] <- okToInline.[i] + 1               
   
  -type MatchValueTransformer(c) =
  +type MatchValueTransformer(c, twoCase) =
       inherit Transformer()
   
       override this.TransformMatchSuccess(index, results) =
  
positive.code:                 InlineMatchValueTransformer(trCases).TransformExpression(trMatchVal)    
              else
                  let c = newId()
                  let res = newId()
                  Sequential [
                      NewVar(c, Undefined)
                      StatementExpr(
                          Switch(
                              MatchValueTransformer(c).TransformExpression(trMatchVal), 
                              trCases |> List.mapi (fun j (captures, body) ->
                                  let e =
                                      match captures with
                                      | [] -> body
                                      | [capt] ->
                                          ReplaceId(capt, c).TransformExpression(body)
                                      | _ ->
                                          body |> List.foldBack (fun (i, id) body -> 
                                              Let(id, ItemGet(Var c, Value (Int i)), body)) (List.indexed captures)
                                  Some (Value (Int j)), 
                                  Block [
                                      VarSetStatement(res, e) 
                                      Break None 
                                  ]
                              )
                          )
                          , Some res
                      )
                  ]
          | BasicPatterns.DecisionTreeSuccess (index, results) ->
  
negative.code:             | [] -> ()
              | [ capt ] -> yield VarSet (c, capt) 
              | _ -> yield VarSet (c, NewArray results) 
              if twoCase then
                  yield Value (Bool (index = 0))
              else
                  yield Value (Int index)
          ]
  
  type InlineMatchValueTransformer(cases : (Id list * Expression) list) =
  