    {-# LANGUAGE BangPatterns #-}
    {-# LANGUAGE CPP          #-}
    {-# LANGUAGE MultiWayIf   #-}

    module Data.Aeson.Parser.UnescapePure
      ( unescapeText
      ) where

    import           Control.Exception        (throwIO, try)
    import           Data.Bits                (shiftL, shiftR, (.&.), (.|.))
    import           Data.ByteString          (ByteString)
    import           Data.Text                (Text)
    import           Data.Text.Encoding.Error (UnicodeException (..))
    import           Data.Text.Unsafe         (unsafeDupablePerformIO)
    import           Data.Word                (Word32, Word8)
    import           Foreign.ForeignPtr       (withForeignPtr)
    import           Foreign.Ptr              (Ptr, plusPtr)
    import           Foreign.Storable         (peek)

    import qualified Data.Primitive           as P
    import qualified Data.Text.Array          as T
    import qualified Data.Text.Internal       as T

    import Data.Aeson.Internal.ByteString

    #if !MIN_VERSION_text(2,0,0)
    import           Data.Word                (Word16)
    #endif

    unescapeText :: ByteString -> Either UnicodeException Text
    unescapeText :: ByteString -> Either UnicodeException Text
    unescapeText = IO (Either UnicodeException Text) -> Either UnicodeException Text
    forall a. IO a -> a
    unsafeDupablePerformIO (IO (Either UnicodeException Text) -> Either UnicodeException Text)
    -> (ByteString -> IO (Either UnicodeException Text))
    -> ByteString
    -> Either UnicodeException Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . IO Text -> IO (Either UnicodeException Text)
    forall e a. Exception e => IO a -> IO (Either e a)
    try (IO Text -> IO (Either UnicodeException Text))
    -> (ByteString -> IO Text)
    -> ByteString
    -> IO (Either UnicodeException Text)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ByteString -> IO Text
    unescapeTextIO

    throwDecodeError :: IO a
    throwDecodeError :: forall a. IO a
    throwDecodeError =
      let desc :: String
    desc = String
    "Data.Text.Internal.Encoding.decodeUtf8: Invalid UTF-8 stream"
       in UnicodeException -> IO a
    forall e a. Exception e => e -> IO a
    throwIO (String -> Maybe Word8 -> UnicodeException
    DecodeError String
    desc Maybe Word8
    forall a. Maybe a
    Nothing)

    -------------------------------------------------------------------------------
    -- unescapeTextIO
    -------------------------------------------------------------------------------

    -- This function is generated using staged-streams
    -- See: https://github.com/phadej/staged/blob/master/staged-streams-unicode/src/Unicode/JSON.hs
    --
    -- Because @aeson@ better to not use template-haskell itself,
    -- we dump the splice and prettify it by hand a bit.
    --
    unescapeTextIO :: ByteString -> IO Text

    #if MIN_VERSION_text(2,0,0)

    unescapeTextIO :: ByteString -> IO Text
    unescapeTextIO ByteString
    bs = ByteString -> (ForeignPtr Word8 -> Int -> IO Text) -> IO Text
    forall r. ByteString -> (ForeignPtr Word8 -> Int -> r) -> r
    withBS ByteString
    bs ((ForeignPtr Word8 -> Int -> IO Text) -> IO Text)
    -> (ForeignPtr Word8 -> Int -> IO Text) -> IO Text
    forall a b. (a -> b) -> a -> b
    $ \ForeignPtr Word8
    fptr Int
    len ->
      ForeignPtr Word8 -> (Ptr Word8 -> IO Text) -> IO Text
    forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
    withForeignPtr ForeignPtr Word8
    fptr ((Ptr Word8 -> IO Text) -> IO Text)
    -> (Ptr Word8 -> IO Text) -> IO Text
    forall a b. (a -> b) -> a -> b
    $ \Ptr Word8
    begin -> do
        let end :: Ptr Word8
            end :: Ptr Word8
    end = Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    begin Int
    len

        MutablePrimArray RealWorld Word8
    arr <- Int -> IO (MutablePrimArray (PrimState IO) Word8)
    forall (m :: * -> *) a.
    (PrimMonad m, Prim a) =>
    Int -> m (MutablePrimArray (PrimState m) a)
    P.newPrimArray Int
    len

        let write3bytes :: Int -> Word8 -> Word8 -> Word8 -> Ptr Word8 -> IO Text
            write3bytes :: Int -> Word8 -> Word8 -> Word8 -> Ptr Word8 -> IO Text
    write3bytes !Int
    out !Word8
    b1 !Word8
    b2 !Word8
    b3 !Ptr Word8
    inp = do
              MutablePrimArray (PrimState IO) Word8 -> Int -> Word8 -> IO ()
    forall a (m :: * -> *).
    (Prim a, PrimMonad m) =>
    MutablePrimArray (PrimState m) a -> Int -> a -> m ()
    P.writePrimArray MutablePrimArray RealWorld Word8
    MutablePrimArray (PrimState IO) Word8
    arr Int
    out Word8
    b1
              Int -> Word8 -> Word8 -> Ptr Word8 -> IO Text
    write2bytes (Int
    out Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1) Word8
    b2 Word8
    b3 Ptr Word8
    inp

            write2bytes :: Int -> Word8 -> Word8 -> Ptr Word8 -> IO Text
            write2bytes :: Int -> Word8 -> Word8 -> Ptr Word8 -> IO Text
    write2bytes !Int
    out !Word8
    b1 !Word8
    b2 !Ptr Word8
    inp = do
              MutablePrimArray (PrimState IO) Word8 -> Int -> Word8 -> IO ()
    forall a (m :: * -> *).
    (Prim a, PrimMonad m) =>
    MutablePrimArray (PrimState m) a -> Int -> a -> m ()
    P.writePrimArray MutablePrimArray RealWorld Word8
    MutablePrimArray (PrimState IO) Word8
    arr Int
    out Word8
    b1
              Int -> Word8 -> Ptr Word8 -> IO Text
    write1byte (Int
    out Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1) Word8
    b2 Ptr Word8
    inp

            write1byte :: Int -> Word8 -> Ptr Word8 -> IO Text
            write1byte :: Int -> Word8 -> Ptr Word8 -> IO Text
    write1byte !Int
    out !Word8
    b1 !Ptr Word8
    inp = do
              MutablePrimArray (PrimState IO) Word8 -> Int -> Word8 -> IO ()
    forall a (m :: * -> *).
    (Prim a, PrimMonad m) =>
    MutablePrimArray (PrimState m) a -> Int -> a -> m ()
    P.writePrimArray MutablePrimArray RealWorld Word8
    MutablePrimArray (PrimState IO) Word8
    arr Int
    out Word8
    b1
              Int -> Ptr Word8 -> IO Text
    state_start (Int
    out Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1) Ptr Word8
    inp

            writeCodePoint :: Int -> Ptr Word8 -> Word32 -> IO Text
            writeCodePoint :: Int -> Ptr Word8 -> Word32 -> IO Text
    writeCodePoint !Int
    out !Ptr Word8
    inp !Word32
    acc
              | Word32
    acc Word32 -> Word32 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word32
    127 = do
                MutablePrimArray (PrimState IO) Word8 -> Int -> Word8 -> IO ()
    forall a (m :: * -> *).
    (Prim a, PrimMonad m) =>
    MutablePrimArray (PrimState m) a -> Int -> a -> m ()
    P.writePrimArray MutablePrimArray RealWorld Word8
    MutablePrimArray (PrimState IO) Word8
    arr Int
    out (Word32 -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Word32
    acc :: Word8)
                Int -> Ptr Word8 -> IO Text
    state_start (Int
    out Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1) (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1)

              | Word32
    acc Word32 -> Word32 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word32
    2047 = do
                let b1 :: Word8
    b1 = Word32 -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word32 -> Int -> Word32
    forall a. Bits a => a -> Int -> a
    shiftR Word32
    acc Int
    6 Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .|. Word32
    192) :: Word8
                let b2 :: Word8
    b2 = Word32 -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral ((Word32
    acc Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .&. Word32
    63) Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .|. Word32
    128) :: Word8
                MutablePrimArray (PrimState IO) Word8 -> Int -> Word8 -> IO ()
    forall a (m :: * -> *).
    (Prim a, PrimMonad m) =>
    MutablePrimArray (PrimState m) a -> Int -> a -> m ()
    P.writePrimArray MutablePrimArray RealWorld Word8
    MutablePrimArray (PrimState IO) Word8
    arr Int
    out Word8
    b1
                Int -> Word8 -> Ptr Word8 -> IO Text
    write1byte (Int
    out Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1) Word8
    b2 (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1)

              | Word32
    acc Word32 -> Word32 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word32
    65535 = do
                let b1 :: Word8
    b1 = Word32 -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word32 -> Int -> Word32
    forall a. Bits a => a -> Int -> a
    shiftR Word32
    acc Int
    12 Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .|. Word32
    224) :: Word8
                let b2 :: Word8
    b2 = Word32 -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral ((Word32 -> Int -> Word32
    forall a. Bits a => a -> Int -> a
    shiftR Word32
    acc Int
    6 Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .&. Word32
    63) Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .|.  Word32
    128) :: Word8
                let b3 :: Word8
    b3 = Word32 -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral ((Word32
    acc Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .&. Word32
    63) Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .|. Word32
    128) :: Word8
                MutablePrimArray (PrimState IO) Word8 -> Int -> Word8 -> IO ()
    forall a (m :: * -> *).
    (Prim a, PrimMonad m) =>
    MutablePrimArray (PrimState m) a -> Int -> a -> m ()
    P.writePrimArray MutablePrimArray RealWorld Word8
    MutablePrimArray (PrimState IO) Word8
    arr Int
    out Word8
    b1
                Int -> Word8 -> Word8 -> Ptr Word8 -> IO Text
    write2bytes (Int
    out Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1) Word8
    b2 Word8
    b3 (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1)

              | Bool
    otherwise = do
                let b1 :: Word8
    b1 = Word32 -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word32 -> Int -> Word32
    forall a. Bits a => a -> Int -> a
    shiftR Word32
    acc Int
    18 Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .|. Word32
    240) :: Word8
                let b2 :: Word8
    b2 = Word32 -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral ((Word32 -> Int -> Word32
    forall a. Bits a => a -> Int -> a
    shiftR Word32
    acc Int
    12 Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .&. Word32
    63) Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .|. Word32
    128) :: Word8
                let b3 :: Word8
    b3 = Word32 -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral ((Word32 -> Int -> Word32
    forall a. Bits a => a -> Int -> a
    shiftR Word32
    acc Int
    6 Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .&. Word32
    63) Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .|. Word32
    128) :: Word8
                let b4 :: Word8
    b4 = Word32 -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral ((Word32
    acc Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .&. Word32
    63) Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .|. Word32
    128) :: Word8
                MutablePrimArray (PrimState IO) Word8 -> Int -> Word8 -> IO ()
    forall a (m :: * -> *).
    (Prim a, PrimMonad m) =>
    MutablePrimArray (PrimState m) a -> Int -> a -> m ()
    P.writePrimArray MutablePrimArray RealWorld Word8
    MutablePrimArray (PrimState IO) Word8
    arr Int
    out Word8
    b1
                Int -> Word8 -> Word8 -> Word8 -> Ptr Word8 -> IO Text
    write3bytes (Int
    out Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1) Word8
    b2 Word8
    b3 Word8
    b4 (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1)

            state_sudone :: Int -> Ptr Word8 -> Word32 -> Word32 -> IO Text
            state_sudone :: Int -> Ptr Word8 -> Word32 -> Word32 -> IO Text
    state_sudone !Int
    out !Ptr Word8
    inp !Word32
    hi !Word32
    lo
              | Word32
    56320 Word32 -> Word32 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word32
    lo, Word32
    lo Word32 -> Word32 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word32
    57343
              = Int -> Ptr Word8 -> Word32 -> IO Text
    writeCodePoint Int
    out Ptr Word8
    inp (Word32
    65536 Word32 -> Word32 -> Word32
    forall a. Num a => a -> a -> a
    + (Word32 -> Int -> Word32
    forall a. Bits a => a -> Int -> a
    shiftL (Word32
    hi Word32 -> Word32 -> Word32
    forall a. Num a => a -> a -> a
    - Word32
    55296) Int
    10 Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .|.  (Word32
    lo Word32 -> Word32 -> Word32
    forall a. Num a => a -> a -> a
    - Word32
    56320)))

              | Bool
    otherwise
              = IO Text
    forall a. IO a
    throwDecodeError

            state_su4 :: Int -> Ptr Word8 -> Word32 -> Word32 -> IO Text
            state_su4 :: Int -> Ptr Word8 -> Word32 -> Word32 -> IO Text
    state_su4 !Int
    out !Ptr Word8
    inp !Word32
    hi !Word32
    acc
              | Ptr Word8
    inp Ptr Word8 -> Ptr Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    == Ptr Word8
    end = IO Text
    forall a. IO a
    throwDecodeError
              | Bool
    otherwise = do
                Word8
    w8 <- Ptr Word8 -> IO Word8
    forall a. Storable a => Ptr a -> IO a
    peek Ptr Word8
    inp
                if | Word8
    48 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    w8, Word8
    w8 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    57 ->
                     Int -> Ptr Word8 -> Word32 -> Word32 -> IO Text
    state_sudone Int
    out Ptr Word8
    inp Word32
    hi (Word32 -> Int -> Word32
    forall a. Bits a => a -> Int -> a
    shiftL Word32
    acc Int
    4 Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .|. Word8 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word8
    w8 Word8 -> Word8 -> Word8
    forall a. Num a => a -> a -> a
    - Word8
    48))
                   | Word8
    65 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    w8, Word8
    w8 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    70 ->
                     Int -> Ptr Word8 -> Word32 -> Word32 -> IO Text
    state_sudone Int
    out Ptr Word8
    inp Word32
    hi (Word32 -> Int -> Word32
    forall a. Bits a => a -> Int -> a
    shiftL Word32
    acc Int
    4 Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .|. Word8 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word8
    w8 Word8 -> Word8 -> Word8
    forall a. Num a => a -> a -> a
    - Word8
    55))
                   | Word8
    97 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    w8, Word8
    w8 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    102 ->
                     Int -> Ptr Word8 -> Word32 -> Word32 -> IO Text
    state_sudone Int
    out Ptr Word8
    inp Word32
    hi (Word32 -> Int -> Word32
    forall a. Bits a => a -> Int -> a
    shiftL Word32
    acc Int
    4 Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .|. Word8 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word8
    w8 Word8 -> Word8 -> Word8
    forall a. Num a => a -> a -> a
    - Word8
    87))
                   | Bool
    otherwise ->
                     IO Text
    forall a. IO a
    throwDecodeError

            state_su3 :: Int -> Ptr Word8 -> Word32 -> Word32 -> IO Text
            state_su3 :: Int -> Ptr Word8 -> Word32 -> Word32 -> IO Text
    state_su3 !Int
    out !Ptr Word8
    inp !Word32
    hi !Word32
    acc
              | Ptr Word8
    inp Ptr Word8 -> Ptr Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    == Ptr Word8
    end = IO Text
    forall a. IO a
    throwDecodeError
              | Bool
    otherwise = do
                Word8
    w8 <- Ptr Word8 -> IO Word8
    forall a. Storable a => Ptr a -> IO a
    peek Ptr Word8
    inp
                if | Word8
    48 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    w8, Word8
    w8 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    57 ->
                     Int -> Ptr Word8 -> Word32 -> Word32 -> IO Text
    state_su4 Int
    out (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1) Word32
    hi (Word32 -> Int -> Word32
    forall a. Bits a => a -> Int -> a
    shiftL Word32
    acc Int
    4 Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .|. Word8 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word8
    w8 Word8 -> Word8 -> Word8
    forall a. Num a => a -> a -> a
    - Word8
    48))
                   | Word8
    65 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    w8, Word8
    w8 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    70 ->
                     Int -> Ptr Word8 -> Word32 -> Word32 -> IO Text
    state_su4 Int
    out (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1) Word32
    hi (Word32 -> Int -> Word32
    forall a. Bits a => a -> Int -> a
    shiftL Word32
    acc Int
    4 Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .|. Word8 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word8
    w8 Word8 -> Word8 -> Word8
    forall a. Num a => a -> a -> a
    - Word8
    55))
                   | Word8
    97 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    w8, Word8
    w8 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    102 ->
                     Int -> Ptr Word8 -> Word32 -> Word32 -> IO Text
    state_su4 Int
    out (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1) Word32
    hi (Word32 -> Int -> Word32
    forall a. Bits a => a -> Int -> a
    shiftL Word32
    acc Int
    4 Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .|. Word8 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word8
    w8 Word8 -> Word8 -> Word8
    forall a. Num a => a -> a -> a
    - Word8
    87))
                   | Bool
    otherwise ->
                     IO Text
    forall a. IO a
    throwDecodeError

            state_su2 :: Int -> Ptr Word8 -> Word32 -> Word32 -> IO Text
            state_su2 :: Int -> Ptr Word8 -> Word32 -> Word32 -> IO Text
    state_su2 !Int
    out !Ptr Word8
    inp !Word32
    hi !Word32
    acc
              | Ptr Word8
    inp Ptr Word8 -> Ptr Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    == Ptr Word8
    end = IO Text
    forall a. IO a
    throwDecodeError
              | Bool
    otherwise = do
                Word8
    w8 <- Ptr Word8 -> IO Word8
    forall a. Storable a => Ptr a -> IO a
    peek Ptr Word8
    inp
                if | Word8
    48 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    w8, Word8
    w8 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    57 ->
                     Int -> Ptr Word8 -> Word32 -> Word32 -> IO Text
    state_su3 Int
    out (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1) Word32
    hi (Word32 -> Int -> Word32
    forall a. Bits a => a -> Int -> a
    shiftL Word32
    acc Int
    4 Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .|. Word8 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word8
    w8 Word8 -> Word8 -> Word8
    forall a. Num a => a -> a -> a
    - Word8
    48))
                   | Word8
    65 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    w8, Word8
    w8 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    70 ->
                     Int -> Ptr Word8 -> Word32 -> Word32 -> IO Text
    state_su3 Int
    out (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1) Word32
    hi (Word32 -> Int -> Word32
    forall a. Bits a => a -> Int -> a
    shiftL Word32
    acc Int
    4 Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .|. Word8 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word8
    w8 Word8 -> Word8 -> Word8
    forall a. Num a => a -> a -> a
    - Word8
    55))
                   | Word8
    97 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    w8, Word8
    w8 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    102 ->
                     Int -> Ptr Word8 -> Word32 -> Word32 -> IO Text
    state_su3 Int
    out (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1) Word32
    hi (Word32 -> Int -> Word32
    forall a. Bits a => a -> Int -> a
    shiftL Word32
    acc Int
    4 Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .|. Word8 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word8
    w8 Word8 -> Word8 -> Word8
    forall a. Num a => a -> a -> a
    - Word8
    87))
                   | Bool
    otherwise ->
                     IO Text
    forall a. IO a
    throwDecodeError

            state_su1 :: Int -> Ptr Word8 -> Word32 -> IO Text
            state_su1 :: Int -> Ptr Word8 -> Word32 -> IO Text
    state_su1 !Int
    out !Ptr Word8
    inp !Word32
    hi
              | Ptr Word8
    inp Ptr Word8 -> Ptr Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    == Ptr Word8
    end = IO Text
    forall a. IO a
    throwDecodeError
              | Bool
    otherwise = do
                Word8
    w8 <- Ptr Word8 -> IO Word8
    forall a. Storable a => Ptr a -> IO a
    peek Ptr Word8
    inp
                if | Word8
    48 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    w8, Word8
    w8 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    57 ->
                     Int -> Ptr Word8 -> Word32 -> Word32 -> IO Text
    state_su2 Int
    out (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1) Word32
    hi (Word8 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word8
    w8 Word8 -> Word8 -> Word8
    forall a. Num a => a -> a -> a
    - Word8
    48))
                   | Word8
    65 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    w8, Word8
    w8 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    70 ->
                     Int -> Ptr Word8 -> Word32 -> Word32 -> IO Text
    state_su2 Int
    out (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1) Word32
    hi (Word8 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word8
    w8 Word8 -> Word8 -> Word8
    forall a. Num a => a -> a -> a
    - Word8
    55))
                   | Word8
    97 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    w8, Word8
    w8 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    102 ->
                     Int -> Ptr Word8 -> Word32 -> Word32 -> IO Text
    state_su2 Int
    out (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1) Word32
    hi (Word8 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word8
    w8 Word8 -> Word8 -> Word8
    forall a. Num a => a -> a -> a
    - Word8
    87))
                   | Bool
    otherwise ->
                     IO Text
    forall a. IO a
    throwDecodeError

            state_su :: Int -> Ptr Word8 -> Word32 -> IO Text
            state_su :: Int -> Ptr Word8 -> Word32 -> IO Text
    state_su !Int
    out !Ptr Word8
    inp !Word32
    hi
              | Ptr Word8
    inp Ptr Word8 -> Ptr Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    == Ptr Word8
    end = IO Text
    forall a. IO a
    throwDecodeError
              | Bool
    otherwise = do
                Word8
    w8 <- Ptr Word8 -> IO Word8
    forall a. Storable a => Ptr a -> IO a
    peek Ptr Word8
    inp
                case Word8
    w8 of
                  Word8
    117 -> Int -> Ptr Word8 -> Word32 -> IO Text
    state_su1 Int
    out (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1) Word32
    hi
                  Word8
    _   -> IO Text
    forall a. IO a
    throwDecodeError

            state_ss :: Int -> Ptr Word8 -> Word32 -> IO Text
            state_ss :: Int -> Ptr Word8 -> Word32 -> IO Text
    state_ss !Int
    out !Ptr Word8
    inp !Word32
    hi
              | Ptr Word8
    inp Ptr Word8 -> Ptr Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    == Ptr Word8
    end = IO Text
    forall a. IO a
    throwDecodeError
              | Bool
    otherwise = do
                Word8
    w8 <- Ptr Word8 -> IO Word8
    forall a. Storable a => Ptr a -> IO a
    peek Ptr Word8
    inp
                case Word8
    w8 of
                  Word8
    92 -> Int -> Ptr Word8 -> Word32 -> IO Text
    state_su Int
    out (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1) Word32
    hi
                  Word8
    _  -> IO Text
    forall a. IO a
    throwDecodeError

            state_udone :: Int -> Ptr Word8 -> Word32 -> IO Text
            state_udone :: Int -> Ptr Word8 -> Word32 -> IO Text
    state_udone !Int
    out !Ptr Word8
    inp !Word32
    acc
              | Word32
    acc Word32 -> Word32 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word32
    55296 Bool -> Bool -> Bool
    || Word32
    acc Word32 -> Word32 -> Bool
    forall a. Ord a => a -> a -> Bool
    > Word32
    57343 =
                Int -> Ptr Word8 -> Word32 -> IO Text
    writeCodePoint Int
    out Ptr Word8
    inp Word32
    acc

              | Word32
    acc Word32 -> Word32 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word32
    56320 =
                Int -> Ptr Word8 -> Word32 -> IO Text
    state_ss Int
    out (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1) Word32
    acc

              | Bool
    otherwise =
                IO Text
    forall a. IO a
    throwDecodeError

            state_u4 :: Int -> Ptr Word8 -> Word32 -> IO Text
            state_u4 :: Int -> Ptr Word8 -> Word32 -> IO Text
    state_u4 !Int
    out !Ptr Word8
    inp !Word32
    acc
              | Ptr Word8
    inp Ptr Word8 -> Ptr Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    == Ptr Word8
    end = IO Text
    forall a. IO a
    throwDecodeError
              | Bool
    otherwise = do
                Word8
    w8 <- Ptr Word8 -> IO Word8
    forall a. Storable a => Ptr a -> IO a
    peek Ptr Word8
    inp
                if | Word8
    48 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    w8, Word8
    w8 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    57 ->
                     Int -> Ptr Word8 -> Word32 -> IO Text
    state_udone Int
    out Ptr Word8
    inp (Word32 -> Int -> Word32
    forall a. Bits a => a -> Int -> a
    shiftL Word32
    acc Int
    4 Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .|. Word8 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word8
    w8 Word8 -> Word8 -> Word8
    forall a. Num a => a -> a -> a
    - Word8
    48))
                   | Word8
    65 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    w8, Word8
    w8 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    70 ->
                     Int -> Ptr Word8 -> Word32 -> IO Text
    state_udone Int
    out Ptr Word8
    inp (Word32 -> Int -> Word32
    forall a. Bits a => a -> Int -> a
    shiftL Word32
    acc Int
    4 Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .|. Word8 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word8
    w8 Word8 -> Word8 -> Word8
    forall a. Num a => a -> a -> a
    - Word8
    55))
                   | Word8
    97 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    w8, Word8
    w8 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    102 ->
                     Int -> Ptr Word8 -> Word32 -> IO Text
    state_udone Int
    out Ptr Word8
    inp (Word32 -> Int -> Word32
    forall a. Bits a => a -> Int -> a
    shiftL Word32
    acc Int
    4 Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .|. Word8 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word8
    w8 Word8 -> Word8 -> Word8
    forall a. Num a => a -> a -> a
    - Word8
    87))
                   | Bool
    otherwise ->
                     IO Text
    forall a. IO a
    throwDecodeError

            state_u3 :: Int -> Ptr Word8 -> Word32 -> IO Text
            state_u3 :: Int -> Ptr Word8 -> Word32 -> IO Text
    state_u3 !Int
    out !Ptr Word8
    inp !Word32
    acc
              | Ptr Word8
    inp Ptr Word8 -> Ptr Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    == Ptr Word8
    end = IO Text
    forall a. IO a
    throwDecodeError
              | Bool
    otherwise = do
                Word8
    w8 <- Ptr Word8 -> IO Word8
    forall a. Storable a => Ptr a -> IO a
    peek Ptr Word8
    inp
                if | Word8
    48 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    w8, Word8
    w8 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    57 ->
                     Int -> Ptr Word8 -> Word32 -> IO Text
    state_u4 Int
    out (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1) (Word32 -> Int -> Word32
    forall a. Bits a => a -> Int -> a
    shiftL Word32
    acc Int
    4 Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .|. Word8 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word8
    w8 Word8 -> Word8 -> Word8
    forall a. Num a => a -> a -> a
    - Word8
    48))
                   | Word8
    65 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    w8, Word8
    w8 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    70 ->
                     Int -> Ptr Word8 -> Word32 -> IO Text
    state_u4 Int
    out (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1) (Word32 -> Int -> Word32
    forall a. Bits a => a -> Int -> a
    shiftL Word32
    acc Int
    4 Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .|. Word8 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word8
    w8 Word8 -> Word8 -> Word8
    forall a. Num a => a -> a -> a
    - Word8
    55))
                   | Word8
    97 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    w8, Word8
    w8 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    102 ->
                     Int -> Ptr Word8 -> Word32 -> IO Text
    state_u4 Int
    out (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1) (Word32 -> Int -> Word32
    forall a. Bits a => a -> Int -> a
    shiftL Word32
    acc Int
    4 Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .|. Word8 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word8
    w8 Word8 -> Word8 -> Word8
    forall a. Num a => a -> a -> a
    - Word8
    87))
                   | Bool
    otherwise ->
                     IO Text
    forall a. IO a
    throwDecodeError

            state_u2 :: Int -> Ptr Word8 -> Word32 -> IO Text
            state_u2 :: Int -> Ptr Word8 -> Word32 -> IO Text
    state_u2 !Int
    out !Ptr Word8
    inp !Word32
    acc
              | Ptr Word8
    inp Ptr Word8 -> Ptr Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    == Ptr Word8
    end = IO Text
    forall a. IO a
    throwDecodeError
              | Bool
    otherwise = do
                Word8
    w8 <- Ptr Word8 -> IO Word8
    forall a. Storable a => Ptr a -> IO a
    peek Ptr Word8
    inp
                if | Word8
    48 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    w8, Word8
    w8 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    57 ->
                     Int -> Ptr Word8 -> Word32 -> IO Text
    state_u3 Int
    out (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1) (Word32 -> Int -> Word32
    forall a. Bits a => a -> Int -> a
    shiftL Word32
    acc Int
    4 Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .|. Word8 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word8
    w8 Word8 -> Word8 -> Word8
    forall a. Num a => a -> a -> a
    - Word8
    48))
                   | Word8
    65 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    w8, Word8
    w8 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    70 ->
                     Int -> Ptr Word8 -> Word32 -> IO Text
    state_u3 Int
    out (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1) (Word32 -> Int -> Word32
    forall a. Bits a => a -> Int -> a
    shiftL Word32
    acc Int
    4 Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .|. Word8 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word8
    w8 Word8 -> Word8 -> Word8
    forall a. Num a => a -> a -> a
    - Word8
    55))
                   | Word8
    97 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    w8, Word8
    w8 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    102 ->
                     Int -> Ptr Word8 -> Word32 -> IO Text
    state_u3 Int
    out (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1) (Word32 -> Int -> Word32
    forall a. Bits a => a -> Int -> a
    shiftL Word32
    acc Int
    4 Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .|. Word8 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word8
    w8 Word8 -> Word8 -> Word8
    forall a. Num a => a -> a -> a
    - Word8
    87))
                   | Bool
    otherwise ->
                     IO Text
    forall a. IO a
    throwDecodeError

            state_u1 :: Int -> Ptr Word8 -> IO Text
            state_u1 :: Int -> Ptr Word8 -> IO Text
    state_u1 !Int
    out !Ptr Word8
    inp
              | Ptr Word8
    inp Ptr Word8 -> Ptr Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    == Ptr Word8
    end = IO Text
    forall a. IO a
    throwDecodeError
              | Bool
    otherwise = do
                Word8
    w8 <- Ptr Word8 -> IO Word8
    forall a. Storable a => Ptr a -> IO a
    peek Ptr Word8
    inp
                if | Word8
    48 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    w8, Word8
    w8 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    57 ->
                     Int -> Ptr Word8 -> Word32 -> IO Text
    state_u2 Int
    out (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1) (Word8 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word8
    w8 Word8 -> Word8 -> Word8
    forall a. Num a => a -> a -> a
    - Word8
    48))
                   | Word8
    65 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    w8, Word8
    w8 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    70 ->
                     Int -> Ptr Word8 -> Word32 -> IO Text
    state_u2 Int
    out (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1) (Word8 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word8
    w8 Word8 -> Word8 -> Word8
    forall a. Num a => a -> a -> a
    - Word8
    55))
                   | Word8
    97 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    w8, Word8
    w8 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    102 ->
                     Int -> Ptr Word8 -> Word32 -> IO Text
    state_u2 Int
    out (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1) (Word8 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word8
    w8 Word8 -> Word8 -> Word8
    forall a. Num a => a -> a -> a
    - Word8
    87))
                   | Bool
    otherwise ->
                     IO Text
    forall a. IO a
    throwDecodeError

            state_escape :: Int -> Ptr Word8 -> IO Text
            state_escape :: Int -> Ptr Word8 -> IO Text
    state_escape !Int
    out !Ptr Word8
    inp
              | Ptr Word8
    inp Ptr Word8 -> Ptr Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    == Ptr Word8
    end = IO Text
    forall a. IO a
    throwDecodeError
              | Bool
    otherwise  = do
                Word8
    w8 <- Ptr Word8 -> IO Word8
    forall a. Storable a => Ptr a -> IO a
    peek Ptr Word8
    inp
                case Word8
    w8 of
                  Word8
    34 -> do
                    MutablePrimArray (PrimState IO) Word8 -> Int -> Word8 -> IO ()
    forall a (m :: * -> *).
    (Prim a, PrimMonad m) =>
    MutablePrimArray (PrimState m) a -> Int -> a -> m ()
    P.writePrimArray MutablePrimArray RealWorld Word8
    MutablePrimArray (PrimState IO) Word8
    arr Int
    out Word8
    34
                    Int -> Ptr Word8 -> IO Text
    state_start (Int
    out Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1) (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1)

                  Word8
    92 -> do
                    MutablePrimArray (PrimState IO) Word8 -> Int -> Word8 -> IO ()
    forall a (m :: * -> *).
    (Prim a, PrimMonad m) =>
    MutablePrimArray (PrimState m) a -> Int -> a -> m ()
    P.writePrimArray MutablePrimArray RealWorld Word8
    MutablePrimArray (PrimState IO) Word8
    arr Int
    out Word8
    92
                    Int -> Ptr Word8 -> IO Text
    state_start (Int
    out Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1) (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1)

                  Word8
    47 -> do
                    MutablePrimArray (PrimState IO) Word8 -> Int -> Word8 -> IO ()
    forall a (m :: * -> *).
    (Prim a, PrimMonad m) =>
    MutablePrimArray (PrimState m) a -> Int -> a -> m ()
    P.writePrimArray MutablePrimArray RealWorld Word8
    MutablePrimArray (PrimState IO) Word8
    arr Int
    out Word8
    47
                    Int -> Ptr Word8 -> IO Text
    state_start (Int
    out Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1) (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1)

                  Word8
    98 -> do
                    MutablePrimArray (PrimState IO) Word8 -> Int -> Word8 -> IO ()
    forall a (m :: * -> *).
    (Prim a, PrimMonad m) =>
    MutablePrimArray (PrimState m) a -> Int -> a -> m ()
    P.writePrimArray MutablePrimArray RealWorld Word8
    MutablePrimArray (PrimState IO) Word8
    arr Int
    out Word8
    8
                    Int -> Ptr Word8 -> IO Text
    state_start (Int
    out Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1) (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1)

                  Word8
    102 -> do
                    MutablePrimArray (PrimState IO) Word8 -> Int -> Word8 -> IO ()
    forall a (m :: * -> *).
    (Prim a, PrimMonad m) =>
    MutablePrimArray (PrimState m) a -> Int -> a -> m ()
    P.writePrimArray MutablePrimArray RealWorld Word8
    MutablePrimArray (PrimState IO) Word8
    arr Int
    out Word8
    12
                    Int -> Ptr Word8 -> IO Text
    state_start (Int
    out Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1) (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1)

                  Word8
    110 -> do
                    MutablePrimArray (PrimState IO) Word8 -> Int -> Word8 -> IO ()
    forall a (m :: * -> *).
    (Prim a, PrimMonad m) =>
    MutablePrimArray (PrimState m) a -> Int -> a -> m ()
    P.writePrimArray MutablePrimArray RealWorld Word8
    MutablePrimArray (PrimState IO) Word8
    arr Int
    out Word8
    10
                    Int -> Ptr Word8 -> IO Text
    state_start (Int
    out Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1) (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1)

                  Word8
    114 -> do
                    MutablePrimArray (PrimState IO) Word8 -> Int -> Word8 -> IO ()
    forall a (m :: * -> *).
    (Prim a, PrimMonad m) =>
    MutablePrimArray (PrimState m) a -> Int -> a -> m ()
    P.writePrimArray MutablePrimArray RealWorld Word8
    MutablePrimArray (PrimState IO) Word8
    arr Int
    out Word8
    13
                    Int -> Ptr Word8 -> IO Text
    state_start (Int
    out Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1) (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1)

                  Word8
    116 -> do
                    MutablePrimArray (PrimState IO) Word8 -> Int -> Word8 -> IO ()
    forall a (m :: * -> *).
    (Prim a, PrimMonad m) =>
    MutablePrimArray (PrimState m) a -> Int -> a -> m ()
    P.writePrimArray MutablePrimArray RealWorld Word8
    MutablePrimArray (PrimState IO) Word8
    arr Int
    out Word8
    9
                    Int -> Ptr Word8 -> IO Text
    state_start (Int
    out Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1) (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1)

                  Word8
    117 ->
                    Int -> Ptr Word8 -> IO Text
    state_u1 Int
    out (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1)

                  Word8
    _ -> IO Text
    forall a. IO a
    throwDecodeError

            state_input4c :: Int -> Ptr Word8 -> Word8 -> Word8 -> Word8 -> IO Text
            state_input4c :: Int -> Ptr Word8 -> Word8 -> Word8 -> Word8 -> IO Text
    state_input4c !Int
    out !Ptr Word8
    inp !Word8
    b1 !Word8
    b2 !Word8
    b3
              | Ptr Word8
    inp Ptr Word8 -> Ptr Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    == Ptr Word8
    end = IO Text
    forall a. IO a
    throwDecodeError
              | Bool
    otherwise  = do
                Word8
    w8 <- Ptr Word8 -> IO Word8
    forall a. Storable a => Ptr a -> IO a
    peek Ptr Word8
    inp
                if | (Word8
    w8 Word8 -> Word8 -> Word8
    forall a. Bits a => a -> a -> a
    .&. Word8
    192) Word8 -> Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    == Word8
    128
                   , let acc :: Word32
    acc    = Word32 -> Int -> Word32
    forall a. Bits a => a -> Int -> a
    shiftL (Word8 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word8
    b1 Word8 -> Word8 -> Word8
    forall a. Bits a => a -> a -> a
    .&. Word8
    7)) Int
    18
                   , let acc' :: Word32
    acc'   = Word32
    acc Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .|. Word32 -> Int -> Word32
    forall a. Bits a => a -> Int -> a
    shiftL (Word8 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word8
    b2 Word8 -> Word8 -> Word8
    forall a. Bits a => a -> a -> a
    .&. Word8
    63)) Int
    12
                   , let acc'' :: Word32
    acc''  = Word32
    acc' Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .|. Word32 -> Int -> Word32
    forall a. Bits a => a -> Int -> a
    shiftL (Word8 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word8
    b3 Word8 -> Word8 -> Word8
    forall a. Bits a => a -> a -> a
    .&. Word8
    63)) Int
    6
                   , let acc''' :: Word32
    acc''' = Word32
    acc'' Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .|. Word8 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word8
    w8 Word8 -> Word8 -> Word8
    forall a. Bits a => a -> a -> a
    .&. Word8
    63) :: Word32
                   , Word32
    acc''' Word32 -> Word32 -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Word32
    65536 Bool -> Bool -> Bool
    && Word32
    acc''' Word32 -> Word32 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word32
    1114112 -> do
                     MutablePrimArray (PrimState IO) Word8 -> Int -> Word8 -> IO ()
    forall a (m :: * -> *).
    (Prim a, PrimMonad m) =>
    MutablePrimArray (PrimState m) a -> Int -> a -> m ()
    P.writePrimArray MutablePrimArray RealWorld Word8
    MutablePrimArray (PrimState IO) Word8
    arr Int
    out Word8
    b1
                     Int -> Word8 -> Word8 -> Word8 -> Ptr Word8 -> IO Text
    write3bytes (Int
    out Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1) Word8
    b2 Word8
    b3 Word8
    w8 (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1)

                   | Bool
    otherwise ->
                     IO Text
    forall a. IO a
    throwDecodeError

            state_input4b :: Int -> Ptr Word8 -> Word8 -> Word8 -> IO Text
            state_input4b :: Int -> Ptr Word8 -> Word8 -> Word8 -> IO Text
    state_input4b !Int
    out !Ptr Word8
    inp !Word8
    b1 !Word8
    b2
              | Ptr Word8
    inp Ptr Word8 -> Ptr Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    == Ptr Word8
    end = IO Text
    forall a. IO a
    throwDecodeError
              | Bool
    otherwise  = do
                Word8
    w8 <- Ptr Word8 -> IO Word8
    forall a. Storable a => Ptr a -> IO a
    peek Ptr Word8
    inp
                if | (Word8
    w8 Word8 -> Word8 -> Word8
    forall a. Bits a => a -> a -> a
    .&. Word8
    192) Word8 -> Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    == Word8
    128 ->
                     Int -> Ptr Word8 -> Word8 -> Word8 -> Word8 -> IO Text
    state_input4c Int
    out (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1) Word8
    b1 Word8
    b2 Word8
    w8

                   | Bool
    otherwise ->
                     IO Text
    forall a. IO a
    throwDecodeError

            state_input4 :: Int -> Ptr Word8 -> Word8 -> IO Text
            state_input4 :: Int -> Ptr Word8 -> Word8 -> IO Text
    state_input4 !Int
    out !Ptr Word8
    inp !Word8
    b1
              | Ptr Word8
    inp Ptr Word8 -> Ptr Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    == Ptr Word8
    end = IO Text
    forall a. IO a
    throwDecodeError
              | Bool
    otherwise  = do
                Word8
    w8 <- Ptr Word8 -> IO Word8
    forall a. Storable a => Ptr a -> IO a
    peek Ptr Word8
    inp
                if | (Word8
    w8 Word8 -> Word8 -> Word8
    forall a. Bits a => a -> a -> a
    .&. Word8
    192) Word8 -> Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    == Word8
    128 ->
                     Int -> Ptr Word8 -> Word8 -> Word8 -> IO Text
    state_input4b Int
    out (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1) Word8
    b1 Word8
    w8

                   | Bool
    otherwise ->
                     IO Text
    forall a. IO a
    throwDecodeError

            state_input3b :: Int -> Ptr Word8 -> Word8 -> Word8 -> IO Text
            state_input3b :: Int -> Ptr Word8 -> Word8 -> Word8 -> IO Text
    state_input3b !Int
    out !Ptr Word8
    inp !Word8
    b1 !Word8
    b2
              | Ptr Word8
    inp Ptr Word8 -> Ptr Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    == Ptr Word8
    end = IO Text
    forall a. IO a
    throwDecodeError
              | Bool
    otherwise  = do
                Word8
    w8 <- Ptr Word8 -> IO Word8
    forall a. Storable a => Ptr a -> IO a
    peek Ptr Word8
    inp
                if | (Word8
    w8 Word8 -> Word8 -> Word8
    forall a. Bits a => a -> a -> a
    .&. Word8
    192) Word8 -> Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    == Word8
    128
                   , let acc :: Word32
    acc   = Word32 -> Int -> Word32
    forall a. Bits a => a -> Int -> a
    shiftL (Word8 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word8
    b1 Word8 -> Word8 -> Word8
    forall a. Bits a => a -> a -> a
    .&. Word8
    15)) Int
    12
                   , let acc' :: Word32
    acc'  = Word32
    acc Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .|.  Word32 -> Int -> Word32
    forall a. Bits a => a -> Int -> a
    shiftL (Word8 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word8
    b2 Word8 -> Word8 -> Word8
    forall a. Bits a => a -> a -> a
    .&. Word8
    63)) Int
    6
                   , let acc'' :: Word32
    acc'' = Word32
    acc' Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .|. Word8 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word8
    w8 Word8 -> Word8 -> Word8
    forall a. Bits a => a -> a -> a
    .&. Word8
    63) :: Word32
                   , (Word32
    acc'' Word32 -> Word32 -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Word32
    2048 Bool -> Bool -> Bool
    && Word32
    acc'' Word32 -> Word32 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word32
    55296) Bool -> Bool -> Bool
    || Word32
    acc'' Word32 -> Word32 -> Bool
    forall a. Ord a => a -> a -> Bool
    > Word32
    57343 -> do
                     MutablePrimArray (PrimState IO) Word8 -> Int -> Word8 -> IO ()
    forall a (m :: * -> *).
    (Prim a, PrimMonad m) =>
    MutablePrimArray (PrimState m) a -> Int -> a -> m ()
    P.writePrimArray MutablePrimArray RealWorld Word8
    MutablePrimArray (PrimState IO) Word8
    arr Int
    out Word8
    b1
                     Int -> Word8 -> Word8 -> Ptr Word8 -> IO Text
    write2bytes (Int
    out Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1) Word8
    b2 Word8
    w8 (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1)

                   | Bool
    otherwise ->
                     IO Text
    forall a. IO a
    throwDecodeError

            state_input3 :: Int -> Ptr Word8 -> Word8 -> IO Text
            state_input3 :: Int -> Ptr Word8 -> Word8 -> IO Text
    state_input3 !Int
    out !Ptr Word8
    inp !Word8
    b1
              | Ptr Word8
    inp Ptr Word8 -> Ptr Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    == Ptr Word8
    end = IO Text
    forall a. IO a
    throwDecodeError
              | Bool
    otherwise  = do
                Word8
    w8 <- Ptr Word8 -> IO Word8
    forall a. Storable a => Ptr a -> IO a
    peek Ptr Word8
    inp
                if | (Word8
    w8 Word8 -> Word8 -> Word8
    forall a. Bits a => a -> a -> a
    .&. Word8
    192) Word8 -> Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    == Word8
    128 ->
                     Int -> Ptr Word8 -> Word8 -> Word8 -> IO Text
    state_input3b Int
    out (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1) Word8
    b1 Word8
    w8

                   | Bool
    otherwise ->
                     IO Text
    forall a. IO a
    throwDecodeError

            state_input2 :: Int -> Ptr Word8 -> Word8 -> IO Text
            state_input2 :: Int -> Ptr Word8 -> Word8 -> IO Text
    state_input2 !Int
    out !Ptr Word8
    inp !Word8
    b1
              | Ptr Word8
    inp Ptr Word8 -> Ptr Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    == Ptr Word8
    end = IO Text
    forall a. IO a
    throwDecodeError
              | Bool
    otherwise  = do
                Word8
    w8 <- Ptr Word8 -> IO Word8
    forall a. Storable a => Ptr a -> IO a
    peek Ptr Word8
    inp
                if | (Word8
    w8 Word8 -> Word8 -> Word8
    forall a. Bits a => a -> a -> a
    .&. Word8
    192) Word8 -> Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    == Word8
    128,
                     let acc :: Word32
    acc = Word32 -> Int -> Word32
    forall a. Bits a => a -> Int -> a
    shiftL (Word8 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word8
    b1 Word8 -> Word8 -> Word8
    forall a. Bits a => a -> a -> a
    .&. Word8
    63)) Int
    6 :: Word32
                         acc' :: Word32
    acc' = Word32
    acc Word32 -> Word32 -> Word32
    forall a. Bits a => a -> a -> a
    .|. Word8 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word8
    w8 Word8 -> Word8 -> Word8
    forall a. Bits a => a -> a -> a
    .&. Word8
    63) :: Word32
                   , Word32
    acc' Word32 -> Word32 -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Word32
    128 -> do
                     MutablePrimArray (PrimState IO) Word8 -> Int -> Word8 -> IO ()
    forall a (m :: * -> *).
    (Prim a, PrimMonad m) =>
    MutablePrimArray (PrimState m) a -> Int -> a -> m ()
    P.writePrimArray MutablePrimArray RealWorld Word8
    MutablePrimArray (PrimState IO) Word8
    arr Int
    out Word8
    b1
                     Int -> Word8 -> Ptr Word8 -> IO Text
    write1byte (Int
    out Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1) Word8
    w8 (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1)

                   | Bool
    otherwise ->
                     IO Text
    forall a. IO a
    throwDecodeError

            state_start :: Int -> Ptr Word8 -> IO Text
            state_start :: Int -> Ptr Word8 -> IO Text
    state_start !Int
    out !Ptr Word8
    inp
              | Ptr Word8
    inp Ptr Word8 -> Ptr Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    == Ptr Word8
    end = do
                MutablePrimArray (PrimState IO) Word8 -> Int -> IO ()
    forall (m :: * -> *) a.
    (PrimMonad m, Prim a) =>
    MutablePrimArray (PrimState m) a -> Int -> m ()
    P.shrinkMutablePrimArray MutablePrimArray RealWorld Word8
    MutablePrimArray (PrimState IO) Word8
    arr Int
    out
                PrimArray Word8
    frozenArr <- MutablePrimArray (PrimState IO) Word8 -> IO (PrimArray Word8)
    forall (m :: * -> *) a.
    PrimMonad m =>
    MutablePrimArray (PrimState m) a -> m (PrimArray a)
    P.unsafeFreezePrimArray MutablePrimArray RealWorld Word8
    MutablePrimArray (PrimState IO) Word8
    arr
                Text -> IO Text
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Text -> IO Text) -> Text -> IO Text
    forall a b. (a -> b) -> a -> b
    $ case PrimArray Word8
    frozenArr of
                  P.PrimArray ByteArray#
    ba -> Array -> Int -> Int -> Text
    T.Text (ByteArray# -> Array
    T.ByteArray ByteArray#
    ba) Int
    0 Int
    out

              | Bool
    otherwise = do
                Word8
    w8 <- Ptr Word8 -> IO Word8
    forall a. Storable a => Ptr a -> IO a
    peek Ptr Word8
    inp
                if | Word8
    w8 Word8 -> Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    == Word8
    92 -> Int -> Ptr Word8 -> IO Text
    state_escape Int
    out (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1)
                   | Word8
    w8 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    128 -> do
                     MutablePrimArray (PrimState IO) Word8 -> Int -> Word8 -> IO ()
    forall a (m :: * -> *).
    (Prim a, PrimMonad m) =>
    MutablePrimArray (PrimState m) a -> Int -> a -> m ()
    P.writePrimArray MutablePrimArray RealWorld Word8
    MutablePrimArray (PrimState IO) Word8
    arr Int
    out Word8
    w8
                     Int -> Ptr Word8 -> IO Text
    state_start (Int
    out Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1) (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1)

                   | Word8
    w8 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    192 -> IO Text
    forall a. IO a
    throwDecodeError
                   | Word8
    w8 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    224 -> Int -> Ptr Word8 -> Word8 -> IO Text
    state_input2 Int
    out (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1) Word8
    w8
                   | Word8
    w8 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    240 -> Int -> Ptr Word8 -> Word8 -> IO Text
    state_input3 Int
    out (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1) Word8
    w8
                   | Word8
    w8 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    248 -> Int -> Ptr Word8 -> Word8 -> IO Text
    state_input4 Int
    out (Ptr Word8 -> Int -> Ptr Word8
    forall a b. Ptr a -> Int -> Ptr b
    plusPtr Ptr Word8
    inp Int
    1) Word8
    w8

                   | Bool
    otherwise -> IO Text
    forall a. IO a
    throwDecodeError

        -- start the state machine
        Int -> Ptr Word8 -> IO Text
    state_start (Int
    0 :: Int) Ptr Word8
    begin
    #else

    unescapeTextIO bs = withBS bs $ \fptr len ->
      withForeignPtr fptr $ \begin -> do
        let end :: Ptr Word8
            end = plusPtr begin len

        arr <- P.newPrimArray len

        let writeLowSurrogate :: Int -> Word16 -> Ptr Word8 -> IO Text
            writeLowSurrogate !out !w16 !inp = do
              P.writePrimArray arr out w16
              state_start (out + 1) inp

            state_sudone :: Int -> Ptr Word8 -> Word32 -> IO Text
            state_sudone !out !inp !lo
              | 56320 <= lo, lo <= 57343 = do
                P.writePrimArray arr out (fromIntegral lo)
                state_start (out + 1) (plusPtr inp 1)

              | otherwise =
                throwDecodeError

            state_su4 :: Int -> Ptr Word8 -> Word32 -> IO Text
            state_su4 !out !inp !acc
              | inp == end = throwDecodeError
              | otherwise = do
                w8 <- peek inp
                if | 48 <= w8, w8 <= 57 ->
                     state_sudone out inp (shiftL acc 4 .|. fromIntegral (w8 - 48))
                   | 65 <= w8, w8 <= 70 ->
                     state_sudone out inp (shiftL acc 4 .|. fromIntegral (w8 - 55))
                   | 97 <= w8, w8 <= 102 ->
                     state_sudone out inp (shiftL acc 4 .|. fromIntegral (w8 - 87))
                   | otherwise ->
                     throwDecodeError

            state_su3 :: Int -> Ptr Word8 -> Word32 -> IO Text
            state_su3 !out !inp  !acc
              | inp == end = throwDecodeError
              | otherwise = do
                w8 <- peek inp
                if | 48 <= w8, w8 <= 57 ->
                     state_su4 out (plusPtr inp 1) (shiftL acc 4 .|. fromIntegral (w8 - 48))
                   | 65 <= w8, w8 <= 70 ->
                     state_su4 out (plusPtr inp 1) (shiftL acc 4 .|. fromIntegral (w8 - 55))
                   | 97 <= w8, w8 <= 102 ->
                     state_su4 out (plusPtr inp 1) (shiftL acc 4 .|. fromIntegral (w8 - 87))
                   | otherwise -> throwDecodeError

            state_su2 :: Int -> Ptr Word8 -> Word32 -> IO Text
            state_su2 !out !inp !acc
              | inp == end = throwDecodeError
              | otherwise = do
                w8 <- peek inp
                if | 48 <= w8, w8 <= 57 ->
                     state_su3 out (plusPtr inp 1) (shiftL acc 4 .|. fromIntegral (w8 - 48))
                   | 65 <= w8, w8 <= 70 ->
                     state_su3 out (plusPtr inp 1) (shiftL acc 4 .|. fromIntegral (w8 - 55))
                   | 97 <= w8, w8 <= 102 ->
                     state_su3 out (plusPtr inp 1) (shiftL acc 4 .|. fromIntegral (w8 - 87))
                   | otherwise ->
                     throwDecodeError

            state_su1 :: Int -> Ptr Word8 -> IO Text
            state_su1 !out !inp
              | inp == end = throwDecodeError
              | otherwise = do
                w8 <- peek inp
                if | 48 <= w8, w8 <= 57 ->
                     state_su2 out (plusPtr inp 1) (fromIntegral (w8 - 48))
                   | 65 <= w8, w8 <= 70 ->
                     state_su2 out (plusPtr inp 1) (fromIntegral (w8 - 55))
                   | 97 <= w8, w8 <= 102 ->
                     state_su2 out (plusPtr inp 1) (fromIntegral (w8 - 87))
                   | otherwise ->
                     throwDecodeError

            -- high surrogate u
            state_su :: Int -> Ptr Word8 -> IO Text
            state_su !out !inp
              | inp == end = throwDecodeError
              | otherwise = do
                w8 <- peek inp
                case w8 of
                  117 -> state_su1 out (plusPtr inp 1)
                  _   -> throwDecodeError

            -- high surrogate slash
            state_ss :: Int -> Ptr Word8 -> IO Text
            state_ss !out !inp
              | inp == end = throwDecodeError
              | otherwise = do
                w8 <- peek inp
                case w8 of
                  92 -> state_su out (plusPtr inp 1)
                  _  -> throwDecodeError

            state_udone :: Int -> Ptr Word8 -> Word32 -> IO Text
            state_udone !out !inp !acc
              -- we know that codepoint in acc is in BMP
              | acc < 55296 || acc > 57343 = do
                P.writePrimArray arr out (fromIntegral acc)
                state_start (out + 1) (plusPtr inp 1)

              -- hi surrogate,
              -- we write it immediately (UTF16 as an output!)
              | acc < 56320 = do
                P.writePrimArray arr out (fromIntegral acc)
                state_ss (out + 1) (plusPtr inp 1)

              | otherwise =
                throwDecodeError

            state_u4 :: Int -> Ptr Word8 -> Word32 -> IO Text
            state_u4 !out !inp !acc
              | inp == end = throwDecodeError
              | otherwise = do
                w8 <- peek inp
                if | 48 <= w8, w8 <= 57 ->
                     state_udone out inp (shiftL acc 4 .|. fromIntegral (w8 - 48))
                   | 65 <= w8, w8 <= 70 ->
                     state_udone out inp (shiftL acc 4 .|. fromIntegral (w8 - 55))
                   | 97 <= w8, w8 <= 102 ->
                     state_udone out inp (shiftL acc 4 .|. fromIntegral (w8 - 87))
                   | otherwise ->
                     throwDecodeError

            state_u3 :: Int -> Ptr Word8 -> Word32 -> IO Text
            state_u3 !out !inp !acc
              | inp == end = throwDecodeError
              | otherwise = do
                w8 <- peek inp
                if | 48 <= w8, w8 <= 57 ->
                     state_u4 out (plusPtr inp 1) (shiftL acc 4 .|. fromIntegral (w8 - 48))
                   | 65 <= w8, w8 <= 70 ->
                     state_u4 out (plusPtr inp 1) (shiftL acc 4 .|. fromIntegral (w8 - 55))
                   | 97 <= w8, w8 <= 102 ->
                     state_u4 out (plusPtr inp 1) (shiftL acc 4 .|. fromIntegral (w8 - 87))
                   | otherwise ->
                     throwDecodeError

            state_u2 :: Int -> Ptr Word8 -> Word32 -> IO Text
            state_u2 !out !inp !acc
              | inp == end = throwDecodeError
              | otherwise = do
                w8 <- peek inp
                if | 48 <= w8, w8 <= 57 ->
                     state_u3 out (plusPtr inp 1) (shiftL acc 4 .|. fromIntegral (w8 - 48))
                   | 65 <= w8, w8 <= 70 ->
                     state_u3 out (plusPtr inp 1) (shiftL acc 4 .|. fromIntegral (w8 - 55))
                   | 97 <= w8, w8 <= 102 ->
                     state_u3 out (plusPtr inp 1) (shiftL acc 4 .|. fromIntegral (w8 - 87))
                   | otherwise ->
                     throwDecodeError

            state_u1 :: Int -> Ptr Word8 -> IO Text
            state_u1 !out !inp
              | inp == end = throwDecodeError
              | otherwise = do
                w8 <- peek inp
                if | 48 <= w8, w8 <= 57 ->
                     state_u2 out (plusPtr inp 1) (fromIntegral (w8 - 48))
                   | 65 <= w8, w8 <= 70 ->
                     state_u2 out (plusPtr inp 1) (fromIntegral (w8 - 55))
                   | 97 <= w8, w8 <= 102 ->
                     state_u2 out (plusPtr inp 1) (fromIntegral (w8 - 87))
                   | otherwise ->
                     throwDecodeError

            state_escape :: Int -> Ptr Word8 -> IO Text
            state_escape out inp
              | inp == end = throwDecodeError
              | otherwise = do
                w8 <- peek inp
                case w8 of
                  34 -> do
                    P.writePrimArray arr out 34
                    state_start (out + 1) (plusPtr inp 1)

                  92 -> do
                    P.writePrimArray arr out 92
                    state_start (out + 1) (plusPtr inp 1)

                  47 -> do
                    P.writePrimArray arr out 47
                    state_start (out + 1) (plusPtr inp 1)

                  98 -> do
                    P.writePrimArray arr out 8
                    state_start (out + 1) (plusPtr inp 1)

                  102 -> do
                    P.writePrimArray arr out 12
                    state_start (out + 1) (plusPtr inp 1)

                  110 -> do
                    P.writePrimArray arr out 10
                    state_start (out + 1) (plusPtr inp 1)

                  114 -> do
                    P.writePrimArray arr out 13
                    state_start (out + 1) (plusPtr inp 1)

                  116 -> do
                    P.writePrimArray arr out 9
                    state_start (out + 1) (plusPtr inp 1)

                  117 ->
                    state_u1 out (plusPtr inp 1)

                  _ -> throwDecodeError

            state_input4c :: Int -> Ptr Word8 -> Word32 -> IO Text
            state_input4c !out !inp !acc
              | inp == end = throwDecodeError
              | otherwise = do
                w8 <- peek inp
                if | (w8 .&. 0xc0) == 0x80
                   , let acc' = acc .|.  fromIntegral (w8 .&. 63)
                   , acc' >= 65536 && acc' < 1114112 ->
                     if {- -- | acc' < 65536 -> do
                           --   P.writePrimArray arr out (fromIntegral acc' :: Word16)
                           --   state_start (out + 1) (plusPtr inp 1) -}
                        | otherwise -> do
                          let u = acc' - 65536
                              hi = fromIntegral (55296 + shiftR u 10) :: Word16
                              lo = fromIntegral (56320 + (u .&. 1023)) :: Word16
                          P.writePrimArray arr out hi
                          writeLowSurrogate (out + 1) lo (plusPtr inp 1)

                   | otherwise -> throwDecodeError

            state_input4b :: Int -> Ptr Word8 -> Word32 -> IO Text
            state_input4b !out !inp !acc
              | inp == end = throwDecodeError
              | otherwise = do
                w8 <- peek inp
                if | (w8 .&. 0xc0) == 0x80 ->
                     state_input4c out (plusPtr inp 1) (acc .|. shiftL (fromIntegral (w8 .&. 63)) 6)

                   | otherwise -> throwDecodeError

            state_input4 :: Int -> Ptr Word8 -> Word32 -> IO Text
            state_input4 !out !inp !acc
              | inp == end = throwDecodeError
              | otherwise = do
                w8 <- peek inp
                if | (w8 .&. 0xc0) == 0x80 ->
                     state_input4b out (plusPtr inp 1) (acc .|. shiftL (fromIntegral (w8 .&. 63)) 12)

                   | otherwise -> throwDecodeError

            state_input3b :: Int -> Ptr Word8 -> Word32 -> IO Text
            state_input3b !out !inp !acc
              | inp == end = throwDecodeError
              | otherwise = do
                w8 <- peek inp
                if | (w8 .&. 0xc0) == 0x80
                   , let acc' = acc .|.  fromIntegral (w8 .&. 63)
                   , (acc' >= 2048 && acc' < 55296) || acc' > 57343 ->
                     if | acc' < 65536 -> do
                          P.writePrimArray arr out (fromIntegral acc')
                          state_start (out + 1) (plusPtr inp 1)

                        | otherwise -> do
                          let u = acc' - 65536
                              hi = fromIntegral (55296 + shiftR u 10) :: Word16
                              lo = fromIntegral (56320 + (u .&. 1023)) :: Word16
                          P.writePrimArray arr out hi
                          writeLowSurrogate (out + 1) lo (plusPtr inp 1)

                   | otherwise -> throwDecodeError

            state_input3 :: Int -> Ptr Word8 -> Word32 -> IO Text
            state_input3 !out !inp !acc
              | inp == end = throwDecodeError
              | otherwise = do
                w8 <- peek inp
                if | (w8 .&. 0xc0) == 0x80 ->
                     state_input3b out (plusPtr inp 1) (acc .|. shiftL (fromIntegral (w8 .&. 63)) 6)
                   | otherwise -> throwDecodeError

            state_input2 :: Int -> Ptr Word8 -> Word32 -> IO Text
            state_input2 !out !inp !acc
              | inp == end = throwDecodeError
              | otherwise = do
                w8 <- peek inp
                if | (w8 .&. 0xc0) == 0x80
                   , let acc' = acc .|. fromIntegral (w8 .&. 63)
                   , acc' >= 0x80 -> do
                     P.writePrimArray arr out (fromIntegral acc' :: Word16)
                     state_start (out + 1) (plusPtr inp 1)

                   | otherwise -> throwDecodeError

            state_start :: Int -> Ptr Word8 -> IO Text
            state_start !out !inp
              | inp == end = do
                P.shrinkMutablePrimArray arr out
                frozenArr <- P.unsafeFreezePrimArray arr
                return $ case frozenArr of
                  P.PrimArray ba -> T.Text (T.Array ba) 0 out

              | otherwise = do
                w8 <- peek inp
                if | w8 == 92 -> state_escape out (plusPtr inp 1)
                   | w8 < 0x80 -> do
                      P.writePrimArray arr out (fromIntegral w8 :: Word16)
                      state_start (out + 1) (plusPtr inp 1)

                   | w8 < 0xc0 -> throwDecodeError
                   | w8 < 224 -> state_input2 out (plusPtr inp 1) (shiftL (fromIntegral (w8 .&. 63)) 6)
                   | w8 < 240 -> state_input3 out (plusPtr inp 1) (shiftL (fromIntegral (w8 .&. 15)) 12)
                   | w8 < 248 -> state_input4 out (plusPtr inp 1) (shiftL (fromIntegral (w8 .&.  7)) 18)
                   | otherwise -> throwDecodeError

        -- start the state machine
        state_start (0 :: Int) begin

    #endif