Submission #47058458

---

Source Code Expand

{-# LANGUAGE
  ScopedTypeVariables, BangPatterns, TupleSections, ExplicitForAll,
  LambdaCase, MultiWayIf, Unsafe, RecordWildCards, FlexibleContexts, CPP,
  NoMonomorphismRestriction, GADTs, PatternGuards, MagicHash,
  UnboxedTuples, InstanceSigs, DataKinds, TypeOperators,
  RankNTypes, EmptyDataDecls, EmptyCase, ViewPatterns, PolyKinds,
  TypeFamilies, OverloadedStrings, FlexibleInstances, UndecidableInstances,
  DefaultSignatures, GeneralizedNewtypeDeriving, StandaloneDeriving,
  DeriveGeneric, DeriveFunctor, DeriveDataTypeable, DeriveFoldable,
  DeriveTraversable, DeriveDataTypeable, FlexibleInstances,
  MultiParamTypeClasses, TypeApplications, RecordWildCards,
  PackageImports, DerivingStrategies, PatternSynonyms,
  NumericUnderscores, ConstraintKinds #-}
{-# OPTIONS_GHC -O2 -Wno-unused-top-binds -Wno-unused-imports #-}

#include "MachDeps.h"

#define PHASE_FUSED [1]
#define PHASE_INNER [0]
#define INLINE_FUSED INLINE PHASE_FUSED
#define INLINE_INNER INLINE PHASE_INNER

import Prelude
import Data.Bits
import Data.List as Lst
import Data.Maybe
import Data.Tuple
import Data.Ord
import Data.Int
import Data.Word
import Data.Char
import Data.Ratio
import Data.Function
import Data.STRef
import Data.IORef
import Data.Monoid
import Data.Functor
import Data.Functor.Identity
import Data.Data
import Data.Typeable
import Data.Bifunctor
import Data.Foldable as Fld
import Data.Traversable as Tr
import GHC.Generics
import System.IO
import System.IO.Unsafe (unsafeDupablePerformIO, unsafePerformIO)
import qualified Control.Arrow as Aw
import Control.Applicative
import Control.Monad
import Control.Monad.Primitive
import Control.Monad.State.Strict
import Control.Monad.ST
import Control.Monad.ST.Lazy (strictToLazyST, lazyToStrictST)
import qualified Control.Monad.ST.Lazy as STL
-- import Control.Monad.ST.Safe
import Control.DeepSeq
import Data.Coerce
import Data.Primitive.MutVar
import qualified Data.Primitive as Prim
import qualified Data.ByteString as BSW
import qualified Data.ByteString.Char8 as BS
import qualified Data.ByteString.Lazy as BSLW
import qualified Data.ByteString.Lazy.Char8 as BSL
import qualified Data.ByteString.Builder as BSB
import qualified Data.ByteString.Unsafe as BSU
import qualified Data.ByteString.Internal as BSU
import qualified Data.IntPSQ as IntPSQ
import Data.IntPSQ (IntPSQ)
import qualified Data.OrdPSQ as OrdPSQ
import Data.OrdPSQ (OrdPSQ)
import qualified Data.HashPSQ as HashPSQ
import Data.HashPSQ (HashPSQ)
import qualified Data.HashMap.Strict as HashMap
import qualified Data.HashMap.Strict as HMS
import qualified Data.HashMap.Lazy as HashMapL
import qualified Data.HashMap.Lazy as HML
import Data.HashMap.Strict (HashMap)
import qualified Data.IntMap.Strict as IntMap
import qualified Data.IntMap.Strict as IMS
import qualified Data.IntMap.Lazy as IntMapL
import qualified Data.IntMap.Lazy as IML
import Data.IntMap (IntMap)
import qualified Data.Map.Strict as Map
import qualified Data.Map.Lazy as MapL
import Data.Map.Strict (Map)
import Data.List as List
import Data.Hashable (Hashable)
import Data.Set (Set)
import qualified Data.Set as Set
import Data.HashSet (HashSet)
import qualified Data.HashSet as HashSet
import Data.IntSet (IntSet)
import qualified Data.IntSet as IntSet
import qualified Data.IntSet as IS
import qualified Data.Sequence as Seq
import Data.Sequence (Seq)
import qualified Data.Array.IArray as A
import qualified Data.Array.MArray.Safe as A
import qualified Data.Array.MArray as A
import Data.Array (Array)
import Data.Array.Unboxed (UArray)
import Data.Array.IArray (IArray)
import Data.Array.MArray.Safe (MArray)
import Data.Array.IO.Safe (IOArray, IOUArray)
import Data.Array.ST.Safe (STArray, STUArray, runSTArray, runSTUArray)
import qualified Data.Vector as V
import qualified Data.Vector.Mutable as VM
import qualified Data.Vector.Unboxed as VU
import qualified Data.Vector.Unboxed.Mutable as VUM
import qualified Data.Vector.Storable as VS
import qualified Data.Vector.Storable.Mutable as VSM
import qualified Data.Vector.Primitive as VP
import qualified Data.Vector.Primitive.Mutable as VPM
import qualified Data.Vector.Generic as VG
import qualified Data.Vector.Generic.Mutable as VGM
import qualified Data.Vector.Generic.New as VGN
import qualified Data.Vector.Fusion.Bundle.Monadic as VFBM
import qualified Data.Vector.Fusion.Bundle as VFB
import qualified Data.Vector.Fusion.Stream.Monadic as VFSM
import qualified Data.Vector.Fusion.Bundle.Size as VFBS
import qualified Data.Vector.Fusion.Util as VFU
import qualified Data.Vector.Algorithms.Intro as VAIT
import qualified Data.Attoparsec.ByteString.Char8 as Atto
import qualified Debug.Trace
import qualified Data.Mutable as DMut
import Unsafe.Coerce
import Foreign.ForeignPtr
import GHC.Float (castWord64ToDouble, castDoubleToWord64)
import GHC.Word (Word(..), Word64(..))
import GHC.Exts (build, Int(..),
                 (+#), (*#), (-#), (<#), (>=#), (==#), quotRemInt#,
                 remInt#, uncheckedIShiftRL#, andI#, orI#,
                 Addr#, Ptr(..),
                 timesWord2#, quotRemWord2#, minusWord#, Word#,
                 uncheckedShiftRL#, plusWord#, and#, word2Int#,
                 isTrue#, Int#, not#, negateInt#, int2Word#, ltWord#,
                 eqWord#, neWord#, or#, ctz#, timesWord#, leWord#,
                 uncheckedShiftL#, plusWord2#, geWord# )
import GHC.TypeLits ( type (<=) )
import GHC.TypeNats ( KnownNat, Nat )
import qualified GHC.TypeNats as TNats ( natVal )
import Numeric.Natural
import Data.Reflection
import Math.NumberTheory.Logarithms (naturalLog2)
import GHC.Stack
import GHC.Int
#if __GLASGOW_HASKELL__ >= 902
import GHC.Num.Integer
#endif


subsetGen2 :: VU.Vector Int -> IntMap Int
subsetGen2 = VU.ifoldl'
  (\ !ps !i !x -> IMS.union ps $ IMS.fromDistinctAscList
    $ map ((+x) `bimap` const i) $ IMS.toList ps)
  (IMS.singleton 0 (-1))

subsetSum2 :: VU.Vector Int -> Int -> Maybe (VU.Vector Bool)
subsetSum2 xs !goal = (\(x,y) -> dig sumsL l x VU.++ dig sumsR r y)
  <$> go (IMS.toAscList sumsL) (IMS.toDescList sumsR)
  where
    go as@((a,_):as') ds@((d,_):ds') = case compare (a+d) goal of
      LT -> go as' ds
      EQ -> Just (a, d)
      GT -> go as ds'
    go _ _ = Nothing
    !len = VU.length xs
    !off = len `div` 2
    (l,r) = VU.splitAt off xs
    !sumsL = subsetGen2 l
    !sumsR = subsetGen2 r
    dig sums vec x = VU.replicate (VU.length vec) False VU.//
      unfoldr (\ !s -> let !i = sums IMS.! s
                       in if i >= 0 then Just $! ((i, True),) $! s - vec VU.! i
                          else Nothing) x

subsetGen :: VU.Vector Int -> VU.Vector (Int,Int)
subsetGen = VU.ifoldl' add (VU.singleton (0, -1))
  where
    add :: VU.Vector (Int,Int) -> Int -> Int -> VU.Vector (Int,Int)
    add !ps !i !x = VU.create $ do
      res <- VUM.new (VU.length ps * 2)
      let merge !u !v !w
            | u >= len = do
                VU.iforM_ (VU.drop v ps) $ \ !k (!pvk,_) ->
                  VUM.unsafeWrite res (w+k) (pvk + x, i)
                return (w + len - v)
            | v >= len = do
                VU.unsafeCopy
                  (VUM.unsafeSlice w (len - u) res)
                  (VU.drop u ps)
                return (w + len - v)
          merge !u !v !w = case compare pu pvx of
            LT -> do VUM.unsafeWrite res w (pu, ju)
                     merge (u+1)  v    (w+1)
            GT -> do VUM.unsafeWrite res w (pvx, i)
                     merge  u    (v+1) (w+1)
            EQ -> do VUM.unsafeWrite res w (pu, ju)
                     merge (u+1) (v+1) (w+1)
            where
              !(!pu, !ju) = VU.unsafeIndex ps u
              !pvx = (+x) $ fst $ VU.unsafeIndex ps v
      !rlen <- merge 0 0 0
      return $ VUM.take rlen res
      where
        !len = VU.length ps

subsetSum :: VU.Vector Int -> Int -> Maybe (VU.Vector Bool)
subsetSum xs !goal = go sumsL sumsR <&> \(x,y) -> dig sumsL l x VU.++ dig sumsR r y
  where
    go as@(VU.uncons -> Just ((a,_),as')) ds@(VU.unsnoc -> Just (ds',(d,_)))
      = case compare (a+d) goal of
      LT -> go as' ds
      EQ -> Just (a, d)
      GT -> go as ds'
    go _ _ = Nothing
    !len = VU.length xs
    !off = len `div` 2
    (l,r) = VU.splitAt off xs
    sumsL = subsetGen l
    sumsR = subsetGen r
    dig sums vec x = VU.update (VU.replicate (VU.length vec) False)
      $ VU.unfoldr (\ !s -> let !i = search sums s
                            in if i >= 0 then Just $! ((i, True),) $! s - vec VU.! i
                               else Nothing) x
    search ps x = lp 0 (VU.length ps)
      where
        lp !le !gt | diff <= 1 = snd $ ps `VU.unsafeIndex` le
                   | midval <= x = lp mid gt
                   | otherwise   = lp le mid
          where
            !diff = gt - le
            mid = le + shiftR diff 1
            midval = fst $ VU.unsafeIndex ps mid
    
          

query :: VU.Vector Int -> (Int,Int) -> Maybe (VU.Vector Bool)
query !as (x,y) = do
  guard $ x >= xmin && y >= ymin && even (x-xmin) && even (y-ymin)
  !xres <- subsetSum xpart $ (x-xmin) `div` 2
  !yres <- subsetSum ypart $ (y-ymin) `div` 2
  let !dirs = VU.update (VU.replicate (len+1) (1::Int,0::Int))
          $ VU.imap (\i b -> (2*i+1, (0,if b then 1 else -1))) yres
          VU.++ VU.imap (\ i b -> (2*i+2, (if b then 1 else -1,0))) xres
      !res = VU.zipWith (\(dx,dy) -> ((dy,-dx)==)) dirs (VU.tail dirs)
  return res
  where
    !len = VU.length as
    !xlen = len `div` 2
    !ylen = len - xlen
    !xpart = VU.backpermute as (VU.enumFromStepN 1 2 xlen)
    !xmin = negate (VU.sum xpart)
    !ypart = VU.backpermute as (VU.enumFromStepN 0 2 ylen)
    !ymin = negate (VU.sum ypart)

main :: IO ()
main = do
  [n,x,y] <- map readInt . words <$> getLine
  as <- getVecULn n rInt
  case query as (x,y) of
    Nothing -> putStrLn "No"
    Just res -> do putStrLn "Yes"
                   BS.putStrLn $ svecToBS $ VS.convert
                     $ VU.map (\r -> if r then ord8 'R' else ord8 'L') res
  return ()

debug :: Bool
debug = True

#define DefDebugAux(fct,ty,debugvar,dbg,rel)\
  fct :: ty; {-# INLINE fct #-}; fct | debugvar = dbg | otherwise = rel
#define DefDebug(fct,ty,rel) DefDebugAux(fct,ty,debug,Debug.Trace.fct,rel)
#define DefDebugC(fct,ty,rel) DefDebug(fct,ty,const (rel))

DefDebugC(trace, String -> a -> a, id)
DefDebug(traceId, String -> String, id)
DefDebugC(traceShow, Show b => b -> a -> a, id)
DefDebug(traceShowId, Show a => a -> a, id)
DefDebugC(traceStack, String -> a -> a, id)
DefDebugC(traceIO, String -> IO (), return ())
DefDebugC(traceM, Applicative f => String -> f (), pure ())
DefDebugC(traceShowM, (Show a, Applicative f) => a -> f (), pure ())
DefDebugC(traceEvent, String -> a -> a, id)
DefDebugC(traceEventIO, String -> IO (), pure ())
DefDebugC(traceMarker, String -> a -> a, id)
DefDebugC(traceMarkerIO, String -> IO (), pure ())

#undef DefDebugAux
#undef DefDebug
#undef DefDebugC

traceShowIO :: Show a => a -> IO ()
{-# INLINE traceShowIO #-}
traceShowIO | debug     = Debug.Trace.traceIO . show
            | otherwise = const $ pure ()

#define IL(f) {-# INLINE f #-}; f

putBuilder :: BSB.Builder -> IO ()
IL(putBuilder) = BSB.hPutBuilder stdout

printVecInLines, printVecInSpcSepLn ::
  (VG.Vector v a, ShowAsBuilder a) => v a -> IO ()
IL(printVecInLines) = putBuilder . v2BLines
IL(printVecInSpcSepLn) = putBuilder . v2BSpcSepLn

class ShowAsBuilder a where
  showAsBuilder :: a -> BSB.Builder
  default showAsBuilder :: (Show a) => a -> BSB.Builder
  IL(showAsBuilder) = BSB.string8 . show

-- Inconsistent with show
instance {-# INCOHERENT #-} (ShowAsBuilder a, VG.Vector v a) => ShowAsBuilder (v a) where
  IL(showAsBuilder) = v2BSpcSep

#define INS(t,f) instance ShowAsBuilder t where { IL(showAsBuilder)=f }
INS(Int,BSB.intDec)
INS(Int8,BSB.int8Dec)
INS(Int16,BSB.int16Dec)
INS(Int32,BSB.int32Dec)
INS(Int64,BSB.int64Dec)
INS(Word,BSB.wordDec)
INS(Word8,BSB.word8Dec)
INS(Word16,BSB.word16Dec)
INS(Word32,BSB.word32Dec)
INS(Word64,BSB.word64Dec)
INS(Integer,BSB.integerDec)
INS(Float,BSB.floatDec)
INS(Double,BSB.doubleDec)
-- INS(String,BSB.string8) -- Inconsistent with Show
-- INS(BS.ByteString,BSB.byteString) -- Inconsistent with Show
-- INS(BSL.ByteString,BSB.lazyByteString) -- Inconsisitent with Show
#undef INS


vConstrAccN
  :: VG.Vector v b
  => Int
  -> (v b -> a -> (a, b))
  -> a
  -> (a, v b)
{-# INLINE vConstrAccN #-}
vConstrAccN n f a0 = runST $ do
  res <- VGM.unsafeNew (max 0 n)
  let go !i a | i >= n = (a,) <$> VG.unsafeFreeze res
      go !i a = do
        (a', b) <- (`f` a) <$> VG.unsafeFreeze (VGM.unsafeTake i res)
        VGM.unsafeWrite res i b
        go (i+1) a'
  go 0 a0

-- Inconsistent with Show
instance (ShowAsBuilder a, ShowAsBuilder b) => ShowAsBuilder (a,b) where
  IL(showAsBuilder) = showTupAsBuilder
instance (ShowAsBuilder a, ShowAsBuilder b, ShowAsBuilder c) =>
  ShowAsBuilder (a,b,c) where
  IL(showAsBuilder) = showTup3AsBuilder
instance (ShowAsBuilder a, ShowAsBuilder b, ShowAsBuilder c, ShowAsBuilder d) =>
  ShowAsBuilder (a,b,c,d) where
  IL(showAsBuilder) = showTup4AsBuilder

IL(showTupAsBuilderWith)
  :: (a -> BSB.Builder) -> (b -> BSB.Builder) -> (a,b) -> BSB.Builder
showTupAsBuilderWith showA showB
  = \(a,b) -> (showA a <>) $ BSB.char7 ' ' <> showB b
IL(showTupAsBuilder) :: (ShowAsBuilder a, ShowAsBuilder b)
  => (a,b) -> BSB.Builder
showTupAsBuilder = showTupAsBuilderWith showAsBuilder showAsBuilder 

IL(showTup3AsBuilderWith) :: (a -> BSB.Builder) -> (b -> BSB.Builder) ->
  (c -> BSB.Builder) -> (a,b,c) -> BSB.Builder
showTup3AsBuilderWith showA showB showC
  = \(a,b,c) -> (showA a <>) $ (BSB.char7 ' ' <>) $ (showB b <>)
                $ (BSB.char7 ' ' <>) $ showC c
IL(showTup3AsBuilder) :: (ShowAsBuilder a, ShowAsBuilder b, ShowAsBuilder c)
  => (a,b,c) -> BSB.Builder
showTup3AsBuilder
  = showTup3AsBuilderWith showAsBuilder showAsBuilder showAsBuilder

IL(showTup4AsBuilderWith) :: (a -> BSB.Builder) -> (b -> BSB.Builder) ->
  (c -> BSB.Builder) -> (d -> BSB.Builder) -> (a,b,c,d) -> BSB.Builder
showTup4AsBuilderWith showA showB showC showD
  = \(a,b,c,d) -> (showA a <>) $ (BSB.char7 ' ' <>)
                  $ showTup3AsBuilderWith showB showC showD (b,c,d)
IL(showTup4AsBuilder) ::
  (ShowAsBuilder a, ShowAsBuilder b, ShowAsBuilder c, ShowAsBuilder d) =>
  (a,b,c,d) -> BSB.Builder
showTup4AsBuilder = showTup4AsBuilderWith showAsBuilder showAsBuilder
                    showAsBuilder showAsBuilder

v2BSpcSepLn, v2BSpcSep, v2BConcat, v2BLines ::
  (VG.Vector v a, ShowAsBuilder a)
  => v a -> BSB.Builder
IL(v2BSpcSepLn) = v2BSpcSepLnWith showAsBuilder
IL(v2BSpcSep) = v2BSpcSepWith showAsBuilder
IL(v2BConcat) = v2BConcatWith showAsBuilder
IL(v2BLines) = v2BLinesWith showAsBuilder


v2BSpcSepLnWith, v2BSpcSepWith, v2BConcatWith, v2BLinesWith ::
  (VG.Vector v a)
  => (a -> BSB.Builder) -- ^ show function
  -> v a -> BSB.Builder
IL(v2BSpcSepLnWith) = v2BSpcSepPostfWith $ BS.singleton '\n'
IL(v2BSpcSepWith) = v2BSpcSepPostfWith BS.empty
IL(v2BConcatWith) showFct = VG.foldr ((<>) . showFct) mempty
IL(v2BLinesWith) showFct
  = VG.foldr (\ a -> (showFct a <>) . (BSB.char7 '\n' <>)) mempty


v2BSpcSepPostf :: (VG.Vector v a, ShowAsBuilder a)
  => BS.ByteString -- ^ postfix
  -> v a -> BSB.Builder
IL(v2BSpcSepPostf) = (`v2BSpcSepPostfWith` showAsBuilder)

v2BSpcSepPostfWith :: (VG.Vector v a)
  => BS.ByteString -- ^ postfix
  -> (a -> BSB.Builder) -- ^ show function
  -> v a -> BSB.Builder
IL(v2BSpcSepPostfWith) = vecToBuilder BS.empty $ BS.singleton ' '

IL(vecToBuilder) :: (VG.Vector v a)
  => BS.ByteString -- ^ prefix
  -> BS.ByteString -- ^ separator
  -> BS.ByteString -- ^ postfix
  -> (a -> BSB.Builder) -- ^ show function
  -> v a -> BSB.Builder
vecToBuilder !prefix !separator !postfix
  = vecToBuilder_ (BSB.byteString prefix)
                  (BSB.byteString separator)
                  (BSB.byteString postfix)


IL(vecToBuilder_) :: (VG.Vector v a)
  => BSB.Builder -- ^ prefix
  -> BSB.Builder -- ^ separator
  -> BSB.Builder -- ^ postfix
  -> (a -> BSB.Builder) -- ^ show function
  -> v a -> BSB.Builder
vecToBuilder_ !prefix !separator !postfix showFct = \vec -> prefix <>
  VG.foldr
  (\ a rest !prefx -> prefx <> (showFct a <> rest separator))
  (const postfix) vec mempty

IL(evalVals) :: [a] -> [a]
evalVals xs = build $ \c n -> foldr (c $!) n xs
IL(forceVals) :: (NFData a) => [a] -> [a]
forceVals xs = build $ \c n -> foldr (c $!!) n xs

IL(readLnWith) :: StateT BS.ByteString Maybe a -> IO a
readLnWith parser = fromJust . evalStateT parser <$> BS.getLine
IL(readContentWith) :: StateT BSL.ByteString Maybe a -> IO a
readContentWith parser = fromJust . evalStateT parser <$> BSL.getContents

IL(getVecGLn) :: (VG.Vector v a) =>
  Int -> StateT BS.ByteString Maybe a -> IO (v a)
getVecGLn n s = VG.unfoldrN n (runStateT s) <$> BS.getLine
IL(getVecGRest) :: (VG.Vector v a) =>
  Int -> StateT BSL.ByteString Maybe a -> IO (v a)
getVecGRest n s = VG.unfoldrN n (runStateT s) <$> BSL.getContents
IL(getVecLn) :: Int -> StateT BS.ByteString Maybe a -> IO (V.Vector a)
getVecLn = getVecGLn
IL(getVecRest) :: Int -> StateT BSL.ByteString Maybe a -> IO (V.Vector a)
getVecRest = getVecGRest
IL(getVecULn) :: (VU.Unbox a) =>
  Int -> StateT BS.ByteString Maybe a -> IO (VU.Vector a)
getVecULn = getVecGLn
IL(getVecURest) :: (VU.Unbox a) =>
  Int -> StateT BSL.ByteString Maybe a -> IO (VU.Vector a)
getVecURest = getVecGRest

IL(ord8) :: Char -> Word8
ord8 = fromIntegral . fromEnum
IL(chr8) :: Word8 -> Char
chr8 = toEnum . fromIntegral

{-# INLINE rVecGExactN #-}
rVecGExactN :: (VG.Vector v a)
  => Int
  -> StateT s Maybe a
  -> StateT s Maybe (v a)
rVecGExactN n act = StateT $ \s0 -> runST $ do
  res <- VGM.new n
  let go !i s | i >= n = Just . (,s) <$> VG.unsafeFreeze res
      go !i s1 = case runStateT act s1 of
        Nothing -> return Nothing
        Just (a, s2) -> do
          VGM.unsafeWrite res i a
          go (i+1) s2
  go 0 s0

{-# INLINE rVecUExactN #-}
rVecUExactN :: (VU.Unbox a)
  => Int
  -> StateT s Maybe a
  -> StateT s Maybe (VU.Vector a)
rVecUExactN = rVecGExactN


class AtCoderIParsed bytestring where
  rInt :: StateT bytestring Maybe Int
  rInteger :: StateT bytestring Maybe Integer
  rStr :: MonadState bytestring m => m BS.ByteString
  rChar :: StateT bytestring Maybe Char
  rCharW :: StateT bytestring Maybe Word8
  dropSpecial :: MonadState bytestring m => m ()

skipSpecial
  :: (AtCoderIParsed bytestring, MonadState bytestring m)
  => m a -> m a
{-# INLINE skipSpecial #-}
skipSpecial = (dropSpecial *>)

rInt1 :: AtCoderIParsed bytestring => StateT bytestring Maybe Int
{-# INLINE rInt1 #-}
rInt1 = subtract 1 <$> rInt

rInteger1 :: AtCoderIParsed bytestring => StateT bytestring Maybe Integer
{-# INLINE rInteger1 #-}
rInteger1 = subtract 1 <$> rInteger

instance AtCoderIParsed BS.ByteString where
  {-# INLINE rInt #-}
  rInt = skipSpecial $ StateT BS.readInt
  {-# INLINE rInteger #-}
  rInteger = skipSpecial $ StateT BS.readInteger
  {-# INLINE rStr #-}
  rStr = skipSpecial $ state $ BSW.span (>= ord8 '!')
  {-# INLINE rChar #-}
  rChar = StateT BS.uncons
  {-# INLINE rCharW #-}
  rCharW = StateT BSW.uncons
  {-# INLINE dropSpecial #-}
  dropSpecial = modify $ BSW.dropWhile (< ord8 '!')


instance AtCoderIParsed BSL.ByteString where
  {-# INLINE rInt #-}
  rInt = skipSpecial $ StateT BSL.readInt
  {-# INLINE rInteger #-}
  rInteger = skipSpecial $ StateT BSL.readInteger
  {-# INLINE rStr #-}
  rStr = skipSpecial $ BSL.toStrict <$> state (BSLW.span (>= ord8 '!'))
  {-# INLINE rChar #-}
  rChar = StateT BSL.uncons
  {-# INLINE rCharW #-}
  rCharW = StateT BSLW.uncons
  {-# INLINE dropSpecial #-}
  dropSpecial = modify $ BSLW.dropWhile (< ord8 '!')

IL(linToMat) :: (VG.Vector v a) => Int -> Int -> v a -> V.Vector (v a)
linToMat h w lvec = vEvalElemsId $ V.generate h (\i -> VG.slice (i*w) w lvec)

IL(mLinToMat) :: (VGM.MVector v a) => Int -> Int -> v s a -> V.Vector (v s a)
mLinToMat h w lvec = vEvalElemsId $ V.generate h (\i -> VGM.slice (i*w) w lvec)
  
IL(unsafeAddrToSVec) :: Int -> Addr# -> VS.Vector Word8
unsafeAddrToSVec n addr
  = (`VS.unsafeFromForeignPtr0` n)
    $ unsafeDupablePerformIO
    $ newForeignPtr_ $ Ptr addr

IL(vEvalElemsId) :: (VG.Vector v a) => v a -> v a
vEvalElemsId = vMapFoldl (\ !_ !x -> (x,())) ()

IL(vEvalElems) :: (VG.Vector v a) => v a -> ()
vEvalElems = VG.foldl' (\ !_ !_ -> ()) () 

IL(vMapFoldl) :: (VG.Vector v b, VG.Vector v c) =>
  (a -> b -> (c,a)) -> a -> v b -> v c
vMapFoldl f a
  = VG.unstream . VFB.inplace (streamMapFoldl f a) id . VG.stream

streamMapFoldl :: (Functor m) =>
  (a -> b -> (c,a)) -> a -> VFSM.Stream m b -> VFSM.Stream m c
{-# INLINE_FUSED streamMapFoldl #-}
streamMapFoldl f a (VFSM.Stream step s) = VFSM.Stream step1 (a,s)
  where
    {-# INLINE_INNER step1 #-}
    step1 (a0,s0) =  (<$> step s0) $ \r -> case r of
      VFSM.Yield b s1 -> case f a0 b of (c,a1) -> VFSM.Yield c (a1,s1)
      VFSM.Skip    s1 -> VFSM.Skip (a0,s1)
      VFSM.Done       -> VFSM.Done

IL(svecToBS) :: VS.Vector Word8 -> BS.ByteString
svecToBS vec = BSU.fromForeignPtr ptr 0 len
  where (ptr, len) = VS.unsafeToForeignPtr0 vec

IL(vLength) :: VG.Vector v a => v a -> Int
vLength = VFB.length . VG.stream

unlessM, whenM :: (Monad m) => m Bool -> m () -> m ()
IL(whenM) = (. flip when) . (>>=)
IL(unlessM) = (. flip unless) . (>>=)


wrA :: (MArray a e m, A.Ix i) => a i e -> i -> e -> m ()
IL(wrA) = A.writeArray
rdA :: (MArray a e m, A.Ix i) => a i e -> i -> m e
IL(rdA) = A.readArray
mdA :: (MArray a b m, A.Ix i) => a i b -> (b -> b) -> i -> m (b, b)
IL(mdA) = \arr f !i -> do
  ai <- rdA arr i
  let fai = f ai 
  wrA arr i fai
  return (ai,fai)
mdA' :: (MArray a b m, A.Ix i) => a i b -> (b -> b) -> i -> m (b, b)
{-# INLINE mdA' #-}
mdA' = \arr f !i -> do
  !ai <- rdA arr i
  let !fai = f ai
  wrA arr i fai
  return (ai,fai)
swapA :: (MArray a e m, A.Ix i) => a i e -> i -> i -> m ()
IL(swapA) = \arr !i !j -> do
  ai <- rdA arr i
  wrA arr i =<< rdA arr j
  wrA arr j ai

#define D(f,r,d)\
  IL(f) :: Integral a=>a->d; f=fromIntegral;\
  IL(r) :: String->d; r=read
#define C(f,r,g,h,d) D(f,r,d);\
  g,h :: RealFrac a=>a->d; IL(g)=floor; IL(h)=ceiling
C(_toInteger_,readInteger,floorInteger,ceilInteger,Integer)
C(toInt,readInt,floorInt,ceilInt,Int)
C(toI8,readI8,floorI8,ceilI8,Int8)
C(toI16,readI16,floorI16,ceilI16,Int16)
C(toI32,readI32,floorI32,ceilI32,Int32)
C(toI64,readI64,floorI64,ceilI64,Int64)
C(toWord,readWord,floorWord,ceilWord,Word)
C(toW8,readW8,floorW8,ceilW8,Word8)
C(toW16,readW16,floorW16,ceilW16,Word16)
C(toW32,readW32,floorW32,ceilW32,Word32)
C(toW64,readW64,floorW64,ceilW64,Word64)
D(toDouble,readDouble,Double)
D(toFloat,readFloat,Float)
#undef D
#undef C

#define TS(f,a,m,s,init)\
  IL(f) :: forall e i s. (C(a,m) A.Ix i) => (i,i) -> init m (a i e); f
#define N(f,g,h,s,a,m)\
  TS(f,a,m,s,e->)=A.newArray;\
  TS(g,a,m,s,)=A.newArray_;\
  TS(h,a,m,s,[e]->)=A.newListArray
#define C(a,m)
N(newIOA,newIOA_,newIOAL,,IOArray,IO)
N(newSTA,newSTA_,newSTAL,s,(STArray s),(ST s))
#undef C
#define C(a,m) MArray a e m, 
N(newIOUA,newIOUA_,newIOUAL,,IOUArray,IO)
N(newSTUA,newSTUA_,newSTUAL,s,(STUArray s),(ST s))
#undef C
#undef N
#undef TS

#undef IL

Submission Info

Judge Result