anchor.diff:          (int char) - (int '0')
   
       let rec parseString acc = function
  -        |  '"' :: t -> (acc, t) //'"
  +        | '"' :: 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 (Char.IsDigit digit) ->
  -                    parseNumber (acc * 10 + (charToInt digit)) t
  -        | char :: t -> (acc, char :: t)
  -        | [] -> (acc, [])
  +        | 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
  
positive.code:     let genBoolean = 
          fun() -> (rand 2) = 1
      let genNumber =
          fun() -> rnd.Next()
      let genChar = 
          fun() -> sprintf "%c" (char ((int 'a') + (rand 26)))
      let genStr len =
  
negative.code:     match json with
      | JSON_Null -> "null"
      | JSON_String s -> s_name s
      | JSON_Number n -> print_number n
      | JSON_Boolean b -> match b with
                          | true -> "true"
                          | _ -> "false"
  