anchor.diff:                          | [var] -> sprintSingleVar var 
                           | tupledVars -> sprintf "(%s)" (tupledVars |> List.map sprintSingleVar |> String.concat ", "))
                   |> String.concat " "
  -            applyParens OP.Fun (sprintf "fun %s -> %s" sprintedVars (decompile (OP(0),OP.Non) body))
  +            applyParens OP.Fun (sprintf "fun %s -> %s" sprintedVars (decompile CC.Zero body))
           | EP.BinaryInfixCall((symbol, prec), lhs, rhs) -> //must come before Call pattern
               let lhsValue, rhsValue = decompile (prec,OP.Left) lhs, decompile (prec,OP.Right) rhs
               applyParens prec (sprintf "%s %s %s" lhsValue symbol rhsValue)
  
positive.code:             else 
                  let decompiledTarget =
                      match target with
                      | Some(target) -> (decompile (OP(22),OP.Non) target) //instance
                      | None -> ER.sourceName mi.DeclaringType
  
                  applyParens OP.Application (sprintf "%s.%s%s" decompiledTarget methodName sprintedArgs)
          | P.Call(target, mi, args) -> //a "normal" .net instance or static call
              let decompiledTarget =
                  match target with
                  | Some(target) -> (decompile (OP(22),OP.Non) target) //instance
                  | None -> mi.DeclaringType.Name
              applyParens OP.Application (sprintf "%s.%s%s(%s)" decompiledTarget mi.Name (ER.sprintGenericArgsIfNotInferable mi) (decompileTupledArgs args)) //SHOULD BE CALL PREC
          | P.PropertyGet(Some(target), pi, args) -> //instance get
              match pi.Name, args with
              | CompiledMatch(@"^Item(\d*)?$") _, _ when pi.DeclaringType |> FSharpType.IsUnion ->
                  //for UnionCaseTypeTests, require a op_Dynamic implementation
                  sprintf "(%s?%s : %s)" (decompile (OP(22),OP.Non) target) pi.Name (pi.PropertyType |> ER.sprintSig)
              | _, [] -> sprintf "%s.%s" (decompile (OP(22),OP.Non) target) pi.Name //also includes "Item" with zero args
              | "Item", _ -> sprintf "%s.[%s]" (decompile (OP(22),OP.Non) target) (decompileTupledArgs args)
              | _, _ -> applyParens OP.Application (sprintf "%s.%s(%s)" (decompile (OP(22),OP.Non) target) pi.Name (decompileTupledArgs args)) //SHOULD BE CALL
          | P.PropertyGet(None, pi, args) -> //static get (note: can't accept params)
              let sprintedName =
                  if ER.isOpenModule pi.DeclaringType then 
  
negative.code:         | P.TypeTest(lhs, ty) -> //seems to be same as TypeTestGeneric
              applyParens OP.TypeTest (sprintf "%s :? %s" (decompile (OP.TypeTest,OP.Left) lhs) (ER.sprintSig ty))
          | EP.Range(startToken,endToken,a,b) -> //not sure about precedence for op ranges
              sprintf "%s%s..%s%s" startToken (decompile CC.Zero a) (decompile CC.Zero b) endToken
          | EP.RangeStep(startToken,endToken,a,b,c) ->
              sprintf "%s%s..%s..%s%s" startToken (decompile CC.Zero a) (decompile CC.Zero b) (decompile CC.Zero c) endToken
          | P.Call(None, mi, target::[]) when mi.DeclaringType.Name = "IntrinsicFunctions" && mi.Name = "UnboxGeneric" -> //i.e. :?>
              let ty = mi.GetGenericArguments().[0]
              applyParens OP.DynamicCast (sprintf "%s :?> %s" (decompile (OP.DynamicCast,OP.Left) target) (ER.sprintSig ty))
          | P.Call(None, mi, target::args) when mi.DeclaringType.Name = "IntrinsicFunctions" -> //e.g. GetChar, GetArray, GetArray2D
              sprintf "%s.[%s]" (decompile CC.TwentyTwo target) (decompileTupledArgs args) //not sure what precedence is
          | P.Call(target, (ER.FunctionOrGenericValue(fOrGV) as mi), args) -> //instance or static call representing an F# function or generic value
              //if mi has generic args which can't be infered, need to sprint them.
              //if mi takes no arguments, then need to decompile "()", unless mi is an F# value, in which case we omit ()
  