anchor.diff:  let inlineCpp =
       let normalCharSnippet = manySatisfy (fun c -> c <> '\\' && c <> '#')
       let escapedChar = pstring "\\" >>. (anyOf "\\#" |>> string)
  -    between (pstring "#") (pstring "#") (stringsSepBy normalCharSnippet escapedChar) |> pos
  +    between (pstring "#") (pstring "#") (fatalizeAnyError (stringsSepBy normalCharSnippet escapedChar)) |> pos
   
   // expr
   do
  -    let punit = skipString "()" >>% () |> pos |>> UnitExp
  +    let punit = skipString "()" |> pos |>> UnitExp
       let parens = betweenChar '(' (expr |>> unwrap) ')'
       let ptrue = skipString "true" |> pos |>> TrueExp
       let pfalse = skipString "false" |> pos |>> FalseExp
  -    let pint = pos pint64 |>> IntExp .>> notFollowedByString "."
  -    let pdouble = pos pfloat |>> DoubleExp
  -    let pfloat = pos (pfloat .>> skipChar 'f') |>> FloatExp
  -    let pint8 = pos (pint64 .>> skipString "i8") |>> Int8Exp
  -    let pint16 = pos (pint64 .>> skipString "i16") |>> Int16Exp
  -    let pint32 = pos (pint64 .>> skipString "i32") |>> Int32Exp
  -    let pint64' = pos (pint64 .>> skipString "i64") |>> Int64Exp
  -    let puint8 = pos (pint64 .>> skipString "u8") |>> UInt8Exp
  -    let puint16 = pos (pint64 .>> skipString "u16") |>> UInt16Exp
  -    let puint32 = pos (pint64 .>> skipString "u32") |>> UInt32Exp
  -    let puint64 = pos (pint64 .>> skipString "u64") |>> UInt64Exp
  +    let floatParser =
  +        fun stream ->
  +            let reply = numberLiteralE NumberLiteralOptions.DefaultFloat (expected "floating-point number") stream
  +            if reply.Status = Ok then
  +                let result = reply.Result
  +                if result.IsInteger then
  +                    stream.Skip(-result.String.Length)
  +                    Reply(Error, expected "floating-point number with decimal")
  +                else
  +                    try
  +                        let d =
  +                            if result.IsDecimal then
  +                                System.Double.Parse(result.String, System.Globalization.CultureInfo.InvariantCulture)
  +                            elif result.IsHexadecimal then
  +                                floatOfHexString result.String
  +                            elif result.IsInfinity then
  +                                if result.HasMinusSign then System.Double.NegativeInfinity else System.Double.PositiveInfinity
  +                            else
  +                                System.Double.NaN
  +                        Reply(d)
  +                    with 
  +                    | :? System.OverflowException ->
  +                        Reply(if result.HasMinusSign then System.Double.NegativeInfinity else System.Double.PositiveInfinity)
  +                    | :? System.FormatException ->
  +                        stream.Skip(-result.String.Length)
  +                        Reply(FatalError, messageError "The floating-point number has an invalid format (this error is unexpected, please report this error message to fparsec@quanttec.com).")
  +            else
  +                Reply(reply.Status, reply.Error)
  +    
  +    let pfloating = (floatParser .>>. choice [skipChar 'f' >>. preturn FloatExp; preturn DoubleExp]) |>
  +                    pos |>>
  +                    (fun (posN, (num, constructor)) -> constructor (posN, num))
  +    let parseInt s t = skipString s >>. preturn t
  +    let pint = (pint64 .>>.
  +                    choice [parseInt "i8" Int8Exp; parseInt "i16" Int16Exp; parseInt "i32" Int32Exp;
  +                            parseInt "i64" Int64Exp; parseInt "u8" UInt8Exp; parseInt "u16" UInt32Exp;
  +                            parseInt "u32" UInt32Exp; parseInt "u64" UInt64Exp; preturn Int32Exp]) |>
  +               pos |>>
  +               (fun (posN, (num, constructor)) -> constructor (posN, num))
       let charlist = pos (stringLiteral '\'' true) |>> CharListLiteral
       let str = pos (stringLiteral '"' true) |>> StringLiteral
  -    let seq = betweenChar '(' (separatedList (attempt expr) ';' |> pos) ')' |>> SequenceExp
  -    let quit = skipString "quit" >>. ws >>. opt (skipChar '<' >>. ws >>. tyExpr .>> ws .>> skipChar '>') .>> ws .>> skipChar '(' .>> ws .>> skipChar ')' |>> QuitExp
  +    let seq = betweenChar '(' (((expr .>> ws .>> skipChar ';' .>> ws) .>>. fatalizeAnyError (separatedList expr ';')) |> pos) ')' |>> (fun (overallPos, (firstExpr, restExprs)) -> SequenceExp (overallPos, firstExpr::restExprs))
  +    let quit = skipString "quit" >>. ws >>. (fatalizeAnyError (opt (skipChar '<' >>. ws >>. tyExpr .>> ws .>> skipChar '>') .>> ws .>> skipChar '(' .>> ws .>> skipChar ')')) |>> QuitExp
       let applyTemplateToFunc =
           pipe2
               (pos ((attempt moduleQualifier |>> Choice2Of2) <|> (id |>> Choice1Of2)) .>> ws)
  
positive.code:                 | ArrayIndex index -> ArrayAccessExp {array=term; index=index}
                  | TypeConstraintType typ -> TypeConstraint {exp=term; typ=typ}
                  | FieldAccessName fieldName -> RecordAccessExp {record=term; fieldName=fieldName}
                  | UnsafeTypeCastType typ -> UnsafeTypeCast {exp=term; typ=typ}) |> attempt
  
  // templateApply
  do
  
negative.code:     let typeConstraint = skipChar ':' >>. ws >>. tyExpr |>> TypeConstraintType
      let fieldAccessName = skipChar '.' >>. ws >>. attempt id |> pos |>> FieldAccessName
      let unsafeTypeCast = skipString "::::" >>. ws >>. tyExpr |>> UnsafeTypeCastType
      [callArgs; arrayIndex; unsafeTypeCast; typeConstraint; fieldAccessName] |> choice |> pos .>> ws |> many
  
  // elifList
  do
  