anchor.diff:                  | Some(instance) -> Expr.PropertyGet(instance, pi, piArgs)
                   | None -> Expr.PropertyGet(pi, piArgs)
               //don't know what precedence is
  -            applyParens OP.LessThanOp (sprintf "%s <- %s" (decompile (OP(0),OP.Non) lhs) (decompile (OP(0),OP.Non) rhs))
  +            applyParens OP.LessThanOp (sprintf "%s <- %s" (decompile CC.Zero lhs) (decompile CC.Zero rhs))
           | P.FieldGet(Some(target), fi) ->
  -            sprintf "%s.%s" (decompile (OP(22),OP.Non) target) fi.Name
  +            sprintf "%s.%s" (decompile CC.TwentyTwo target) fi.Name
           | P.FieldGet(None, fi) ->
               sprintf "%s.%s" fi.DeclaringType.Name fi.Name
           | P.FieldSet(target, fi, rhs) ->
  
positive.code:                         | [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))
          | 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)
  
negative.code: 
                  if expr |> isLiteralConstruction then
                      let rec sprintLiteralConstructionArgs = function
                          | P.NewUnionCase(_, lhs::(P.NewUnionCase(_, []))::[]) -> decompile (OP.Semicolon,OP.Non) lhs
                          | P.NewUnionCase(_, lhs::rhs::[]) ->
                              sprintf "%s; %s" (decompile (OP.Semicolon,OP.Non) lhs) (sprintLiteralConstructionArgs rhs)
                          | _ -> failwith "unexpected list union case"
                      sprintf "[%s]" (sprintLiteralConstructionArgs expr)
                  else 
  