anchor.diff:  
   let rec tabbedStringify (prefix : string) (tab : string) (json : JSON) : string =
       let itself = tabbedStringify (prefix + tab) tab
  -    let s_name (s : string) : string = "\"" + s + "\""
  +
  +    let print_char = function
  +        | '\"' -> "\\\"" 
  +        | '\\' -> "\\\\" //'" (syntax highlining broken : ( )
  +        | '/' -> "\\/" 
  +        | '\b' -> "\\b"
  +        | '\u000C' -> "\\f"
  +        | '\n' -> "\\n"
  +        | '\r' -> "\\r"
  +        | '\t' -> "\\t"
  +        | c -> Convert.ToString c
  +
  +    let s_name (s : string) : string =
  +        "\"" + String.collect print_char s + "\""
  +
  +    let print_number (x : Number) : string =
  +        match x with
  +        | Float f -> sprintf "%f" f
  +        | Int i -> sprintf "%d" i
   
       let rec print_list (acc : string) (l : JSON list) : string = 
           match l with
  
positive.code:         | 'n'::'u'::'l'::'l'::t -> tokenize' (Null :: acc) t
          | '"'::t -> let (s, t') = parseString "" t //"
                      tokenize' (String s :: acc) t' 
          | digit :: t when (Char.IsDigit digit) ->
                      let (n, t') = parseNumber (charToInt digit) t
                      tokenize' (Number n :: acc) t'
          | 't'::'r'::'u'::'e'::t -> tokenize' (Boolean true :: acc) t
          | 'f'::'a'::'l'::'s'::'e'::t -> tokenize' (Boolean false :: acc) t
          | [] -> acc
  
negative.code:         (int char) - (int '0')
  
      let rec parseString acc = function
          | '"' :: t -> (acc, t) //'"
          | '\\' :: 'n' :: t -> parseString (acc + "\n") t
          | '\\' :: 'r' :: t -> parseString (acc + "\r") t
          | '\\' :: 't' :: t -> parseString (acc + "\t") t
          | '\\' :: '\'' :: t -> parseString (acc + "\'") t
          | '\\' :: '\"' :: t -> parseString (acc + "\"") t
          | '\\' :: '\\' :: t -> parseString (acc + "\\") t //'"
          | '\\' :: '/' :: t -> parseString (acc + "/") t
          | '\\' :: 'b' :: t -> parseString (acc + "\b") t
          | '\\' :: 'f' :: t -> parseString (acc + "\u000C") t
          | '\\' :: 'u' :: a :: b :: c :: d :: t ->
              let s = implode('\\' :: 'u' :: a :: b :: c :: [d])
              parseString (appendChar acc (char (Int32.Parse(s.Substring(2), NumberStyles.HexNumber)))) t
          | c :: t -> parseString (appendChar acc c) t
          | _ -> failwith "string parser error"
          // What should we do if line brakes?
  
      let isNumberChar c =
          (Char.IsDigit c) || (c = '-') || (c = '+') || (c = '.')
  
      let rec parseNumber acc = function
          | digit :: t when (isNumberChar digit) || (digit = 'e') || (digit = 'E')  ->
                      parseNumber (appendChar acc  digit) t
          | list -> (acc, list)
         
      let strToNumber x =
          if not (Regex("\A[\-]?([0]|[1-9][0-9]*)([\.][0-9]+)?([eE][\+\-]?[0-9]+)?\z")
              .IsMatch(x)) then failwith ("Bad number" + x)
          else 
              if (x.Contains(".") || x.Contains("E") || x.Contains("e")) then
                  Number.Float(float x)
              else
                  Number.Int(int x)
  
      let rec tokenize' acc = function
          | w :: t when (Char.IsWhiteSpace w) -> tokenize' acc t
  