anchor.diff:              | [] -> ()
               | [ capt ] -> yield VarSet (c, capt) 
               | _ -> yield VarSet (c, NewArray results) 
  -            yield Value (Int index)
  +            if twoCase then
  +                yield Value (Bool (index = 0))
  +            else
  +                yield Value (Int index)
           ]
   
   type InlineMatchValueTransformer(cases : (Id list * Expression) list) =
  
positive.code:         if ok >= 0 then
              okToInline.[i] <- okToInline.[i] + 1               
  
  type MatchValueTransformer(c) =
      inherit Transformer()
  
      override this.TransformMatchSuccess(index, results) =
  
negative.code:                 InlineMatchValueTransformer(trCases).TransformExpression(trMatchVal)    
              else
                  let c = newId()
                  let mv = MatchValueTransformer(c, trCases.Length = 2).TransformExpression(trMatchVal)
                  let cs = 
                      trCases |> List.map (fun (captures, body) ->
                          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)
                      )
                  
                  Sequential [
                      NewVar(c, Undefined)
                      (
                          match cs with
                          | [c1] ->
                              Sequential [mv; c1]
                          | [c1; c2] ->
                              Conditional(mv, c1, c2)
                          | _ ->
                              let res = newId()
                              let css =
                                  cs |> List.mapi (fun j e ->
                                      Some (Value (Int j)),
                                      Block [
                                          VarSetStatement(res, e) 
                                          Break None 
                                      ]
                                  )
                              StatementExpr(Switch(mv, css), Some res)
                      )
                  ]
          | BasicPatterns.DecisionTreeSuccess (index, results) ->
  