    {-# LANGUAGE Trustworthy #-}
    {-# LANGUAGE NoImplicitPrelude
               , BangPatterns
               , NondecreasingIndentation
               , MagicHash
               , UnboxedTuples
      #-}
    {-# OPTIONS_GHC -funbox-strict-fields #-}

    -----------------------------------------------------------------------------
    -- |
    -- Module      :  GHC.Internal.IO.Encoding.UTF8
    -- Copyright   :  (c) The University of Glasgow, 2009
    -- License     :  see libraries/base/LICENSE
    --
    -- Maintainer  :  libraries@haskell.org
    -- Stability   :  internal
    -- Portability :  non-portable
    --
    -- UTF-8 Codec for the IO library
    --
    -- This is one of several UTF-8 implementations provided by GHC; see Note
    -- [GHC's many UTF-8 implementations] in "GHC.Encoding.UTF8" for an
    -- overview.
    --
    -- Portions Copyright   : (c) Tom Harper 2008-2009,
    --                        (c) Bryan O'Sullivan 2009,
    --                        (c) Duncan Coutts 2009
    --
    -----------------------------------------------------------------------------

    module GHC.Internal.IO.Encoding.UTF8 (
      utf8, mkUTF8,
      utf8_bom, mkUTF8_bom
      ) where

    import GHC.Internal.Base
    import GHC.Internal.Real
    import GHC.Internal.Num
    import GHC.Internal.IORef
    -- import GHC.Internal.IO
    import GHC.Internal.IO.Buffer
    import GHC.Internal.IO.Encoding.Failure
    import GHC.Internal.IO.Encoding.Types
    import GHC.Internal.Word
    import GHC.Internal.Data.Bits

    utf8 :: TextEncoding
    utf8 :: TextEncoding
    utf8 = CodingFailureMode -> TextEncoding
    mkUTF8 CodingFailureMode
    ErrorOnCodingFailure

    -- | @since base-4.4.0.0
    mkUTF8 :: CodingFailureMode -> TextEncoding
    mkUTF8 :: CodingFailureMode -> TextEncoding
    mkUTF8 CodingFailureMode
    cfm = TextEncoding { textEncodingName :: String
    textEncodingName = String
    "UTF-8",
                                mkTextDecoder :: IO (TextDecoder ())
    mkTextDecoder = CodingFailureMode -> IO (TextDecoder ())
    utf8_DF CodingFailureMode
    cfm,
                                mkTextEncoder :: IO (TextEncoder ())
    mkTextEncoder = CodingFailureMode -> IO (TextEncoder ())
    utf8_EF CodingFailureMode
    cfm }

    utf8_DF :: CodingFailureMode -> IO (TextDecoder ())
    utf8_DF :: CodingFailureMode -> IO (TextDecoder ())
    utf8_DF CodingFailureMode
    cfm =
      TextDecoder () -> IO (TextDecoder ())
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (BufferCodec# {
                 encode# :: CodeBuffer# Word8 Char
    encode#   = CodeBuffer# Word8 Char
    utf8_decode,
                 recover# :: Buffer Word8
    -> Buffer Char
    -> State# RealWorld
    -> (# State# RealWorld, Buffer Word8, Buffer Char #)
    recover#  = CodingFailureMode
    -> Buffer Word8
    -> Buffer Char
    -> State# RealWorld
    -> (# State# RealWorld, Buffer Word8, Buffer Char #)
    recoverDecode# CodingFailureMode
    cfm,
                 close# :: IO ()
    close#    = () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (),
                 getState# :: IO ()
    getState# = () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (),
                 setState# :: () -> IO ()
    setState# = IO () -> () -> IO ()
    forall a b. a -> b -> a
    const (IO () -> () -> IO ()) -> IO () -> () -> IO ()
    forall a b. (a -> b) -> a -> b
    $ () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()
              })

    utf8_EF :: CodingFailureMode -> IO (TextEncoder ())
    utf8_EF :: CodingFailureMode -> IO (TextEncoder ())
    utf8_EF CodingFailureMode
    cfm =
      TextEncoder () -> IO (TextEncoder ())
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (BufferCodec# {
                 encode# :: CodeBuffer# Char Word8
    encode#   = CodeBuffer# Char Word8
    utf8_encode,
                 recover# :: Buffer Char
    -> Buffer Word8
    -> State# RealWorld
    -> (# State# RealWorld, Buffer Char, Buffer Word8 #)
    recover#  = CodingFailureMode
    -> Buffer Char
    -> Buffer Word8
    -> State# RealWorld
    -> (# State# RealWorld, Buffer Char, Buffer Word8 #)
    recoverEncode# CodingFailureMode
    cfm,
                 close# :: IO ()
    close#    = () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (),
                 getState# :: IO ()
    getState# = () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (),
                 setState# :: () -> IO ()
    setState# = IO () -> () -> IO ()
    forall a b. a -> b -> a
    const (IO () -> () -> IO ()) -> IO () -> () -> IO ()
    forall a b. (a -> b) -> a -> b
    $ () -> IO ()
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()
              })

    utf8_bom :: TextEncoding
    utf8_bom :: TextEncoding
    utf8_bom = CodingFailureMode -> TextEncoding
    mkUTF8_bom CodingFailureMode
    ErrorOnCodingFailure

    mkUTF8_bom :: CodingFailureMode -> TextEncoding
    mkUTF8_bom :: CodingFailureMode -> TextEncoding
    mkUTF8_bom CodingFailureMode
    cfm = TextEncoding { textEncodingName :: String
    textEncodingName = String
    "UTF-8BOM",
                                    mkTextDecoder :: IO (TextDecoder Bool)
    mkTextDecoder = CodingFailureMode -> IO (TextDecoder Bool)
    utf8_bom_DF CodingFailureMode
    cfm,
                                    mkTextEncoder :: IO (TextEncoder Bool)
    mkTextEncoder = CodingFailureMode -> IO (TextEncoder Bool)
    utf8_bom_EF CodingFailureMode
    cfm }

    utf8_bom_DF :: CodingFailureMode -> IO (TextDecoder Bool)
    utf8_bom_DF :: CodingFailureMode -> IO (TextDecoder Bool)
    utf8_bom_DF CodingFailureMode
    cfm = do
       ref <- Bool -> IO (IORef Bool)
    forall a. a -> IO (IORef a)
    newIORef Bool
    True
       return (BufferCodec# {
                 encode#   = utf8_bom_decode ref,
                 recover#  = recoverDecode# cfm,
                 close#    = return (),
                 getState# = readIORef ref,
                 setState# = writeIORef ref
              })

    utf8_bom_EF :: CodingFailureMode -> IO (TextEncoder Bool)
    utf8_bom_EF :: CodingFailureMode -> IO (TextEncoder Bool)
    utf8_bom_EF CodingFailureMode
    cfm = do
       ref <- Bool -> IO (IORef Bool)
    forall a. a -> IO (IORef a)
    newIORef Bool
    True
       return (BufferCodec# {
                 encode#   = utf8_bom_encode ref,
                 recover#  = recoverEncode# cfm,
                 close#    = return (),
                 getState# = readIORef ref,
                 setState# = writeIORef ref
              })

    utf8_bom_decode :: IORef Bool -> DecodeBuffer#
    utf8_bom_decode :: IORef Bool -> CodeBuffer# Word8 Char
    utf8_bom_decode IORef Bool
    ref
      input :: Buffer Word8
    input@Buffer{  bufRaw :: forall e. Buffer e -> RawBuffer e
    bufRaw=RawBuffer Word8
    iraw, bufL :: forall e. Buffer e -> Int
    bufL=Int
    ir, bufR :: forall e. Buffer e -> Int
    bufR=Int
    iw,  bufSize :: forall e. Buffer e -> Int
    bufSize=Int
    _  }
      Buffer Char
    output
      State# RealWorld
    st0
     = do
       let !(# State# RealWorld
    st1, Bool
    first #) = IO Bool -> State# RealWorld -> (# State# RealWorld, Bool #)
    forall a. IO a -> State# RealWorld -> (# State# RealWorld, a #)
    unIO (IORef Bool -> IO Bool
    forall a. IORef a -> IO a
    readIORef IORef Bool
    ref) State# RealWorld
    st0
       if Bool -> Bool
    not Bool
    first
          then CodeBuffer# Word8 Char
    utf8_decode Buffer Word8
    input Buffer Char
    output State# RealWorld
    st1
          else do
           let no_bom :: (# State# RealWorld, CodingProgress, Buffer Word8, Buffer Char #)
    no_bom = let !(# State# RealWorld
    st', () #) = IO () -> State# RealWorld -> (# State# RealWorld, () #)
    forall a. IO a -> State# RealWorld -> (# State# RealWorld, a #)
    unIO (IORef Bool -> Bool -> IO ()
    forall a. IORef a -> a -> IO ()
    writeIORef IORef Bool
    ref Bool
    False) State# RealWorld
    st1 in CodeBuffer# Word8 Char
    utf8_decode Buffer Word8
    input Buffer Char
    output State# RealWorld
    st'
           if Int
    iw Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    ir Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    < Int
    1 then (# State# RealWorld
    st1,CodingProgress
    InputUnderflow,Buffer Word8
    input,Buffer Char
    output #) else do
           let !(# State# RealWorld
    st2, Word8
    c0 #) = IO Word8 -> State# RealWorld -> (# State# RealWorld, Word8 #)
    forall a. IO a -> State# RealWorld -> (# State# RealWorld, a #)
    unIO (RawBuffer Word8 -> Int -> IO Word8
    readWord8Buf RawBuffer Word8
    iraw Int
    ir) State# RealWorld
    st1
           if (Word8
    c0 Word8 -> Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    /= Word8
    bom0) then (# State# RealWorld, CodingProgress, Buffer Word8, Buffer Char #)
    no_bom else do
           if Int
    iw Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    ir Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    < Int
    2 then (# State# RealWorld
    st2,CodingProgress
    InputUnderflow,Buffer Word8
    input,Buffer Char
    output #) else do
           let !(# State# RealWorld
    st3, Word8
    c1 #) = IO Word8 -> State# RealWorld -> (# State# RealWorld, Word8 #)
    forall a. IO a -> State# RealWorld -> (# State# RealWorld, a #)
    unIO (RawBuffer Word8 -> Int -> IO Word8
    readWord8Buf RawBuffer Word8
    iraw (Int
    irInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    1)) State# RealWorld
    st2
           if (Word8
    c1 Word8 -> Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    /= Word8
    bom1) then (# State# RealWorld, CodingProgress, Buffer Word8, Buffer Char #)
    no_bom else do
           if Int
    iw Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    ir Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    < Int
    3 then (# State# RealWorld
    st3,CodingProgress
    InputUnderflow,Buffer Word8
    input,Buffer Char
    output #) else do
           let !(# State# RealWorld
    st4, Word8
    c2 #) = IO Word8 -> State# RealWorld -> (# State# RealWorld, Word8 #)
    forall a. IO a -> State# RealWorld -> (# State# RealWorld, a #)
    unIO (RawBuffer Word8 -> Int -> IO Word8
    readWord8Buf RawBuffer Word8
    iraw (Int
    irInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    2)) State# RealWorld
    st3
           if (Word8
    c2 Word8 -> Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    /= Word8
    bom2) then (# State# RealWorld, CodingProgress, Buffer Word8, Buffer Char #)
    no_bom else do
           -- found a BOM, ignore it and carry on
           let !(# State# RealWorld
    st5, () #) = IO () -> State# RealWorld -> (# State# RealWorld, () #)
    forall a. IO a -> State# RealWorld -> (# State# RealWorld, a #)
    unIO (IORef Bool -> Bool -> IO ()
    forall a. IORef a -> a -> IO ()
    writeIORef IORef Bool
    ref Bool
    False) State# RealWorld
    st4
           CodeBuffer# Word8 Char
    utf8_decode Buffer Word8
    input{ bufL = ir + 3 } Buffer Char
    output State# RealWorld
    st5

    utf8_bom_encode :: IORef Bool -> EncodeBuffer#
    utf8_bom_encode :: IORef Bool -> CodeBuffer# Char Word8
    utf8_bom_encode IORef Bool
    ref Buffer Char
    input
      output :: Buffer Word8
    output@Buffer{ bufRaw :: forall e. Buffer e -> RawBuffer e
    bufRaw=RawBuffer Word8
    oraw, bufL :: forall e. Buffer e -> Int
    bufL=Int
    _, bufR :: forall e. Buffer e -> Int
    bufR=Int
    ow, bufSize :: forall e. Buffer e -> Int
    bufSize=Int
    os }
      State# RealWorld
    st0
     = do
      let !(# State# RealWorld
    st1, Bool
    b #) = IO Bool -> State# RealWorld -> (# State# RealWorld, Bool #)
    forall a. IO a -> State# RealWorld -> (# State# RealWorld, a #)
    unIO (IORef Bool -> IO Bool
    forall a. IORef a -> IO a
    readIORef IORef Bool
    ref) State# RealWorld
    st0
      if Bool -> Bool
    not Bool
    b then CodeBuffer# Char Word8
    utf8_encode Buffer Char
    input Buffer Word8
    output State# RealWorld
    st1
               else if Int
    os Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    ow Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    < Int
    3
                      then (# State# RealWorld
    st1,CodingProgress
    OutputUnderflow,Buffer Char
    input,Buffer Word8
    output #)
                      else do
                        let !(# State# RealWorld
    st2, () #) = IO () -> State# RealWorld -> (# State# RealWorld, () #)
    forall a. IO a -> State# RealWorld -> (# State# RealWorld, a #)
    unIO (IORef Bool -> Bool -> IO ()
    forall a. IORef a -> a -> IO ()
    writeIORef IORef Bool
    ref Bool
    False)           State# RealWorld
    st1
                            !(# State# RealWorld
    st3, () #) = IO () -> State# RealWorld -> (# State# RealWorld, () #)
    forall a. IO a -> State# RealWorld -> (# State# RealWorld, a #)
    unIO (RawBuffer Word8 -> Int -> Word8 -> IO ()
    writeWord8Buf RawBuffer Word8
    oraw Int
    ow     Word8
    bom0) State# RealWorld
    st2
                            !(# State# RealWorld
    st4, () #) = IO () -> State# RealWorld -> (# State# RealWorld, () #)
    forall a. IO a -> State# RealWorld -> (# State# RealWorld, a #)
    unIO (RawBuffer Word8 -> Int -> Word8 -> IO ()
    writeWord8Buf RawBuffer Word8
    oraw (Int
    owInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    1) Word8
    bom1) State# RealWorld
    st3
                            !(# State# RealWorld
    st5, () #) = IO () -> State# RealWorld -> (# State# RealWorld, () #)
    forall a. IO a -> State# RealWorld -> (# State# RealWorld, a #)
    unIO (RawBuffer Word8 -> Int -> Word8 -> IO ()
    writeWord8Buf RawBuffer Word8
    oraw (Int
    owInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    2) Word8
    bom2) State# RealWorld
    st4
                        CodeBuffer# Char Word8
    utf8_encode Buffer Char
    input Buffer Word8
    output{ bufR = ow+3 } State# RealWorld
    st5

    bom0, bom1, bom2 :: Word8
    bom0 :: Word8
    bom0 = Word8
    0xef
    bom1 :: Word8
    bom1 = Word8
    0xbb
    bom2 :: Word8
    bom2 = Word8
    0xbf

    utf8_decode :: DecodeBuffer#
    utf8_decode :: CodeBuffer# Word8 Char
    utf8_decode
      input :: Buffer Word8
    input@Buffer{  bufRaw :: forall e. Buffer e -> RawBuffer e
    bufRaw=RawBuffer Word8
    iraw, bufL :: forall e. Buffer e -> Int
    bufL=Int
    ir0, bufR :: forall e. Buffer e -> Int
    bufR=Int
    iw,  bufSize :: forall e. Buffer e -> Int
    bufSize=Int
    _  }
      output :: Buffer Char
    output@Buffer{ bufRaw :: forall e. Buffer e -> RawBuffer e
    bufRaw=RawBuffer Char
    oraw, bufL :: forall e. Buffer e -> Int
    bufL=Int
    _,   bufR :: forall e. Buffer e -> Int
    bufR=Int
    ow0, bufSize :: forall e. Buffer e -> Int
    bufSize=Int
    os }
      State# RealWorld
    st
     = let
           loop :: Int -> Int -> DecodingBuffer#
           loop :: Int -> Int -> DecodingBuffer#
    loop !Int
    ir !Int
    ow State# RealWorld
    st0
             | Int
    ow Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Int
    os = CodingProgress -> Int -> Int -> DecodingBuffer#
    done CodingProgress
    OutputUnderflow Int
    ir Int
    ow State# RealWorld
    st0
             | Int
    ir Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Int
    iw = CodingProgress -> Int -> Int -> DecodingBuffer#
    done CodingProgress
    InputUnderflow Int
    ir Int
    ow State# RealWorld
    st0
             | Bool
    otherwise = do
                  let !(# State# RealWorld
    st1, Word8
    c0 #) = IO Word8 -> State# RealWorld -> (# State# RealWorld, Word8 #)
    forall a. IO a -> State# RealWorld -> (# State# RealWorld, a #)
    unIO (RawBuffer Word8 -> Int -> IO Word8
    readWord8Buf RawBuffer Word8
    iraw Int
    ir) State# RealWorld
    st0
                  case Word8
    c0 of
                    Word8
    _ | Word8
    c0 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    0x7f -> do
                               let !(# State# RealWorld
    st2, Int
    ow' #) = IO Int -> State# RealWorld -> (# State# RealWorld, Int #)
    forall a. IO a -> State# RealWorld -> (# State# RealWorld, a #)
    unIO (RawBuffer Char -> Int -> Char -> IO Int
    writeCharBuf RawBuffer Char
    oraw Int
    ow (Int -> Char
    unsafeChr (Word8 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Word8
    c0))) State# RealWorld
    st1
                               Int -> Int -> DecodingBuffer#
    loop (Int
    irInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    1) Int
    ow' State# RealWorld
    st2
                      | Word8
    c0 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Word8
    0xc0 Bool -> Bool -> Bool
    && Word8
    c0 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    0xc1 -> DecodingBuffer#
    invalid State# RealWorld
    st1 -- Overlong forms
                      | Word8
    c0 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Word8
    0xc2 Bool -> Bool -> Bool
    && Word8
    c0 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    0xdf ->
                               if Int
    iw Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    ir Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    < Int
    2 then CodingProgress -> Int -> Int -> DecodingBuffer#
    done CodingProgress
    InputUnderflow Int
    ir Int
    ow State# RealWorld
    st1 else do
                               let !(# State# RealWorld
    st2, Word8
    c1 #) = IO Word8 -> State# RealWorld -> (# State# RealWorld, Word8 #)
    forall a. IO a -> State# RealWorld -> (# State# RealWorld, a #)
    unIO (RawBuffer Word8 -> Int -> IO Word8
    readWord8Buf RawBuffer Word8
    iraw (Int
    irInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    1)) State# RealWorld
    st1
                               if (Word8
    c1 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    < Word8
    0x80 Bool -> Bool -> Bool
    || Word8
    c1 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Word8
    0xc0) then DecodingBuffer#
    invalid State# RealWorld
    st2 else do
                               let !(# State# RealWorld
    st3, Int
    ow' #) = IO Int -> State# RealWorld -> (# State# RealWorld, Int #)
    forall a. IO a -> State# RealWorld -> (# State# RealWorld, a #)
    unIO (RawBuffer Char -> Int -> Char -> IO Int
    writeCharBuf RawBuffer Char
    oraw Int
    ow (Word8 -> Word8 -> Char
    chr2 Word8
    c0 Word8
    c1)) State# RealWorld
    st2
                               Int -> Int -> DecodingBuffer#
    loop (Int
    irInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    2) Int
    ow' State# RealWorld
    st3
                      | Word8
    c0 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Word8
    0xe0 Bool -> Bool -> Bool
    && Word8
    c0 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    0xef ->
                          case Int
    iw Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    ir of
                            Int
    1 -> CodingProgress -> Int -> Int -> DecodingBuffer#
    done CodingProgress
    InputUnderflow Int
    ir Int
    ow State# RealWorld
    st1
                            Int
    2 -> do -- check for an error even when we don't have
                                    -- the full sequence yet (#3341)
                               let !(# State# RealWorld
    st2, Word8
    c1 #) = IO Word8 -> State# RealWorld -> (# State# RealWorld, Word8 #)
    forall a. IO a -> State# RealWorld -> (# State# RealWorld, a #)
    unIO (RawBuffer Word8 -> Int -> IO Word8
    readWord8Buf RawBuffer Word8
    iraw (Int
    irInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    1)) State# RealWorld
    st1
                               if Bool -> Bool
    not (Word8 -> Word8 -> Word8 -> Bool
    validate3 Word8
    c0 Word8
    c1 Word8
    0x80)
                                  then DecodingBuffer#
    invalid State# RealWorld
    st2 else CodingProgress -> Int -> Int -> DecodingBuffer#
    done CodingProgress
    InputUnderflow Int
    ir Int
    ow State# RealWorld
    st2
                            Int
    _ -> do
                               let !(# State# RealWorld
    st2, Word8
    c1 #) = IO Word8 -> State# RealWorld -> (# State# RealWorld, Word8 #)
    forall a. IO a -> State# RealWorld -> (# State# RealWorld, a #)
    unIO (RawBuffer Word8 -> Int -> IO Word8
    readWord8Buf RawBuffer Word8
    iraw (Int
    irInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    1)) State# RealWorld
    st1
                               let !(# State# RealWorld
    st3, Word8
    c2 #) = IO Word8 -> State# RealWorld -> (# State# RealWorld, Word8 #)
    forall a. IO a -> State# RealWorld -> (# State# RealWorld, a #)
    unIO (RawBuffer Word8 -> Int -> IO Word8
    readWord8Buf RawBuffer Word8
    iraw (Int
    irInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    2)) State# RealWorld
    st2
                               if Bool -> Bool
    not (Word8 -> Word8 -> Word8 -> Bool
    validate3 Word8
    c0 Word8
    c1 Word8
    c2) then DecodingBuffer#
    invalid State# RealWorld
    st3 else do
                               let !(# State# RealWorld
    st4, Int
    ow' #) = IO Int -> State# RealWorld -> (# State# RealWorld, Int #)
    forall a. IO a -> State# RealWorld -> (# State# RealWorld, a #)
    unIO (RawBuffer Char -> Int -> Char -> IO Int
    writeCharBuf RawBuffer Char
    oraw Int
    ow (Word8 -> Word8 -> Word8 -> Char
    chr3 Word8
    c0 Word8
    c1 Word8
    c2)) State# RealWorld
    st3
                               Int -> Int -> DecodingBuffer#
    loop (Int
    irInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    3) Int
    ow' State# RealWorld
    st4
                      | Word8
    c0 Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Word8
    0xf0 ->
                          case Int
    iw Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    ir of
                            Int
    1 -> CodingProgress -> Int -> Int -> DecodingBuffer#
    done CodingProgress
    InputUnderflow Int
    ir Int
    ow State# RealWorld
    st1
                            Int
    2 -> do -- check for an error even when we don't have
                                    -- the full sequence yet (#3341)
                               let !(# State# RealWorld
    st2, Word8
    c1 #) = IO Word8 -> State# RealWorld -> (# State# RealWorld, Word8 #)
    forall a. IO a -> State# RealWorld -> (# State# RealWorld, a #)
    unIO (RawBuffer Word8 -> Int -> IO Word8
    readWord8Buf RawBuffer Word8
    iraw (Int
    irInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    1)) State# RealWorld
    st1
                               if Bool -> Bool
    not (Word8 -> Word8 -> Word8 -> Word8 -> Bool
    validate4 Word8
    c0 Word8
    c1 Word8
    0x80 Word8
    0x80)
                                  then DecodingBuffer#
    invalid State# RealWorld
    st2 else CodingProgress -> Int -> Int -> DecodingBuffer#
    done CodingProgress
    InputUnderflow Int
    ir Int
    ow State# RealWorld
    st2
                            Int
    3 -> do
                               let !(# State# RealWorld
    st2, Word8
    c1 #) = IO Word8 -> State# RealWorld -> (# State# RealWorld, Word8 #)
    forall a. IO a -> State# RealWorld -> (# State# RealWorld, a #)
    unIO (RawBuffer Word8 -> Int -> IO Word8
    readWord8Buf RawBuffer Word8
    iraw (Int
    irInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    1)) State# RealWorld
    st1
                                   !(# State# RealWorld
    st3, Word8
    c2 #) = IO Word8 -> State# RealWorld -> (# State# RealWorld, Word8 #)
    forall a. IO a -> State# RealWorld -> (# State# RealWorld, a #)
    unIO (RawBuffer Word8 -> Int -> IO Word8
    readWord8Buf RawBuffer Word8
    iraw (Int
    irInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    2)) State# RealWorld
    st2
                               if Bool -> Bool
    not (Word8 -> Word8 -> Word8 -> Word8 -> Bool
    validate4 Word8
    c0 Word8
    c1 Word8
    c2 Word8
    0x80)
                                  then DecodingBuffer#
    invalid State# RealWorld
    st3 else CodingProgress -> Int -> Int -> DecodingBuffer#
    done CodingProgress
    InputUnderflow Int
    ir Int
    ow State# RealWorld
    st3
                            Int
    _ -> do
                               let !(# State# RealWorld
    st2, Word8
    c1 #) = IO Word8 -> State# RealWorld -> (# State# RealWorld, Word8 #)
    forall a. IO a -> State# RealWorld -> (# State# RealWorld, a #)
    unIO (RawBuffer Word8 -> Int -> IO Word8
    readWord8Buf RawBuffer Word8
    iraw (Int
    irInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    1)) State# RealWorld
    st1
                                   !(# State# RealWorld
    st3, Word8
    c2 #) = IO Word8 -> State# RealWorld -> (# State# RealWorld, Word8 #)
    forall a. IO a -> State# RealWorld -> (# State# RealWorld, a #)
    unIO (RawBuffer Word8 -> Int -> IO Word8
    readWord8Buf RawBuffer Word8
    iraw (Int
    irInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    2)) State# RealWorld
    st2
                                   !(# State# RealWorld
    st4, Word8
    c3 #) = IO Word8 -> State# RealWorld -> (# State# RealWorld, Word8 #)
    forall a. IO a -> State# RealWorld -> (# State# RealWorld, a #)
    unIO (RawBuffer Word8 -> Int -> IO Word8
    readWord8Buf RawBuffer Word8
    iraw (Int
    irInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    3)) State# RealWorld
    st3
                               if Bool -> Bool
    not (Word8 -> Word8 -> Word8 -> Word8 -> Bool
    validate4 Word8
    c0 Word8
    c1 Word8
    c2 Word8
    c3) then DecodingBuffer#
    invalid State# RealWorld
    st4 else do
                               let !(# State# RealWorld
    st5, Int
    ow' #) = IO Int -> State# RealWorld -> (# State# RealWorld, Int #)
    forall a. IO a -> State# RealWorld -> (# State# RealWorld, a #)
    unIO (RawBuffer Char -> Int -> Char -> IO Int
    writeCharBuf RawBuffer Char
    oraw Int
    ow (Word8 -> Word8 -> Word8 -> Word8 -> Char
    chr4 Word8
    c0 Word8
    c1 Word8
    c2 Word8
    c3)) State# RealWorld
    st4
                               Int -> Int -> DecodingBuffer#
    loop (Int
    irInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    4) Int
    ow' State# RealWorld
    st5
                      | Bool
    otherwise ->
                               DecodingBuffer#
    invalid State# RealWorld
    st1
             where
               invalid :: DecodingBuffer#
               invalid :: DecodingBuffer#
    invalid State# RealWorld
    st' = CodingProgress -> Int -> Int -> DecodingBuffer#
    done CodingProgress
    InvalidSequence Int
    ir Int
    ow State# RealWorld
    st'

           -- lambda-lifted, to avoid thunks being built in the inner-loop:
           {-# NOINLINE done #-}
           done :: CodingProgress -> Int -> Int -> DecodingBuffer#
           done :: CodingProgress -> Int -> Int -> DecodingBuffer#
    done CodingProgress
    why !Int
    ir !Int
    ow State# RealWorld
    st' =
             let !ri :: Buffer Word8
    ri = if Int
    ir Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    iw then Buffer Word8
    input{ bufL = 0, bufR = 0} else Buffer Word8
    input{ bufL = ir }
                 !ro :: Buffer Char
    ro = Buffer Char
    output { bufR = ow }
             in (# State# RealWorld
    st', CodingProgress
    why, Buffer Word8
    ri, Buffer Char
    ro #)
       in
       Int -> Int -> DecodingBuffer#
    loop Int
    ir0 Int
    ow0 State# RealWorld
    st

    utf8_encode :: EncodeBuffer#
    utf8_encode :: CodeBuffer# Char Word8
    utf8_encode
      input :: Buffer Char
    input@Buffer{  bufRaw :: forall e. Buffer e -> RawBuffer e
    bufRaw=RawBuffer Char
    iraw, bufL :: forall e. Buffer e -> Int
    bufL=Int
    ir0, bufR :: forall e. Buffer e -> Int
    bufR=Int
    iw,  bufSize :: forall e. Buffer e -> Int
    bufSize=Int
    _  }
      output :: Buffer Word8
    output@Buffer{ bufRaw :: forall e. Buffer e -> RawBuffer e
    bufRaw=RawBuffer Word8
    oraw, bufL :: forall e. Buffer e -> Int
    bufL=Int
    _,   bufR :: forall e. Buffer e -> Int
    bufR=Int
    ow0, bufSize :: forall e. Buffer e -> Int
    bufSize=Int
    os }
      State# RealWorld
    st
     = let
          {-# NOINLINE done #-}
          done :: CodingProgress -> Int -> Int -> EncodingBuffer#
          done :: CodingProgress -> Int -> Int -> EncodingBuffer#
    done CodingProgress
    why !Int
    ir !Int
    ow State# RealWorld
    st' =
            let !ri :: Buffer Char
    ri = if Int
    ir Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    iw then Buffer Char
    input{ bufL = 0, bufR = 0 } else Buffer Char
    input{ bufL = ir }
                !ro :: Buffer Word8
    ro = Buffer Word8
    output{ bufR = ow }
            in  (# State# RealWorld
    st', CodingProgress
    why, Buffer Char
    ri, Buffer Word8
    ro #)
          loop :: Int -> Int -> EncodingBuffer#
          loop :: Int -> Int -> EncodingBuffer#
    loop !Int
    ir !Int
    ow State# RealWorld
    st0
            | Int
    ow Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Int
    os = CodingProgress -> Int -> Int -> EncodingBuffer#
    done CodingProgress
    OutputUnderflow Int
    ir Int
    ow State# RealWorld
    st0
            | Int
    ir Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Int
    iw = CodingProgress -> Int -> Int -> EncodingBuffer#
    done CodingProgress
    InputUnderflow Int
    ir Int
    ow State# RealWorld
    st0
            | Bool
    otherwise = do
               let !(# State# RealWorld
    st1, (Char
    c,Int
    ir') #) = IO (Char, Int)
    -> State# RealWorld -> (# State# RealWorld, (Char, Int) #)
    forall a. IO a -> State# RealWorld -> (# State# RealWorld, a #)
    unIO (RawBuffer Char -> Int -> IO (Char, Int)
    readCharBuf RawBuffer Char
    iraw Int
    ir) State# RealWorld
    st0
               case Char -> Int
    ord Char
    c of
                 Int
    x | Int
    x Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Int
    0x7F   -> do
                         let !(# State# RealWorld
    st2, () #) = IO () -> State# RealWorld -> (# State# RealWorld, () #)
    forall a. IO a -> State# RealWorld -> (# State# RealWorld, a #)
    unIO (RawBuffer Word8 -> Int -> Word8 -> IO ()
    writeWord8Buf RawBuffer Word8
    oraw Int
    ow (Int -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    x)) State# RealWorld
    st1
                         Int -> Int -> EncodingBuffer#
    loop Int
    ir' (Int
    owInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    1) State# RealWorld
    st2
                   | Int
    x Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Int
    0x07FF ->
                        if Int
    os Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    ow Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    < Int
    2 then CodingProgress -> Int -> Int -> EncodingBuffer#
    done CodingProgress
    OutputUnderflow Int
    ir Int
    ow State# RealWorld
    st1 else do
                        let (Word8
    c1,Word8
    c2) = Char -> (Word8, Word8)
    ord2 Char
    c
                            !(# State# RealWorld
    st2, () #) = IO () -> State# RealWorld -> (# State# RealWorld, () #)
    forall a. IO a -> State# RealWorld -> (# State# RealWorld, a #)
    unIO (RawBuffer Word8 -> Int -> Word8 -> IO ()
    writeWord8Buf RawBuffer Word8
    oraw Int
    ow     Word8
    c1) State# RealWorld
    st1
                            !(# State# RealWorld
    st3, () #) = IO () -> State# RealWorld -> (# State# RealWorld, () #)
    forall a. IO a -> State# RealWorld -> (# State# RealWorld, a #)
    unIO (RawBuffer Word8 -> Int -> Word8 -> IO ()
    writeWord8Buf RawBuffer Word8
    oraw (Int
    owInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    1) Word8
    c2) State# RealWorld
    st2
                        Int -> Int -> EncodingBuffer#
    loop Int
    ir' (Int
    owInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    2) State# RealWorld
    st3
                   | Int
    x Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Int
    0xFFFF -> if Char -> Bool
    isSurrogate Char
    c then CodingProgress -> Int -> Int -> EncodingBuffer#
    done CodingProgress
    InvalidSequence Int
    ir Int
    ow State# RealWorld
    st1 else do
                        if Int
    os Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    ow Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    < Int
    3 then CodingProgress -> Int -> Int -> EncodingBuffer#
    done CodingProgress
    OutputUnderflow Int
    ir Int
    ow State# RealWorld
    st1 else do
                        let (Word8
    c1,Word8
    c2,Word8
    c3) = Char -> (Word8, Word8, Word8)
    ord3 Char
    c
                            !(# State# RealWorld
    st2, () #) = IO () -> State# RealWorld -> (# State# RealWorld, () #)
    forall a. IO a -> State# RealWorld -> (# State# RealWorld, a #)
    unIO (RawBuffer Word8 -> Int -> Word8 -> IO ()
    writeWord8Buf RawBuffer Word8
    oraw Int
    ow     Word8
    c1) State# RealWorld
    st1
                            !(# State# RealWorld
    st3, () #) = IO () -> State# RealWorld -> (# State# RealWorld, () #)
    forall a. IO a -> State# RealWorld -> (# State# RealWorld, a #)
    unIO (RawBuffer Word8 -> Int -> Word8 -> IO ()
    writeWord8Buf RawBuffer Word8
    oraw (Int
    owInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    1) Word8
    c2) State# RealWorld
    st2
                            !(# State# RealWorld
    st4, () #) = IO () -> State# RealWorld -> (# State# RealWorld, () #)
    forall a. IO a -> State# RealWorld -> (# State# RealWorld, a #)
    unIO (RawBuffer Word8 -> Int -> Word8 -> IO ()
    writeWord8Buf RawBuffer Word8
    oraw (Int
    owInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    2) Word8
    c3) State# RealWorld
    st3
                        Int -> Int -> EncodingBuffer#
    loop Int
    ir' (Int
    owInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    3) State# RealWorld
    st4
                   | Bool
    otherwise -> do
                        if Int
    os Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    ow Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    < Int
    4 then CodingProgress -> Int -> Int -> EncodingBuffer#
    done CodingProgress
    OutputUnderflow Int
    ir Int
    ow State# RealWorld
    st1 else do
                        let (Word8
    c1,Word8
    c2,Word8
    c3,Word8
    c4) = Char -> (Word8, Word8, Word8, Word8)
    ord4 Char
    c
                            !(# State# RealWorld
    st2, () #) = IO () -> State# RealWorld -> (# State# RealWorld, () #)
    forall a. IO a -> State# RealWorld -> (# State# RealWorld, a #)
    unIO (RawBuffer Word8 -> Int -> Word8 -> IO ()
    writeWord8Buf RawBuffer Word8
    oraw Int
    ow     Word8
    c1) State# RealWorld
    st1
                            !(# State# RealWorld
    st3, () #) = IO () -> State# RealWorld -> (# State# RealWorld, () #)
    forall a. IO a -> State# RealWorld -> (# State# RealWorld, a #)
    unIO (RawBuffer Word8 -> Int -> Word8 -> IO ()
    writeWord8Buf RawBuffer Word8
    oraw (Int
    owInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    1) Word8
    c2) State# RealWorld
    st2
                            !(# State# RealWorld
    st4, () #) = IO () -> State# RealWorld -> (# State# RealWorld, () #)
    forall a. IO a -> State# RealWorld -> (# State# RealWorld, a #)
    unIO (RawBuffer Word8 -> Int -> Word8 -> IO ()
    writeWord8Buf RawBuffer Word8
    oraw (Int
    owInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    2) Word8
    c3) State# RealWorld
    st3
                            !(# State# RealWorld
    st5, () #) = IO () -> State# RealWorld -> (# State# RealWorld, () #)
    forall a. IO a -> State# RealWorld -> (# State# RealWorld, a #)
    unIO (RawBuffer Word8 -> Int -> Word8 -> IO ()
    writeWord8Buf RawBuffer Word8
    oraw (Int
    owInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    3) Word8
    c4) State# RealWorld
    st4
                        Int -> Int -> EncodingBuffer#
    loop Int
    ir' (Int
    owInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    4) State# RealWorld
    st5
       in
       Int -> Int -> EncodingBuffer#
    loop Int
    ir0 Int
    ow0 State# RealWorld
    st

    -- -----------------------------------------------------------------------------
    -- UTF-8 primitives, lifted from Data.Text.Fusion.Utf8

    ord2   :: Char -> (Word8,Word8)
    ord2 :: Char -> (Word8, Word8)
    ord2 Char
    c = Bool -> (Word8, Word8) -> (Word8, Word8)
    forall a. (?callStack::CallStack) => Bool -> a -> a
    assert (Int
    n Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Int
    0x80 Bool -> Bool -> Bool
    && Int
    n Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Int
    0x07ff) (Word8
    x1,Word8
    x2)
        where
          n :: Int
    n  = Char -> Int
    ord Char
    c
          x1 :: Word8
    x1 = Int -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Word8) -> Int -> Word8
    forall a b. (a -> b) -> a -> b
    $ (Int
    n Int -> Int -> Int
    forall a. Bits a => a -> Int -> a
    `shiftR` Int
    6) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    0xC0
          x2 :: Word8
    x2 = Int -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Word8) -> Int -> Word8
    forall a b. (a -> b) -> a -> b
    $ (Int
    n Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .&. Int
    0x3F)   Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    0x80

    ord3   :: Char -> (Word8,Word8,Word8)
    ord3 :: Char -> (Word8, Word8, Word8)
    ord3 Char
    c = Bool -> (Word8, Word8, Word8) -> (Word8, Word8, Word8)
    forall a. (?callStack::CallStack) => Bool -> a -> a
    assert (Int
    n Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Int
    0x0800 Bool -> Bool -> Bool
    && Int
    n Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Int
    0xffff) (Word8
    x1,Word8
    x2,Word8
    x3)
        where
          n :: Int
    n  = Char -> Int
    ord Char
    c
          x1 :: Word8
    x1 = Int -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Word8) -> Int -> Word8
    forall a b. (a -> b) -> a -> b
    $ (Int
    n Int -> Int -> Int
    forall a. Bits a => a -> Int -> a
    `shiftR` Int
    12) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    0xE0
          x2 :: Word8
    x2 = Int -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Word8) -> Int -> Word8
    forall a b. (a -> b) -> a -> b
    $ ((Int
    n Int -> Int -> Int
    forall a. Bits a => a -> Int -> a
    `shiftR` Int
    6) Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .&. Int
    0x3F) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    0x80
          x3 :: Word8
    x3 = Int -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Word8) -> Int -> Word8
    forall a b. (a -> b) -> a -> b
    $ (Int
    n Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .&. Int
    0x3F) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    0x80

    ord4   :: Char -> (Word8,Word8,Word8,Word8)
    ord4 :: Char -> (Word8, Word8, Word8, Word8)
    ord4 Char
    c = Bool
    -> (Word8, Word8, Word8, Word8) -> (Word8, Word8, Word8, Word8)
    forall a. (?callStack::CallStack) => Bool -> a -> a
    assert (Int
    n Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Int
    0x10000) (Word8
    x1,Word8
    x2,Word8
    x3,Word8
    x4)
        where
          n :: Int
    n  = Char -> Int
    ord Char
    c
          x1 :: Word8
    x1 = Int -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Word8) -> Int -> Word8
    forall a b. (a -> b) -> a -> b
    $ (Int
    n Int -> Int -> Int
    forall a. Bits a => a -> Int -> a
    `shiftR` Int
    18) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    0xF0
          x2 :: Word8
    x2 = Int -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Word8) -> Int -> Word8
    forall a b. (a -> b) -> a -> b
    $ ((Int
    n Int -> Int -> Int
    forall a. Bits a => a -> Int -> a
    `shiftR` Int
    12) Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .&. Int
    0x3F) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    0x80
          x3 :: Word8
    x3 = Int -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Word8) -> Int -> Word8
    forall a b. (a -> b) -> a -> b
    $ ((Int
    n Int -> Int -> Int
    forall a. Bits a => a -> Int -> a
    `shiftR` Int
    6) Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .&. Int
    0x3F) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    0x80
          x4 :: Word8
    x4 = Int -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Word8) -> Int -> Word8
    forall a b. (a -> b) -> a -> b
    $ (Int
    n Int -> Int -> Int
    forall a. Bits a => a -> a -> a
    .&. Int
    0x3F) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    0x80

    chr2       :: Word8 -> Word8 -> Char
    chr2 :: Word8 -> Word8 -> Char
    chr2 (W8# Word8#
    x1#) (W8# Word8#
    x2#) = Char# -> Char
    C# (Int# -> Char#
    chr# (Int#
    z1# Int# -> Int# -> Int#
    +# Int#
    z2#))
        where
          !y1# :: Int#
    y1# = Word# -> Int#
    word2Int# (Word8# -> Word#
    word8ToWord# Word8#
    x1#)
          !y2# :: Int#
    y2# = Word# -> Int#
    word2Int# (Word8# -> Word#
    word8ToWord# Word8#
    x2#)
          !z1# :: Int#
    z1# = Int# -> Int# -> Int#
    uncheckedIShiftL# (Int#
    y1# Int# -> Int# -> Int#
    -# Int#
    0xC0#) Int#
    6#
          !z2# :: Int#
    z2# = Int#
    y2# Int# -> Int# -> Int#
    -# Int#
    0x80#
    {-# INLINE chr2 #-}

    chr3          :: Word8 -> Word8 -> Word8 -> Char
    chr3 :: Word8 -> Word8 -> Word8 -> Char
    chr3 (W8# Word8#
    x1#) (W8# Word8#
    x2#) (W8# Word8#
    x3#) = Char# -> Char
    C# (Int# -> Char#
    chr# (Int#
    z1# Int# -> Int# -> Int#
    +# Int#
    z2# Int# -> Int# -> Int#
    +# Int#
    z3#))
        where
          !y1# :: Int#
    y1# = Word# -> Int#
    word2Int# (Word8# -> Word#
    word8ToWord# Word8#
    x1#)
          !y2# :: Int#
    y2# = Word# -> Int#
    word2Int# (Word8# -> Word#
    word8ToWord# Word8#
    x2#)
          !y3# :: Int#
    y3# = Word# -> Int#
    word2Int# (Word8# -> Word#
    word8ToWord# Word8#
    x3#)
          !z1# :: Int#
    z1# = Int# -> Int# -> Int#
    uncheckedIShiftL# (Int#
    y1# Int# -> Int# -> Int#
    -# Int#
    0xE0#) Int#
    12#
          !z2# :: Int#
    z2# = Int# -> Int# -> Int#
    uncheckedIShiftL# (Int#
    y2# Int# -> Int# -> Int#
    -# Int#
    0x80#) Int#
    6#
          !z3# :: Int#
    z3# = Int#
    y3# Int# -> Int# -> Int#
    -# Int#
    0x80#
    {-# INLINE chr3 #-}

    chr4             :: Word8 -> Word8 -> Word8 -> Word8 -> Char
    chr4 :: Word8 -> Word8 -> Word8 -> Word8 -> Char
    chr4 (W8# Word8#
    x1#) (W8# Word8#
    x2#) (W8# Word8#
    x3#) (W8# Word8#
    x4#) =
        Char# -> Char
    C# (Int# -> Char#
    chr# (Int#
    z1# Int# -> Int# -> Int#
    +# Int#
    z2# Int# -> Int# -> Int#
    +# Int#
    z3# Int# -> Int# -> Int#
    +# Int#
    z4#))
        where
          !y1# :: Int#
    y1# = Word# -> Int#
    word2Int# (Word8# -> Word#
    word8ToWord# Word8#
    x1#)
          !y2# :: Int#
    y2# = Word# -> Int#
    word2Int# (Word8# -> Word#
    word8ToWord# Word8#
    x2#)
          !y3# :: Int#
    y3# = Word# -> Int#
    word2Int# (Word8# -> Word#
    word8ToWord# Word8#
    x3#)
          !y4# :: Int#
    y4# = Word# -> Int#
    word2Int# (Word8# -> Word#
    word8ToWord# Word8#
    x4#)
          !z1# :: Int#
    z1# = Int# -> Int# -> Int#
    uncheckedIShiftL# (Int#
    y1# Int# -> Int# -> Int#
    -# Int#
    0xF0#) Int#
    18#
          !z2# :: Int#
    z2# = Int# -> Int# -> Int#
    uncheckedIShiftL# (Int#
    y2# Int# -> Int# -> Int#
    -# Int#
    0x80#) Int#
    12#
          !z3# :: Int#
    z3# = Int# -> Int# -> Int#
    uncheckedIShiftL# (Int#
    y3# Int# -> Int# -> Int#
    -# Int#
    0x80#) Int#
    6#
          !z4# :: Int#
    z4# = Int#
    y4# Int# -> Int# -> Int#
    -# Int#
    0x80#
    {-# INLINE chr4 #-}

    between :: Word8                -- ^ byte to check
            -> Word8                -- ^ lower bound
            -> Word8                -- ^ upper bound
            -> Bool
    between :: Word8 -> Word8 -> Word8 -> Bool
    between Word8
    x Word8
    y Word8
    z = Word8
    x Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Word8
    y Bool -> Bool -> Bool
    && Word8
    x Word8 -> Word8 -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word8
    z
    {-# INLINE between #-}

    validate3          :: Word8 -> Word8 -> Word8 -> Bool
    {-# INLINE validate3 #-}
    validate3 :: Word8 -> Word8 -> Word8 -> Bool
    validate3 Word8
    x1 Word8
    x2 Word8
    x3 = Bool
    validate3_1 Bool -> Bool -> Bool
    ||
                         Bool
    validate3_2 Bool -> Bool -> Bool
    ||
                         Bool
    validate3_3 Bool -> Bool -> Bool
    ||
                         Bool
    validate3_4
      where
        validate3_1 :: Bool
    validate3_1 = (Word8
    x1 Word8 -> Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    == Word8
    0xE0) Bool -> Bool -> Bool
    &&
                      Word8 -> Word8 -> Word8 -> Bool
    between Word8
    x2 Word8
    0xA0 Word8
    0xBF Bool -> Bool -> Bool
    &&
                      Word8 -> Word8 -> Word8 -> Bool
    between Word8
    x3 Word8
    0x80 Word8
    0xBF
        validate3_2 :: Bool
    validate3_2 = Word8 -> Word8 -> Word8 -> Bool
    between Word8
    x1 Word8
    0xE1 Word8
    0xEC Bool -> Bool -> Bool
    &&
                      Word8 -> Word8 -> Word8 -> Bool
    between Word8
    x2 Word8
    0x80 Word8
    0xBF Bool -> Bool -> Bool
    &&
                      Word8 -> Word8 -> Word8 -> Bool
    between Word8
    x3 Word8
    0x80 Word8
    0xBF
        validate3_3 :: Bool
    validate3_3 = Word8
    x1 Word8 -> Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    == Word8
    0xED Bool -> Bool -> Bool
    &&
                      Word8 -> Word8 -> Word8 -> Bool
    between Word8
    x2 Word8
    0x80 Word8
    0x9F Bool -> Bool -> Bool
    &&
                      Word8 -> Word8 -> Word8 -> Bool
    between Word8
    x3 Word8
    0x80 Word8
    0xBF
        validate3_4 :: Bool
    validate3_4 = Word8 -> Word8 -> Word8 -> Bool
    between Word8
    x1 Word8
    0xEE Word8
    0xEF Bool -> Bool -> Bool
    &&
                      Word8 -> Word8 -> Word8 -> Bool
    between Word8
    x2 Word8
    0x80 Word8
    0xBF Bool -> Bool -> Bool
    &&
                      Word8 -> Word8 -> Word8 -> Bool
    between Word8
    x3 Word8
    0x80 Word8
    0xBF

    validate4             :: Word8 -> Word8 -> Word8 -> Word8 -> Bool
    {-# INLINE validate4 #-}
    validate4 :: Word8 -> Word8 -> Word8 -> Word8 -> Bool
    validate4 Word8
    x1 Word8
    x2 Word8
    x3 Word8
    x4 = Bool
    validate4_1 Bool -> Bool -> Bool
    ||
                            Bool
    validate4_2 Bool -> Bool -> Bool
    ||
                            Bool
    validate4_3
      where
        validate4_1 :: Bool
    validate4_1 = Word8
    x1 Word8 -> Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    == Word8
    0xF0 Bool -> Bool -> Bool
    &&
                      Word8 -> Word8 -> Word8 -> Bool
    between Word8
    x2 Word8
    0x90 Word8
    0xBF Bool -> Bool -> Bool
    &&
                      Word8 -> Word8 -> Word8 -> Bool
    between Word8
    x3 Word8
    0x80 Word8
    0xBF Bool -> Bool -> Bool
    &&
                      Word8 -> Word8 -> Word8 -> Bool
    between Word8
    x4 Word8
    0x80 Word8
    0xBF
        validate4_2 :: Bool
    validate4_2 = Word8 -> Word8 -> Word8 -> Bool
    between Word8
    x1 Word8
    0xF1 Word8
    0xF3 Bool -> Bool -> Bool
    &&
                      Word8 -> Word8 -> Word8 -> Bool
    between Word8
    x2 Word8
    0x80 Word8
    0xBF Bool -> Bool -> Bool
    &&
                      Word8 -> Word8 -> Word8 -> Bool
    between Word8
    x3 Word8
    0x80 Word8
    0xBF Bool -> Bool -> Bool
    &&
                      Word8 -> Word8 -> Word8 -> Bool
    between Word8
    x4 Word8
    0x80 Word8
    0xBF
        validate4_3 :: Bool
    validate4_3 = Word8
    x1 Word8 -> Word8 -> Bool
    forall a. Eq a => a -> a -> Bool
    == Word8
    0xF4 Bool -> Bool -> Bool
    &&
                      Word8 -> Word8 -> Word8 -> Bool
    between Word8
    x2 Word8
    0x80 Word8
    0x8F Bool -> Bool -> Bool
    &&
                      Word8 -> Word8 -> Word8 -> Bool
    between Word8
    x3 Word8
    0x80 Word8
    0xBF Bool -> Bool -> Bool
    &&
                      Word8 -> Word8 -> Word8 -> Bool
    between Word8
    x4 Word8
    0x80 Word8
    0xBF