text:
{-# LANGUAGE TypeFamilies, FlexibleContexts, TypeSynonymInstances, ExistentialQuantification, DeriveDataTypeable, FlexibleInstances, UndecidableInstances #-}

module Data.String.Class
    ( Stringy
    , StringCells(..)
    , StringCell(..)
    , StringRWIO(..)
    , ConvGenString(..)
    , ConvString(..)
    , ConvStrictByteString(..)
    , ConvLazyByteString(..)
    , ConvText(..)
    , GenString(..)
    , GenStringDefault
    ) where

import Prelude hiding (head, tail, last, init, take, drop, length, null, concat, putStr, getContents)
import Control.Applicative hiding (empty)
import qualified Data.ByteString as S
import qualified Data.ByteString.Char8 as SC
import qualified Data.ByteString.Internal as BI
import qualified Data.ByteString.Lazy as L
import qualified Data.ByteString.Lazy.Char8 as LC
import Data.Int
import qualified Data.List as List
import Data.Semigroup
import Data.Monoid hiding ((<>))
import Data.String (IsString)
import qualified Data.String
import Data.Tagged
import qualified Data.Text as T
import qualified Data.Text.Encoding as TE
import qualified Data.Text.Encoding.Error as TEE
import qualified Data.Text.IO as T
import qualified Data.Text.Lazy as LT
import qualified Data.Text.Lazy.Encoding as LTE
import qualified Data.Text.Lazy.IO as LT
import Data.Typeable
import Data.Word
import qualified System.IO as IO

-- | String super class
class    (StringCells s, StringRWIO s) => Stringy s
instance (StringCells s, StringRWIO s) => Stringy s

-- | Minimal complete definition: StringCellChar; StringCellAltChar; toStringCells; fromStringCells; toMainChar; toAltChar; cons; snoc; either all of head, tail, last, and init, or all of uncons and unsnoc; take, take64 or genericTake; drop, drop64, or genericDrop; and length, length64, or genericLength
class (Eq s, Monoid s, IsString s, Typeable s, StringCell (StringCellChar s), StringCell (StringCellAltChar s), ConvGenString s, ConvString s, ConvStrictByteString s, ConvLazyByteString s, ConvText s, ConvLazyText s) => StringCells s where
    type StringCellChar s
    type StringCellAltChar s

    toStringCells   :: (StringCells s2) => s  -> s2
    fromStringCells :: (StringCells s2) => s2 -> s

    infixr 9 `cons`
    infixr 9 `uncons`
    infixr 9 `altCons`
    infixr 9 `altUncons`
    cons      :: StringCellChar s -> s -> s
    uncons    :: s -> (StringCellChar s, s)
    snoc      :: s -> StringCellChar s -> s
    unsnoc    :: s -> (s, StringCellChar s)
    altCons   :: StringCellAltChar s -> s -> s
    altUncons :: s -> (StringCellAltChar s, s)
    altSnoc   :: s -> StringCellAltChar s -> s
    altUnsnoc :: s -> (s, StringCellAltChar s)

    toMainChar :: (StringCell c) => c -> Tagged s (StringCellChar s)
    toAltChar  :: (StringCell c) => c -> Tagged s (StringCellAltChar s)

    -- | Append two strings
    infixr 9 `append`
    append :: s -> s -> s
    concat :: [s] -> s

    empty :: s
    null :: s -> Bool

    head :: s -> StringCellChar s
    tail :: s -> s
    last :: s -> StringCellChar s
    init :: s -> s
    altHead :: s -> StringCellAltChar s
    altLast :: s -> StringCellAltChar s

    -- | Construction of a string; implementations should behave safely with incorrect lengths
    --
    -- The default implementation of 'unfoldr' is independent from that of 'altUnfoldr',
    -- as well as 'unfoldrN' as and 'altUnfoldrN'.
    unfoldr       ::          (a -> Maybe (StringCellChar    s, a)) -> a -> s
    altUnfoldr    ::          (a -> Maybe (StringCellAltChar s, a)) -> a -> s
    unfoldrN      :: Int   -> (a -> Maybe (StringCellChar    s, a)) -> a -> s
    altUnfoldrN   :: Int   -> (a -> Maybe (StringCellAltChar s, a)) -> a -> s
    unfoldrN64    :: Int64 -> (a -> Maybe (StringCellChar    s, a)) -> a -> s
    altUnfoldrN64 :: Int64 -> (a -> Maybe (StringCellAltChar s, a)) -> a -> s

    unfoldr f b =
        case f b of
            (Just (a, new_b)) -> a `cons` unfoldr f new_b
            (Nothing)         -> empty

    altUnfoldr f b =
        case f b of
            (Just (a, new_b)) -> a `altCons` altUnfoldr f new_b
            (Nothing)         -> empty
    unfoldrN    = const unfoldr
    altUnfoldrN = const altUnfoldr

    unfoldrN64 l f z = unfoldrN (fromIntegral l) f z

    altUnfoldrN64 l f z = altUnfoldrN (fromIntegral l) f z

    -- | Get the character at the given position
    --
    -- Just like 'drop', 'drop64', and the variants of those functions, the
    -- default definitions of these three variants are independent of each
    -- other, and are defined in terms of 'head' and 'tail', which can be
    -- inefficient.
    index   :: s -> Int   -> StringCellChar s
    index64 :: s -> Int64 -> StringCellChar s
    -- | Index a string at any location
    --
    -- Just like the other 'generic' functions of this module, this function
    -- can be significantly slower than 'index', since the function must be
    -- able to support arbitrarily large indices.  Consider using 'index' or
    -- 'index64', even if you need to coerce the index to an 'Int'.
    genericIndex :: (Integral i) => s -> i -> StringCellChar s

    take        :: Int -> s -> s
    take64      :: Int64 -> s -> s
    genericTake :: (Integral i) => i -> s -> s
    drop        :: Int -> s -> s
    drop64      :: Int64 -> s -> s
    genericDrop :: (Integral i) => i -> s -> s

    length        :: s -> Int
    length64      :: s -> Int64
    genericLength :: (Integral i) => s -> i

    safeUncons        :: s -> Maybe ((StringCellChar s), s)
    safeUnsnoc        :: s -> Maybe (s, (StringCellChar s))
    safeAltUncons     :: s -> Maybe ((StringCellAltChar s), s)
    safeAltUnsnoc     :: s -> Maybe (s, (StringCellAltChar s))
    safeHead          :: s -> Maybe (StringCellChar s)
    safeTail          :: s -> Maybe s
    safeLast          :: s -> Maybe (StringCellChar s)
    safeInit          :: s -> Maybe s
    safeAltHead       :: s -> Maybe (StringCellAltChar s)
    safeAltLast       :: s -> Maybe (StringCellAltChar s)
    safeIndex         :: s -> Int   -> Maybe (StringCellChar s)
    safeIndex64       :: s -> Int64 -> Maybe (StringCellChar s)
    safeGenericIndex  :: (Integral i) => s -> i -> Maybe (StringCellChar s)
    safeTake          :: Int -> s -> Maybe s
    safeTake64        :: Int64 -> s -> Maybe s
    safeGenericTake   :: (Integral i) => i -> s -> Maybe s
    safeDrop          :: Int -> s -> Maybe s
    safeDrop64        :: Int64 -> s -> Maybe s
    safeGenericDrop   :: (Integral i) => i -> s -> Maybe s
    safeUncons2       :: s -> Maybe ((StringCellChar s), (StringCellChar s), s)
    safeUncons3       :: s -> Maybe ((StringCellChar s), (StringCellChar s), (StringCellChar s), s)
    safeUncons4       :: s -> Maybe ((StringCellChar s), (StringCellChar s), (StringCellChar s), (StringCellChar s), s)

    infixr 9 `cons2`
    infixr 9 `cons3`
    infixr 9 `cons4`
    infixr 9 `uncons2`
    infixr 9 `uncons3`
    infixr 9 `uncons4`
    cons2   :: StringCellChar s -> StringCellChar s -> s -> s
    cons3   :: StringCellChar s -> StringCellChar s -> StringCellChar s -> s -> s
    cons4   :: StringCellChar s -> StringCellChar s -> StringCellChar s -> StringCellChar s -> s -> s
    uncons2 :: s -> (StringCellChar s, StringCellChar s, s)
    uncons3 :: s -> (StringCellChar s, StringCellChar s, StringCellChar s, s)
    uncons4 :: s -> (StringCellChar s, StringCellChar s, StringCellChar s, StringCellChar s, s)

    altCons c s = cons (s `untagTypeOf` toMainChar c) s
    altSnoc s c = snoc s (s `untagTypeOf` toMainChar c)
    altUncons s = (\ ~(a, s') -> (s `untagTypeOf` toAltChar a, s')) $ uncons s
    altUnsnoc s = (\ ~(s', a) -> (s', s `untagTypeOf` toAltChar a)) $ unsnoc s

    append = mappend
    concat = mconcat
    empty  = mempty
    null   = (== mempty)

    head = fst . uncons
    tail = snd . uncons
    last = snd . unsnoc
    init = fst . unsnoc
    altHead s = (s `untagTypeOf`) . toAltChar . head $ s
    altLast s = (s `untagTypeOf`) . toAltChar . last $ s

    index        s 0 = head s
    index        s n = (flip index $ pred n) . tail $ s
    index64      s 0 = head s
    index64      s n = (flip index64 $ pred n) . tail $ s
    genericIndex s 0 = head s
    genericIndex s n = (flip genericIndex $ pred n) . tail $ s

    take        n s = take64      (fromIntegral n) s
    take64      n s = genericTake (fromIntegral n  :: Integer) s
    genericTake n s = take        (fromIntegral n) s
    drop        n s = drop64      (fromIntegral n) s
    drop64      n s = genericDrop (fromIntegral n  :: Integer) s
    genericDrop n s = drop        (fromIntegral n) s

    length        = fromIntegral . length64
    length64      = (fromIntegral :: Integer -> Int64) . genericLength
    genericLength = fromIntegral . length

    {-
    -- More efficient default implementation provided above
    append a b = case safeUncons a of
        (Just (c, cs)) -> c `cons` append cs b
        (Nothing)      -> a

    concat = foldr append empty
    -}

    uncons s = (head s, tail s)
    unsnoc s = (init s, last s)

    cons2 a b s = a `cons` b `cons` s
    cons3 a b c s = a `cons` b `cons` c `cons` s
    cons4 a b c d s = a `cons` b `cons` c `cons` d `cons` s
    uncons2 s       =
        let (a, s')   = uncons s
            (b, s'')  = uncons s'
        in  (a, b, s'')
    uncons3 s       =
        let (a, s')   = uncons s
            (b, s'')  = uncons s'
            (c, s''') = uncons s''
        in  (a, b, c, s''')
    uncons4 s       =
        let (a, s')    = uncons s
            (b, s'')   = uncons s'
            (c, s''')  = uncons s''
            (d, s'''') = uncons s'''
        in  (a, b, c, d, s'''')

    safeUncons s
        | null s    = Nothing
        | otherwise = Just $ uncons s
    safeUnsnoc s
        | null s    = Nothing
        | otherwise = Just $ unsnoc s
    safeAltUncons s
        | null s    = Nothing
        | otherwise = Just $ altUncons s
    safeAltUnsnoc s
        | null s    = Nothing
        | otherwise = Just $ altUnsnoc s
    safeHead s
        | null s    = Nothing
        | otherwise = Just $ head s
    safeTail s
        | null s    = Nothing
        | otherwise = Just $ tail s
    safeLast s
        | null s    = Nothing
        | otherwise = Just $ last s
    safeInit s
        | null s    = Nothing
        | otherwise = Just $ init s
    safeAltHead s
        | null s    = Nothing
        | otherwise = Just $ altHead s
    safeAltLast s
        | null s    = Nothing
        | otherwise = Just $ altLast s
    safeIndex s n
        | length s <= n = Nothing
        | otherwise     = Just $ s `index` n
    safeIndex64 s n
        | length64 s <= n = Nothing
        | otherwise     = Just $ s `index64` n
    safeGenericIndex s n
        | genericLength s <= n = Nothing
        | otherwise            = Just $ s `genericIndex` n
    safeTake n s
        | n > length s = Nothing
        | otherwise    = Just $ take n s
    safeTake64 n s
        | n > length64 s = Nothing
        | otherwise      = Just $ take64 n s
    safeGenericTake n s
        | n > genericLength s = Nothing
        | otherwise           = Just $ genericTake n s
    safeDrop n s
        | n > length s = Nothing
        | otherwise    = Just $ drop n s
    safeDrop64 n s
        | n > length64 s = Nothing
        | otherwise      = Just $ drop64 n s
    safeGenericDrop n s
        | n > genericLength s = Nothing
        | otherwise           = Just $ genericDrop n s
    safeUncons2 s = do
        (a, s')    <- safeUncons s
        (b, s'')   <- safeUncons s'
        return (a, b, s'')
    safeUncons3 s = do
        (a, s')    <- safeUncons s
        (b, s'')   <- safeUncons s'
        (c, s''')  <- safeUncons s''
        return (a, b, c, s''')
    safeUncons4 s = do
        (a, s')    <- safeUncons s
        (b, s'')   <- safeUncons s'
        (c, s''')  <- safeUncons s''
        (d, s'''') <- safeUncons s'''
        return (a, b, c, d, s'''')

class StringCell c where
    toChar     :: c      -> Char
    toWord8    :: c      -> Word8
    toWord16   :: c      -> Word16
    toWord32   :: c      -> Word32
    toWord64   :: c      -> Word64
    fromChar   :: Char   -> c
    fromWord8  :: Word8  -> c
    fromWord16 :: Word16 -> c
    fromWord32 :: Word32 -> c
    fromWord64 :: Word64 -> c

class ConvGenString s where
    toGenString   :: s -> GenString
    fromGenString :: GenString -> s

class ConvString s where
    toString   :: s -> String
    fromString :: String -> s

class ConvStrictByteString s where
    toStrictByteString :: s -> S.ByteString
    fromStrictByteString :: S.ByteString -> s

class ConvLazyByteString s where
    toLazyByteString :: s -> L.ByteString
    fromLazyByteString :: L.ByteString -> s

class ConvText s where
    toText :: s -> T.Text
    fromText :: T.Text -> s

class ConvLazyText s where
    toLazyText :: s -> LT.Text
    fromLazyText :: LT.Text -> s

-- | Minimal complete definition: 'hGetContents', 'hGetLine', 'hPutStr', and 'hPutStrLn'
class StringRWIO s where
    --- Handles

    -- | Read n bytes *or* characters, depending on the implementation into a
    -- ByteString, directly from the specified Handle
    --
    -- Whether or not this function is lazy depends on the instance; laziness
    -- is preferred.
    hGetContents :: IO.Handle -> IO s

    -- | Read a single line from a handle
    hGetLine :: IO.Handle -> IO s

    -- | Write a string to a handle
    hPutStr :: IO.Handle -> s -> IO ()

    -- | Write a string to a handle, followed by a newline
    --
    -- N.B.: implementations might not define this atomically.  If the state
    -- of being atomic is necessary, one possible solution is to convert a
    -- string to an efficient type for which 'hPutStrLn' is atomic.
    hPutStrLn :: IO.Handle -> s -> IO ()

    --- Special cases for standard input and output

    -- | Take a function of type Text -> Text as its argument
    --
    -- The entire input from the standard input device is passed to this
    -- function as its argument, and the resulting string is output on the
    -- standard output device.
    interact :: (s -> s) -> IO ()
    interact f = putStr . f =<< getContents

    -- | Read all user input on 'stdin' as a single string
    getContents :: IO s
    getContents = hGetContents IO.stdin

    -- | Read a single line of user input from 'stdin'
    getLine :: IO s
    getLine = hGetLine IO.stdin

    -- | Write a string to 'stdout'
    putStr :: s -> IO ()
    putStr = hPutStr IO.stdout

    -- | Write a string to 'stdout', followed by a newline
    putStrLn :: s -> IO ()
    putStrLn = hPutStrLn IO.stdout

    ---

    -- | Read a file and returns the contents of the file as a string
    --
    -- Depending on the instance, this function might expect the file to be
    -- non-binary.  The default definition uses 'openFile' to open the file.
    readFile :: FilePath -> IO s
    readFile fn = hGetContents =<< IO.openFile fn IO.ReadMode

    -- | Write a string to a file
    --
    -- The file is truncated to zero length before writing begins.
    -- The default definition uses 'withFile' to open the file.
    writeFile :: FilePath -> s -> IO ()
    writeFile fn s = IO.withFile fn IO.WriteMode $ \hdl -> hPutStr hdl s

    -- | Write a string to the end of a file
    --
    -- The default definition uses 'withFile' to open the file.
    appendFile :: FilePath -> s -> IO ()
    appendFile fn s = IO.withFile fn IO.AppendMode $ \hdl -> hPutStr hdl s

instance StringCells String where
    type StringCellChar    String = Char
    type StringCellAltChar String = Char

    toStringCells   = fromString
    fromStringCells = toString

    length = List.genericLength
    empty  = []
    null   = List.null
    cons          = (:)
    snoc s c      = s ++ [c]
    safeUncons (x:xs) = Just (x, xs)
    safeUncons _      = Nothing
    uncons (x:xs) = (x, xs)
    uncons _      = error "String.uncons: null string"
    toMainChar    = Tagged . toChar
    toAltChar     = Tagged . toChar
    head          = List.head
    tail          = List.tail
    init          = List.init
    last          = List.last
    unfoldr       = List.unfoldr
    index         = (List.!!)
    index64 s     = index s . fromIntegral
    genericIndex  = List.genericIndex
    take          = List.take
    genericTake   = List.genericTake
    drop          = List.drop
    genericDrop   = List.genericDrop
    append        = (List.++)
    concat        = List.concat

instance StringCells S.ByteString where
    type StringCellChar    S.ByteString = Word8
    type StringCellAltChar S.ByteString = Char

    toStringCells   = fromStrictByteString
    fromStringCells = toStrictByteString

    length          = S.length
    empty           = S.empty
    null            = S.null
    cons            = S.cons
    snoc            = S.snoc
    safeUncons      = S.uncons
    uncons          = maybe (error "StringCells.Data.ByteString.ByteString.uncons: string is null") id . safeUncons
    toMainChar      = Tagged . toWord8
    toAltChar       = Tagged . toChar
    head            = S.head
    tail            = S.tail
    init            = S.init
    last            = S.last
    unfoldr         = S.unfoldr
    altUnfoldr      = SC.unfoldr
    unfoldrN        = ((fst .) .) . S.unfoldrN
    altUnfoldrN     = ((fst .) .) . SC.unfoldrN
    index           = S.index
    index64 s       = index s . fromIntegral
    take            = S.take
    drop            = S.drop
    append          = S.append
    concat          = S.concat

instance StringCells L.ByteString where
    type StringCellChar    L.ByteString = Word8
    type StringCellAltChar L.ByteString = Char

    toStringCells   = fromLazyByteString
    fromStringCells = toLazyByteString

    length64        = L.length
    length          = fromIntegral . length64
    empty           = L.empty
    null            = L.null
    cons            = L.cons
    snoc            = L.snoc
    safeUncons      = L.uncons
    uncons          = maybe (error "StringCells.Data.ByteString.Lazy.ByteString.uncons: string is null") id . safeUncons
    toMainChar      = Tagged . toWord8
    toAltChar       = Tagged . toChar
    head            = L.head
    tail            = L.tail
    init            = L.init
    last            = L.last
    unfoldr         = L.unfoldr
    altUnfoldr      = LC.unfoldr
    index s         = index64 s . fromIntegral
    index64         = L.index
    take64          = L.take
    drop64          = L.drop
    append          = L.append
    concat          = L.concat

instance StringCells T.Text where
    type StringCellChar    T.Text = Char
    type StringCellAltChar T.Text = Char

    toStringCells   = fromText
    fromStringCells = toText

    length          = T.length
    empty           = T.empty
    null            = T.null
    cons            = T.cons
    safeUncons      = T.uncons
    uncons          = maybe (error "StringCells.Data.Text.Text.uncons: string is null") id . safeUncons
    snoc            = T.snoc
    altSnoc         = T.snoc
    toMainChar      = Tagged . toChar
    toAltChar       = Tagged . toChar
    head            = T.head
    tail            = T.tail
    init            = T.init
    last            = T.last
    unfoldr         = T.unfoldr
    altUnfoldr      = T.unfoldr
    unfoldrN        = T.unfoldrN
    altUnfoldrN     = T.unfoldrN
    index           = T.index
    index64 s       = index s . fromIntegral
    append          = T.append
    concat          = T.concat

instance StringCells LT.Text where
    type StringCellChar    LT.Text = Char
    type StringCellAltChar LT.Text = Char

    toStringCells   = fromLazyText
    fromStringCells = toLazyText

    length64        = LT.length
    empty           = LT.empty
    null            = LT.null
    cons            = LT.cons
    safeUncons      = LT.uncons
    uncons          = maybe (error "StringCells.Data.Text.Lazy.Text.uncons: string is null") id . safeUncons
    snoc            = LT.snoc
    altSnoc         = LT.snoc
    toMainChar      = Tagged . toChar
    toAltChar       = Tagged . toChar
    head            = LT.head
    tail            = LT.tail
    init            = LT.init
    last            = LT.last
    unfoldr         = LT.unfoldr
    altUnfoldr      = LT.unfoldr
    unfoldrN64      = LT.unfoldrN
    altUnfoldrN64   = LT.unfoldrN
    index s         = index64 s . fromIntegral
    index64         = LT.index
    append          = LT.append
    concat          = LT.concat

instance StringCell Char where
    toChar     = id
    toWord8    = BI.c2w
    toWord16   = fromIntegral . toWord8
    toWord32   = fromIntegral . toWord8
    toWord64   = fromIntegral . toWord8
    fromChar   = id
    fromWord8  = BI.w2c
    fromWord16 = BI.w2c . fromIntegral
    fromWord32 = BI.w2c . fromIntegral
    fromWord64 = BI.w2c . fromIntegral

instance StringCell Word8 where
    toChar     = BI.w2c
    toWord8    = id
    toWord16   = fromIntegral
    toWord32   = fromIntegral
    toWord64   = fromIntegral
    fromChar   = BI.c2w
    fromWord8  = id
    fromWord16 = fromIntegral
    fromWord32 = fromIntegral
    fromWord64 = fromIntegral

instance StringCell Word16 where
    toChar     = BI.w2c . fromIntegral
    toWord8    = fromIntegral
    toWord16   = id
    toWord32   = fromIntegral
    toWord64   = fromIntegral
    fromChar   = fromIntegral . BI.c2w
    fromWord8  = fromIntegral
    fromWord16 = id
    fromWord32 = fromIntegral
    fromWord64 = fromIntegral

instance StringCell Word32 where
    toChar     = BI.w2c . fromIntegral
    toWord8    = fromIntegral
    toWord16   = fromIntegral
    toWord32   = id
    toWord64   = fromIntegral
    fromChar   = fromIntegral . BI.c2w
    fromWord8  = fromIntegral
    fromWord16 = fromIntegral
    fromWord32 = id
    fromWord64 = fromIntegral

instance StringCell Word64 where
    toChar     = BI.w2c . fromIntegral
    toWord8    = fromIntegral
    toWord16   = fromIntegral
    toWord32   = fromIntegral
    toWord64   = id
    fromChar   = fromIntegral . BI.c2w
    fromWord8  = fromIntegral
    fromWord16 = fromIntegral
    fromWord32 = fromIntegral
    fromWord64 = id

instance ConvGenString GenString where
    toGenString   = id
    fromGenString = id

instance ConvGenString String where
    toGenString      = GenString
    fromGenString _s = case _s of
        (GenString _s) -> toStringCells _s

instance ConvGenString SC.ByteString where
    toGenString      = GenString
    fromGenString _s = case _s of
        (GenString _s) -> toStringCells _s

instance ConvGenString LC.ByteString where
    toGenString      = GenString
    fromGenString _s = case _s of
        (GenString _s) -> toStringCells _s

instance ConvGenString T.Text where
    toGenString      = GenString
    fromGenString _s = case _s of
        (GenString _s) -> toStringCells _s

instance ConvGenString LT.Text where
    toGenString      = GenString
    fromGenString _s = case _s of
        (GenString _s) -> toStringCells _s

instance ConvString GenString where
    toString   = fromGenString
    fromString = toGenString

instance ConvString String where
    toString   = id
    fromString = id

instance ConvString SC.ByteString where
    toString   = SC.unpack
    fromString = SC.pack

instance ConvString LC.ByteString where
    toString   = LC.unpack
    fromString = LC.pack

instance ConvString T.Text where
    toString   = T.unpack
    fromString = T.pack

instance ConvString LT.Text where
    toString   = LT.unpack
    fromString = LT.pack

instance ConvStrictByteString GenString where
    toStrictByteString   = fromGenString
    fromStrictByteString = toGenString

instance ConvStrictByteString String where
    toStrictByteString   = SC.pack
    fromStrictByteString = SC.unpack

instance ConvStrictByteString S.ByteString where
    toStrictByteString   = id
    fromStrictByteString = id

instance ConvStrictByteString L.ByteString where
    toStrictByteString   = L.toStrict
    fromStrictByteString = toLazyByteString

instance ConvStrictByteString T.Text where
    toStrictByteString   = TE.encodeUtf8
    fromStrictByteString = toText

instance ConvStrictByteString LT.Text where
    toStrictByteString   = toStrictByteString . LTE.encodeUtf8
    fromStrictByteString = toLazyText

instance ConvLazyByteString GenString where
    toLazyByteString   = fromGenString
    fromLazyByteString = toGenString

instance ConvLazyByteString String where
    toLazyByteString   = LC.pack
    fromLazyByteString = LC.unpack

instance ConvLazyByteString S.ByteString where
    toLazyByteString   = L.fromStrict
    fromLazyByteString = toStrictByteString

instance ConvLazyByteString L.ByteString where
    toLazyByteString   = id
    fromLazyByteString = id

instance ConvLazyByteString T.Text where
    toLazyByteString   = toLazyByteString . toStrictByteString
    fromLazyByteString = toText

instance ConvLazyByteString LT.Text where
    toLazyByteString   = toLazyByteString . toStrictByteString
    fromLazyByteString = toLazyText

instance ConvText GenString where
    toText   = fromGenString
    fromText = toGenString

instance ConvText String where
    toText   = T.pack
    fromText = T.unpack

instance ConvText S.ByteString where
    toText   = TE.decodeUtf8With TEE.lenientDecode
    fromText = toStrictByteString

instance ConvText L.ByteString where
    toText   = toText . toStrictByteString
    fromText = toLazyByteString

instance ConvText T.Text where
    toText   = id
    fromText = id

instance ConvText LT.Text where
    toText   = LT.toStrict
    fromText = toLazyText

instance ConvLazyText GenString where
    toLazyText   = fromGenString
    fromLazyText = toGenString

instance ConvLazyText String where
    toLazyText   = LT.pack
    fromLazyText = LT.unpack

instance ConvLazyText S.ByteString where
    toLazyText   = LTE.decodeUtf8With TEE.lenientDecode . toLazyByteString
    fromLazyText = toStrictByteString

instance ConvLazyText L.ByteString where
    toLazyText   = LTE.decodeUtf8With TEE.lenientDecode
    fromLazyText = toLazyByteString

instance ConvLazyText T.Text where
    toLazyText   = LT.fromStrict
    fromLazyText = fromLazyText

instance ConvLazyText LT.Text where
    toLazyText   = id
    fromLazyText = id

-- |
--
-- This is minimally defined with 'GenStringDefault'.
instance StringRWIO GenString where
    hGetContents h = genStringFromConConv <$> hGetContents h

    hGetLine h = genStringFromConConv <$> hGetLine h

    hPutStr h s = hPutStr h (genStringConConv s)

    hPutStrLn h s = hPutStrLn h (genStringConConv s)

-- | Type-restricted string conversion used by 'GenString's instance definition for 'StringRWIO'
genStringConConv :: GenString -> GenStringDefault
genStringConConv = toStringCells

-- | Type-restricted string conversion used by 'GenString's instance definition for 'StringRWIO'
genStringFromConConv :: GenStringDefault -> GenString
genStringFromConConv = toStringCells

-- |
--
-- See 'System.IO for documentation of behaviour.
instance StringRWIO String where
    hGetContents = IO.hGetContents

    hGetLine     = IO.hGetLine

    hPutStr      = IO.hPutStr

    hPutStrLn    = IO.hPutStrLn

    interact     = IO.interact

    getContents  = IO.getContents

    getLine      = IO.getLine

    putStr       = IO.putStr

    putStrLn     = IO.putStrLn

    readFile     = IO.readFile

    writeFile    = IO.writeFile

    appendFile   = IO.appendFile

-- |
--
-- See 'Data.ByteString' for documentation of behaviour.
instance StringRWIO S.ByteString where
    hGetContents = S.hGetContents

    hGetLine     = S.hGetLine

    hPutStr      = S.hPutStr

    hPutStrLn    = SC.hPutStrLn

    interact     = S.interact

    getContents  = S.getContents

    getLine      = S.getLine

    putStr       = S.putStr

    putStrLn     = SC.putStrLn

    readFile     = S.readFile

    writeFile    = S.writeFile

    appendFile   = S.appendFile

-- |
--
-- See 'Data.ByteString.Lazy' for documentation of behaviour.
--
-- 'hGetLine' and 'getLine' are defined in terms of 'toStringCells' and the equivalent methods of 'Data.ByteString'.
-- 'hPutStrLn' is defined non-atomically: it is defined as an action that puts the string and then separately puts a newline character string.
instance StringRWIO L.ByteString where
    hGetContents = L.hGetContents

    hGetLine     = (toStringCells <$>) . S.hGetLine

    hPutStr      = L.hPutStr

    hPutStrLn h  = (>> hPutStr h ((toStringCells :: String -> L.ByteString) ['\n'])) . hPutStr h

    interact     = L.interact

    getContents  = L.getContents

    getLine      = toStringCells <$> S.getLine

    putStr       = L.putStr

    putStrLn     = LC.putStrLn

    readFile     = L.readFile

    writeFile    = L.writeFile

    appendFile   = L.appendFile

-- |
--
-- See 'Data.Text.IO' for documentation of behaviour.
instance StringRWIO T.Text where
    hGetContents = T.hGetContents

    hGetLine     = T.hGetLine

    hPutStr      = T.hPutStr

    hPutStrLn    = T.hPutStrLn

    interact     = T.interact

    getContents  = T.getContents

    getLine      = T.getLine

    putStr       = T.putStr

    putStrLn     = T.putStrLn

    readFile     = T.readFile

    writeFile    = T.writeFile

    appendFile   = T.appendFile

-- |
--
-- See 'Data.Text.Lazy.IO' for documentation of behaviour.
instance StringRWIO LT.Text where
    hGetContents = LT.hGetContents

    hGetLine     = LT.hGetLine

    hPutStr      = LT.hPutStr

    hPutStrLn    = LT.hPutStrLn

    interact     = LT.interact

    getContents  = LT.getContents

    getLine      = LT.getLine

    putStr       = LT.putStr

    putStrLn     = LT.putStrLn

    readFile     = LT.readFile

    writeFile    = LT.writeFile

    appendFile   = LT.appendFile

-- | Polymorphic container of a string
--
-- When operations take place on multiple 'GenString's, they are first
-- converted to the type 'GenStringDefault', which are lazy bytestrings,
-- whenever absolutely necessary (which includes testing for equality,
-- appending strings, concatenating lists of strings, empty strings with
-- 'empty', and unfolding), making them the most efficient type for this
-- polymorphic container.
data GenString = forall s. (Stringy s) => GenString {gen_string :: s}
    deriving (Typeable)

toGenDefaultString :: (Stringy s) => s -> GenStringDefault
toGenDefaultString = toStringCells

instance Eq GenString where
    _a == _b = case (_a, _b) of
        ((GenString _a), (GenString _b)) -> toGenDefaultString _a == toGenDefaultString _b
    _a /= _b = case (_a, _b) of
        ((GenString _a), (GenString _b)) -> toGenDefaultString _a /= toGenDefaultString _b

instance IsString GenString where
    fromString = GenString

instance Semigroup GenString where
    (<>) a b = case (a, b) of
        (GenString _a, GenString _b) -> GenString $ append (toGenDefaultString _a) (toGenDefaultString _b)

instance Monoid GenString where
    mempty  = GenString $ (empty :: GenStringDefault)
    mappend = (<>)
    mconcat ss = GenString $ concat . map toGenDefaultString $ ss

instance StringCells GenString where
    -- These associated types were rather arbitrarily chosen
    type StringCellChar GenString = Char
    type StringCellAltChar GenString = Word8

    toStringCells   = fromGenString
    fromStringCells = toGenString

    cons c _s = case _s of
        (GenString _s) -> GenString $ cons (_s `untagTypeOf` toMainChar c) _s
    uncons _s = case _s of
        (GenString _s) -> let (c, s') = uncons _s
                          in  (genStringPhantom `untagTypeOf` toMainChar c, GenString s')
    snoc _s c = case _s of
        (GenString _s) -> GenString $ snoc _s (_s `untagTypeOf` toMainChar c)
    unsnoc _s = case _s of
        (GenString _s) -> let (s', c) = unsnoc _s
                          in  (GenString s', genStringPhantom `untagTypeOf` toMainChar c)

    altCons c _s = case _s of
        (GenString _s) -> GenString $ cons (fromWord8 c) _s
    altUncons _s = case _s of
        (GenString _s) -> let (c, s') = uncons _s
                          in  (genStringPhantom `untagTypeOf` toAltChar c, GenString s')
    altSnoc _s c = case _s of
        (GenString _s) -> GenString $ snoc _s (fromWord8 c)
    altUnsnoc _s = case _s of
        (GenString _s) -> let (s', c) = unsnoc _s
                          in  (GenString s', genStringPhantom `untagTypeOf` toAltChar c)

    toMainChar = Tagged . toChar
    toAltChar  = Tagged . toWord8

    null _s = case _s of
        (GenString _s) -> null _s

    head _s = case _s of
        (GenString _s) -> genStringPhantom `untagTypeOf` toMainChar (head _s)
    tail _s = case _s of
        (GenString _s) -> GenString $ tail _s
    last _s = case _s of
        (GenString _s) -> genStringPhantom `untagTypeOf` toMainChar (last _s)
    init _s = case _s of
        (GenString _s) -> GenString $ init _s
    altHead _s = case _s of
        (GenString _s) -> genStringPhantom `untagTypeOf` toAltChar (head _s)
    altLast _s = case _s of
        (GenString _s) -> genStringPhantom `untagTypeOf` toAltChar (last _s)

    unfoldr       f z = GenString $ (altUnfoldr    f z  :: GenStringDefault)
    altUnfoldr    f z = GenString $ (unfoldr       f z  :: GenStringDefault)
    unfoldrN    n f z = GenString $ (altUnfoldrN n f z  :: GenStringDefault)
    altUnfoldrN n f z = GenString $ (unfoldrN    n f z  :: GenStringDefault)

    index _s i = case _s of
        (GenString _s) -> genStringPhantom `untagTypeOf` toMainChar (index _s i)
    index64 _s i = case _s of
        (GenString _s) -> genStringPhantom `untagTypeOf` toMainChar (index64 _s i)
    genericIndex _s i = case _s of
        (GenString _s) -> genStringPhantom `untagTypeOf` toMainChar (genericIndex _s i)

    take n _s = case _s of
        (GenString _s) -> GenString $ take n _s
    take64 n _s = case _s of
        (GenString _s) -> GenString $ take64 n _s
    genericTake n _s = case _s of
        (GenString _s) -> GenString $ genericTake n _s
    drop n _s = case _s of
        (GenString _s) -> GenString $ drop n _s
    drop64 n _s = case _s of
        (GenString _s) -> GenString $ drop64 n _s
    genericDrop n _s = case _s of
        (GenString _s) -> GenString $ genericDrop n _s

    length _s = case _s of
        (GenString _s) -> length _s
    length64 _s = case _s of
        (GenString _s) -> length64 _s
    genericLength _s = case _s of
        (GenString _s) -> genericLength _s

    safeUncons _s = case _s of
        (GenString _s) -> (\(c, s') -> (genStringPhantom `untagTypeOf` toMainChar c, GenString s')) <$> safeUncons _s
    safeUnsnoc _s = case _s of
        (GenString _s) -> (\(s', c) -> (GenString s', genStringPhantom `untagTypeOf` toMainChar c)) <$> safeUnsnoc _s
    safeAltUncons _s = case _s of
        (GenString _s) -> (\(c, s') -> (genStringPhantom `untagTypeOf` toAltChar c, GenString s')) <$> safeAltUncons _s
    safeAltUnsnoc _s = case _s of
        (GenString _s) -> (\(s', c) -> (GenString s', genStringPhantom `untagTypeOf` toAltChar c)) <$> safeAltUnsnoc _s
    safeHead _s = case _s of
        (GenString _s) -> (genStringPhantom `untagTypeOf`) . toMainChar <$> safeHead _s
    safeTail _s = case _s of
        (GenString _s) -> GenString <$> safeTail _s
    safeLast _s = case _s of
        (GenString _s) -> (genStringPhantom `untagTypeOf`) . toMainChar <$> safeLast _s
    safeInit _s = case _s of
        (GenString _s) -> GenString <$> safeInit _s
    safeAltHead _s = case _s of
        (GenString _s) -> (genStringPhantom `untagTypeOf`) . toAltChar  <$> safeAltHead _s
    safeAltLast _s = case _s of
        (GenString _s) -> (genStringPhantom `untagTypeOf`) . toAltChar  <$> safeAltLast _s
    safeIndex _s i = case _s of
        (GenString _s) -> (genStringPhantom `untagTypeOf`) . toMainChar <$> safeIndex _s i
    safeIndex64 _s i = case _s of
        (GenString _s) -> (genStringPhantom `untagTypeOf`) . toMainChar <$> safeIndex64 _s i
    safeGenericIndex _s i = case _s of
        (GenString _s) -> (genStringPhantom `untagTypeOf`) . toMainChar <$> safeGenericIndex _s i
    safeTake n _s = case _s of
        (GenString _s) -> GenString <$> safeTake n _s
    safeTake64 n _s = case _s of
        (GenString _s) -> GenString <$> safeTake64 n _s
    safeGenericTake n _s = case _s of
        (GenString _s) -> GenString <$> safeGenericTake n _s
    safeDrop n _s = case _s of
        (GenString _s) -> GenString <$> safeDrop n _s
    safeDrop64 n _s = case _s of
        (GenString _s) -> GenString <$> safeDrop64 n _s
    safeGenericDrop n _s = case _s of
        (GenString _s) -> GenString <$> safeGenericDrop n _s
    safeUncons2 _s = case _s of
        (GenString _s) -> (\(a, b, s') -> (genStringPhantom `untagTypeOf` toMainChar a, genStringPhantom `untagTypeOf` toMainChar b, GenString s')) <$> safeUncons2 _s
    safeUncons3 _s = case _s of
        (GenString _s) -> (\(a, b, c, s') -> (genStringPhantom `untagTypeOf` toMainChar a, genStringPhantom `untagTypeOf` toMainChar b, genStringPhantom `untagTypeOf` toMainChar c, GenString s')) <$> safeUncons3 _s
    safeUncons4 _s = case _s of
        (GenString _s) -> (\(a, b, c, d, s') -> (genStringPhantom `untagTypeOf` toMainChar a, genStringPhantom `untagTypeOf` toMainChar b, genStringPhantom `untagTypeOf` toMainChar c, genStringPhantom `untagTypeOf` toMainChar d, GenString s')) <$> safeUncons4 _s

    cons2 a b _s = case _s of
        (GenString _s) -> GenString $ cons2 (_s `untagTypeOf` toMainChar a) (_s `untagTypeOf` toMainChar b) _s
    cons3 a b c _s = case _s of
        (GenString _s) -> GenString $ cons3 (_s `untagTypeOf` toMainChar a) (_s `untagTypeOf` toMainChar b) (_s `untagTypeOf` toMainChar c) _s
    cons4 a b c d _s = case _s of
        (GenString _s) -> GenString $ cons4 (_s `untagTypeOf` toMainChar a) (_s `untagTypeOf` toMainChar b) (_s `untagTypeOf` toMainChar c) (_s `untagTypeOf` toMainChar d) _s
    uncons2 _s = case _s of
        (GenString _s) -> let (a, b, s') = uncons2 _s
                          in  (genStringPhantom `untagTypeOf` toMainChar a, genStringPhantom `untagTypeOf` toMainChar b, GenString s')
    uncons3 _s = case _s of
        (GenString _s) -> let (a, b, c, s') = uncons3 _s
                          in  (genStringPhantom `untagTypeOf` toMainChar a, genStringPhantom `untagTypeOf` toMainChar b, genStringPhantom `untagTypeOf` toMainChar c, GenString s')
    uncons4 _s = case _s of
        (GenString _s) -> let (a, b, c, d, s') = uncons4 _s
                          in  (genStringPhantom `untagTypeOf` toMainChar a, genStringPhantom `untagTypeOf` toMainChar b, genStringPhantom `untagTypeOf` toMainChar c, genStringPhantom `untagTypeOf` toMainChar d, GenString s')

-- | Untag a type with a type restriction
--
-- The first argument is guaranteed to be ignored; thus the value 'undefined'
-- can be passed in its place.
untagTypeOf :: s -> Tagged s b -> b
untagTypeOf _ = untag

-- | Phantom, undefined value only used for convenience
--
-- Users should be careful that this value is never evaluated when using this.
genStringPhantom :: GenString
genStringPhantom = undefined

-- | This type is used by 'GenString' when a concrete string type is needed
type GenStringDefault = L.ByteString


text:
Eastside rallies late for 23-14 win
View and purchase photos of the game here.
Trailing 14-3 to the Jackson Red Devils after three quarters, the Eastside Eagles came off the deck to score 20 unanswered points and remain undefeated in the young 2012 season.
"Overall, a great effort," Eastside coach Rick Hurst said. "The kids never gave up and never gave in."
Both teams sputtered on offense early in the game, but Jackson finally mounted a drive late in the first quarter. Jackson quarterback Will Lane threw a 35-yard touchdown pass to Michael Finocchiaro who had an incredible catch made more amazing by the fact he was playing in his first ever high school game. Joe Brown kicked the extra point and Jackson led 7-0 with a handful of seconds left in the quarter.
The Eagles answered with a drive of their own highlighted by a 20-yard run by Alex Smith, but Colton Smith's field goal attempt was blocked. He got another shot moments later when Tre Cooper intercepted a pass. Smith's kick sailed over the crossbar with just inches to spare, making the score 7-3 in favor of Jackson.
The Eastside passing attack faltered for most of the game; the Eagles failed to connect on nine consecutive pass plays at one point. Penalties also slowed Eastside drives and kept them alive for Jackson.
"That's something we have to fix," coach Hurst said. "But the penalties seemed to even out as the game went on."
Jackson finally scored again with 43 seconds left in the third quarter after recovering an Eastside fumble at the Eagle 26-yard line.
Jackson stymied the next Eastside possession, but a roughing the punter penalty gave the Eagles new life near midfield. Two plays later Demario Terrell connected with Cameron Boyd for a 45-yard touchdown. Colton Smith's kick pulled Eastside to within four of the lead.
With the penalty bug now biting the Red Devils, Eastside took advantage of a pass interference call - which gave them a first down in Jackson territory - and Terrell connected with Chase Chancey for a 36-yard touchdown pass. The Red Devils blocked the extra-point, but Eastside now led 16-14.
An odd sequence of events unfolded next as Jackson fumbled the ball away at their own 26 and head coach Mike Parris made matters worse by incurring an unsportsmanlike conduct penalty. The Eagles had the ball with a first and goal at the seven, but after a sack and three penalties faced a fourth and what seemed like a furlong at midfield.
Jackson got the ball back, but Boyd picked off a pass and took it back for a touchdown to give Eastside a comfortable nine point lead.
"It's a huge lift for us," Hurst said. "We'll be in this position again later in the season, and we'll know we can come back.
PREP HOOPS: Eagles drop overtime thriller to Walnut Grove
PREP FOOTBALL: Eagles land 13 on All-Region teams
PREP FOOTBALL: Eagles fall to Jones County in state quarterfinals

redpajama_set_name: RedPajamaCommonCrawl


text:
Chatham Emergency Services celebrates 60 years of service
Published: Nov. 12, 2021 at 11:43 AM EST
CHATHAM CO., Ga. (WTOC) - Chatham Emergency Services is celebrating its 60th anniversary in 2021 - that's 60 years of providing fire response to a large part of our area that otherwise would be uncovered by a local fire department. In that time, the organization has evolved and grown to match the changes within Chatham County.
"We're the people who come on your worst day ever to make it better. And we'll be there within minutes," said Chuck Kearns, CEO of Chatham Emergency Services.
The mission of emergency services all across the country has been executed across Chatham County for six decades by a combination of volunteers and professionals.
"Think about it, if you live in Thunderbolt, Tybee, Port Wentworth, you have a fire department. If you don't live in one of those municipalities, you don't had a fire department. So, in 1961, a bunch of business people got together and said this is unacceptable, we have to have a fire department, and if the government is not going to provide it, we're going to provide it. So, they went out and they bought a couple of fire trucks and they volunteered their time and a lot of them would take the trucks home on the weekend, and they'd hear the call and they'd take it from their house and go fight the fire. Well, that's evolved," said Tim Blanco, Board Chair of Chatham Emergency Services.
Chatham Emergency Services has grown as vigorously as the region it serves during the last 60 years to more than 400 personnel and 100 vehicles at 14 fire stations in unincorporated Chatham County.
During the last two decades, they expanded from fire service to also operate the ambulance service for local hospitals.
"We went from a couple hundred calls in the 1960s to now we're running close to 100,000 calls in 2021," said Blanco.
"When people call us, things have happened in their life that they no longer have control over. Their house is on fire, they're having chest pains, they're in a car accident. They need someone to come make it better and that's what we do," said Kearns.
Timea Higgins wanted a closer look at what Chatham Emergency does because she was not conscious when they did it for her in April of 2020.
"Technically, they said it was a blood clot that clogged everything and gave me a widow maker... I woke up 10 days later in the hospital in ICU," said Timea Higgins, life was saved by Chatham Emergency Services.
Chatham Emergency saved her with one of their newest pieces of equipment, which administered expert CPR after she had died in her fiancé Gordon's arms.
"That is what basically kept me alive. I was down for 83 minutes. But I'm back... from what Gordon said, he was a witness, he said they were amazing. He said 'especially that girl',' who is now Pam. She's going to be my bridesmaid," Higgins said.
That rescue happened on Wilmington Island.
But Chatham Emergency has worked all across the county for 60 years, including outside their Garden City headquarters when someone pulled up with a loved one in cardiac distress while we were shooting this story.
But most emergencies don't come to them.
"We go to everything. we've unfortunately been to the plane crash, the National Guard plane crash. The sugar refinery years ago, we were at that. Flooding calls, when we had Hurricane Matthew several years back, we cut down 1,200 trees that were blocking roads around 700 miles of unincorporated area so that emergency vehicles could get in. You name it, we do it," Kearns said.
Martin Luther King, Jr. monument, park dedication on Saturday in Savannah
Parade returns to Springfield for MLK Jr. Day in Effingham County


It's March 11th, I99I. About 8.45am. I'm inside a carriage of the electric worm, rattling along the Victoria line, on my way to work at an advertising agency in London SWI. Unfortunately, the train isn't going to stop at Victoria today. There's been a bomb at the station. A lot of innocent people injured, some badly.The IRA had claimed responsibility, but failed, as usual, to admit irresponsibility.
"Passengers should leave the train at Green Park or Pimlico and make alternative arrangements to reach their destinations. Thank you." The announcement crackled through the tannoy. I settled for a leisurely walk across Green Park to the office.
When I had been mapping out the alignments for my Earthstars book some years before, I'd noticed that the main North-South alignment passed through part of the park, but as I'd been to Green Park countless times and had never noticed anything remotely out of the ordinary in the way of standing stones, or anything similar, I had assumed that there was nothing special there to mark the alignment. However, as I emerged from the tube into the light of day, I was about to be proved wrong.
I thought that if I had to walk to work through the park, I might as well check out the alignment as I was passing through. I intended to walk along the alignment, to see if the energy could be sensed or felt physically and to tune into it to see what insights or images came to mind. In preparation, as I entered the park, I mentally greeted the spirit of the place and asked for its co-operation; something I normally do when working with sacred sites. I asked to be shown anything that I ought to be aware of.
Almost immediately, I felt my attention drawn to a group of trees ahead of me, on the left hand side of the path. They looked as if they might be growing in a circle. I walked closer and was amazed to find they were the most perfect circle of trees you could possibly imagine. Something scuttled around the base of one of the trees. Or at least I thought it did. A small gnome-like figure. There was nothing there, of course. Nothing I could see anyway. But I sensed the place was alive with nature spirits and presences of other sorts. A shiver ran up my spine and I walked into the centre of the circle and gazed around in astonishment.
It felt like I'd entered a different dimension. So quiet, so calm, so re-assuring. I counted the trees: 11, 12,13. I counted them again. Yes, there were 13. One for each of the celtic, lunar months of the year. Whoa. Spooky. What was this? A druidic grove in the middle of Green Park? As a member of The Order of Bards, Ovates and Druids and a confirmed dabbler in things mystical and magical, I resolved to discover more.
Enquiries at the Parks Department of Westminster Council shed only a little light on the situation. The trees had been planted sometime in the last century, but there was no record of any particular person who may have been responsible.
For a while, there had been a bandstand in the circle of trees. However, I was informed that the trees pre-dated it and the bandstand had been demolished in the seventies. There was certainly no record of why the trees had been planted in a circle or why there happened to be thirteen of them.
One possibility is that the tree circle is related to a temple of "concorde" that once stood in the park. It burned down during a firework display. At least one site states the temple had 13 pillars, so perhaps the 13 trees were planted to remember it.
Regardless of how the circle of trees came to be in its present location, it is extremely well placed with regard to certain aspects of the Earth's spiritually energies.
The geometric pattern of sacred sites and energy centres outlined in my books "Earthstars," and " London City of Revelation"shows a central alignment running North-South through London. Green Park is one of the places it passes through and, for reasons that seem destined to remain a mystery, this circle of trees has been planted right on it.
The alignment runs diagonally through the park. It comes down from the hilltop church of St Mary's in East Barnet, over the summit of Highgate Hill (St Joseph's Church, now Highgate School chapel) and crosses Piccadilly near the junction of St James St. It enters Green Park just North of the circular grove, on the Queen's Walk side, crosses the park and goes through the Victoria Memorial Fountain outside Buckingham Palace.
The circle seems to have a few other alignments, too. An extension of Watkins' Strand Ley passes at a tangent to the South side of the circle. The cirlce also stands on a lline of the Earthstars inner pentagonal geometry as well as forming an equilateral triangle with St. Martin's in the Field and the west end of Westminster Abbey.
So, what's the answer? Was the circle planted here deliberately, by someone who was aware of earth energies, a druid gardener perhaps? Or by someone who lived nearby and wanted a convenient personal grove almost on the doorstep ?
We'll never know for sure, but I like to work intuitively with these places of power and see what turns up. So over the last two years, I have visited the Green Park Grove frequently, to attune to the spirit of the place. On the second visit, I was told to use it as an inner grove, which has prompted some interesting insights. Word has spread over the years and many people now visit it regularly and use it as a sanctuary for personal or group mediations whenever the opportunity arises.
Suffice to say, I have had many personal visionary spiritual experiences there. Without going into too much detail, it is clear that there is a presence amongst those trees that gives the place a special atmosphere, an air of sanctity, peace and tranquility that belies its proximity to Piccadilly's traffic and the bustle of London life.
It is a place where you can escape the concrete maze of the city and re-attune to the rhythms, cycles and spirit of nature, the spirit of the Earth that ceaselessly endures beneath our soul-less buildings.
On one visit, I was clearly asked to make more people aware of its existence, to enable them, whether druids, dowsers, healers, light-workers, shamanic groups or whatever, to be aware of this place of power and haven of tranquility, in order that it can fulfill its role as a real sacred grove for central London. The more people who utilise its energies for their own inspiration and healing, the better. If they can also help to channel its beneficial energies to the capital at large, that would be good, too.
Pay it a visit, even if it's only out of curiosity at first. Use it as a focus for silent vigil, particularly on full or new moons evenings and at the turning eight points of the celtic year. Draw on its energy for inspiration, guidance and healing for yourself and empower it as a light centre for the benefit of the capital at large.
I offer two points of advice. Always acknowledge the presence of the guardian spirits of the circle and despite the fact that you're in a public park, treat it with the respect due to a sacred place.
However this circle of trees came into being, behind it was the spirit of the place, which inspired someone to become its human agent and consciously or unconsciously plant those trees.
A conscious interaction with this source of power can be immensely rewarding and uplifting, both personally and for the good of London generally.
Finally, a word of caution; Don't get too carried away by the vibes.The London Underground runs beneath this part of the park, so some of the vibrations to be felt have more to do with the Victoria line rather than the ley-lines.
I recently visited london, and walked thru green park on a sunday nite. Since the streee was closed for the olympics, I was able to walk down the center of the street leading up to the fountain. My crown was blown wide open..felt as if I was using a halucegen. I then walked up towards picadily and still felt that strong impact upon my crown. I just now came accross the article about green park. Thank you for sharing this…It is such a magical place in the midst of the busiest city in the world.


Woven Gauze Sponge is ideal for general wound care, packing, dressing, and cleaning. It is available in non-acute only.
This cotton gauze sponge is ideal for applications where sterile gauze is not required.
Strictly controlled manufacturing process assures clean, debris-free packing with folded edges to prevent unraveling.


text:
BAHA
INW
Sound deleted from horrific hockey injury
You know you've done a bad injury when the video technician decides to delete the audio to avoid traumatising people even further.
Kookaburras defender Matthew Dawson is thanking his lucky stars after being named for the upcoming Commonwealth Games just three weeks after suffering a horrific eye injury.
Dawson was in danger of losing vision in his left eye after being struck by a hockey stick in a freak training accident.
The 23-year-old was in so much pain, his screams sent shockwaves through the people present.
"It was pretty painful. I've never felt anything like it," Dawson said.
"I got sent the footage of the incident. But the video guy deleted the sound off it.
"Apparently the screams were pretty loud. I was pretty lucky not to burst an eyeball."
Dawson's left eye has only just started to open up again, and he's expected to make a full recovery.
The Kookaburras' first game at the Gold Coast Games is just three weeks away, and Dawson is confident he'll be more than ready by then.
First, he'll need to pass a yet-to-be-defined hockey test to prove his eye is ready for action.
If he passes that, the New South Welshman is set to be the coolest kid at the Commonwealth Games courtesy of the streamlined glasses he must now wear to protect his eye.
"The surgeon told me I have to wear them for the next six months to protect the eye," Dawson said.
"I guess it's different. But a few of the boys at training this morning said they looked pretty good.
"That's always nice to hear some positive reinforcement."
Dawson was named as part of an 18-man squad who will try to lead the Kookaburras to a sixth-straight Commonwealth Games gold.
Eleven players are yet to feature in a Commonwealth Games, but coach Colin Batch says the team has enough experience to take home gold.
The Kookaburras are ranked first in the world, with their nearest challengers being India (sixth), England (seventh), and New Zealand (ninth).
©AAP2018
Horn camp calls Crawford soft after delay
Boxer Terence Crawford lets rip at Aussie Jeff Horn on Twitter


text:
790187272019-07-12 10:41:162019-07-12 10:41:1612019-07-12 10:41:16bartlomiejmartBartlomiej MartGeneral Manager
Originally from Poland, Mart is a senior hospitality professional who has previously worked in the Middle East. Mart who has a master's degree in European financial law, chose a career in the hospitality industry and worked for global brands in the UK, US and Gulf region. Mart began his hospitality career in the US in 2003 in the F&B department with Marriott and has since moved up the ranks. He has worked as the housekeeping manager, director of services, and director of operations. In 2014 he was an Edge Award Winner in the 'Marriott Global Award for Excellence in Delivering Guest Experiences', one of only 12 winners from rooms and spa disciplines selected from approximately 4,000 hotels in the world. Prior to his posting in Riyadh, Mart was the hotel manager at Swiss-Belhotel Residences in Bahrain.
Ascott Rafal Olaya RiyadhRiyadhhttps://www.the-ascott.com/en/saudi-arabia/riyadh/ascott-rafal-olaya-riyadh.htmlhttps://www.linkedin.com/in/bartlomiej-mart-5bb8a813/24.808852646.62652570HenriRoelings[email protected]


What Do Millennial IT Pros Need to Know?
In many ways, the challenges of a Millennial workforce have already been addressed. The internet has produced extensive myth-busting content about the Millennial generation, as well as tips to help bridge the gap between Millennials and older generations. We've learned that there are gaps even within the Millennial generation that can cause workplace tension, and that ultimately, Millennials are comprised of individuals with unique needs in much the same way as their predecessors' generations were. But the question remains – why do Millennial stereotypes persist, and how can we end them for good? Perhaps the answer involves Millennials looking inward to identify the ways they are perpetuating these stereotypes, and seeking solutions that will turn the talk in their favor.
Working at an IT consulting firm, ESP's employees get the chance to interact not only with Millennial IT consultants and job seekers, but also with Gen-X and Baby Boomer tech hiring managers. And because Millennials comprise over 60 percent of our in-office staff, we experience our own workplace gaps while also having the opportunity to witness how other Twin Cities businesses operate. That's why we decided to host a "Millennial Round Table" and discuss what advice we'd give to our Millennial IT consultants and job seekers based on these observations and experiences. The resulting 3 "need-to-knows" for Millennial IT pros can not only help you bridge the generational gap with coworkers and have a more positive working experience, but can also help you become more established in your tech career – ultimately leading to career growth and success.
In 2015, Millennials (those born between 1980 and 1999) officially surpassed Gen-X to become the largest generation in the American workforce. Couple this with the fact that 36 percent of all millennials ages 18 to 34 have cited a desire to work within the tech industry, and you can guarantee that Millennial IT pros comprise a large majority of the candidates that tech hiring managers are interviewing.
As Millennials helping other Millennials grow their careers, we understand how easy it can be to point fingers, claiming "them, not us" about others in our generation. But working in an IT consulting and staffing firm, we've had the rare opportunity of experiencing firsthand some of the difficulties Gen-X hiring managers encounter when interviewing and working with Millennial tech pros – and believe us, many of them are founded in first-hand experiences, not preconceived notions. Craft a more positive narrative for Millennials by adjusting your mindset, and developing new habits.
When it came to discussing the career expectations of the Millennial generation, we were all in agreement: we need to be more prepared to work our way up, gradually.
In an extremely hot, candidate-driven tech market, high and even unrealistic expectations are natural. Often times, these expectations are not the result of an IT pro's "inflated" sense of worth, but are instead the product of false information about the tech market. Many recruitment firms use dollars as a hook to attract IT pros and stand out from the crowd of other offers in the competitive market. Unfortunately, these promisers don't always deliver. Though the Twin Cities tech market is booming, what's true of the Silicon Valley doesn't always apply to employers in the Silicon Prairie.
The bottom line: though you may hear talk of first jobs that live up to your ideal, those opportunities are not the norm.
Getting ahead in the corporate world sometimes means playing whatever role your company needs you to be in. You might not get to work with the "sexiest technologies" or make groundbreaking decisions about the direction of your company's tech department right off the bat.
But the good news is that by not limiting the kind of work experience you're willing to gain, you're much more likely to ultimately achieve your "ideal".
Talk to tech hiring managers and recruiters about your career path, the experience that you've earned so far, and where you want to go. With a mapped-out path ahead of you, you can focus on moving up and growing your skill sets.
Though Millennials should all be well aware of these best practices, many of our Millennial staff have had an encounter with another professional in their generation who left the negative impression of being "flaky".
While a hot tech market may lead some Millennial IT pros to believe that making connections has become a less-important industry practice, maintaining a strong professional reputation remains one of the most important aspects to advancement in IT – and particularly in tech consulting.
IT gig-seekers: it's much better to communicate with a recruiter or hiring manager if you have lost interest in a position, than to simply "drop off". Clear communication and a reasonable explanation will not only help you to keep your professional reputation intact, but can actually enhance it.
Whether or not the opportunity before you is one that you want to pursue, by maintaining connections, not burning bridges, and otherwise exhibiting reputable behavior (i.e. following these tips for interview success) you leave your options open for future opportunities with a consulting firm or employer.
The real reason Millennial myths need to get "busted"? Much of what we hear about Millennials isn't founded in research or facts, but instead comes from opinions and individual interactions. Yet, there are some truths about the Millennial generation that differentiate them from those who came before.
For example, the "sharing culture" of Millennials means that less working professionals ages 18-34 invest in items such as cars, houses, and luxury bags. While some from the previous generations see this as a "negative" quality, for many Millennials, these purchasing decisions are the result of economic constraints (i.e. the hefty amount of college debt accumulated by the generation, and the proven decrease in Millennial's household earnings) rather than personal preference, or indifference to long-term investments. In the same way, there are misconceptions surrounding many other Millennial "myths" – but it's up to you to reveal these areas, and prove that they shouldn't be perceived in a negative light.
Millennial IT pros must answer the question: What differentiates you from your predecessors? Is it simply an increased familiarity with the newest technologies? Or do you bring other unique contributions to the professional world? The truth is that not all "stereotypes" about Millennials need to have a negative stigma, and many of them can be presented to tech hiring managers in a way that showcases the value Millennials bring to a team.
A popular truth about Millennials is that they want to feel like their work makes a difference. Not only has this lead to a generation that is more passionate about the work that they do, but it's also led to a generation that places a high value on creativity. Because of this, many Millennial tech pros seek to work in creative industries, or industries that they are passionate about. Millennials can use this as a "selling point" during an interview by explaining what they value most in a workplace, why a particular company appeals to those values, and also how having a passion for different fields uniquely qualifies them to succeed in a contract gig. By showcasing a level of investment in a given company that extends beyond your day-to-day tech work, you'll prove to a hiring manager that you are a good fit, and worthwhile investment.
Another positive stereotype about the Millennial generation is that they are more invested in their community than previous generations have been. This can mean that Millennials are more likely to volunteer within and outside of an organization, and strive to give back to their professional and personal communities. And, as ESP recruiter and Millennial Alex Webb pointed out, "The scope of our 'communities' are so blown up, too – if I share something with my LinkedIn community, all 500+ of my connections know about it." Let hiring mangers know what community means to you – whether you're interested in helping to organize your company's volunteer day, or you're an IT consultant whose network of connections could prove valuable to your client.
Whether perceived as positive or negative, most Millennials likely do identify with a few of the stereotypes about their generation. The key to acknowledging when you do align is first understanding why this stereotype is true of you, and then exploring ways in which you personally live it out. These questions for Millennials will help them to identify where they land on important Millennial topics, and what their tech hiring mangers or IT recruiters need-to-know.
Can We Keep our Flexible Hours but Prove We're Not Lazy?
Yes, it means abiding by the stereotype that Millennials are "plugged-in" to technology much more than other generations, but this allows them to practice the highly-valued work-life-integration model of working different hours, not less. Make sure to tell your IT recruiters up front if you prefer opportunities with flexible scheduling, or remote capabilities. On the other hand, if you differ from the pack and prefer a standard 9-5 schedule (as some of ESP's Millennial teammates do), make sure to share that information with hiring managers to avoid being stereotyped.
Do Job-Hoppers Have a Positive Case for Themselves?
Research has shown that the average worker will hold 10 different jobs before age 40 – a statistic that leaves tech hiring managers especially fearful in the midst of the talent shortage. But as ESP IT Recruiter Armel Martin pointed out, just as IT consultants learn and grow from their many different experiences, this sort of job-hopping can "make us much more adaptable and versatile." Though some hiring managers see this frequent job change as Millennials having "short attention spans", oftentimes the job change results from Millennial's desiring further growth, which they feel can come only by having a variety of experiences.
That's not to say that growth opportunities are the sole motivator behind frequent Millennial turnover. Another common reason that Millennials leave companies is in pursuit of increased work-life balance. And though some may negatively label this desire as "self-love", statistics show that employees who feel they have a greater work-life balance are more productive, more engaged, and are better brand ambassadors for your company than those who burn out from overworking.
Millennial IT pros: if either the desire for further growth or the pursuit of work-life balance have been reasons for your previous job change, share that information with your technical recruiter. Knowing what has and hasn't worked for you in the past will help him or her identify the types of opportunities that will better serve you in the future. On the other hand, if you are a Millennial tech pro with a track record of loyalty to one or two companies, or who has held multiple contract gigs that got extended due to the excellence of your work – point that out! Always seek to identify the ways that you stand out from the crowd.
By the end of our round table, the ESP team had acknowledged quite a few "truths" about the Millennial generation that all seemed to share a common theme: many of the negative "true stereotypes" about Millennials might not really characterize us as a generation. More commonly, they seemed to be the result of inexperience.
Whether you're an IT pro who is newly graduated from college or graduate school, or you've been working in the tech industry for a few years already, acknowledge the areas where you may still be on a learning curve. In doing so, you not only show respect to your Gen-X coworkers and supervisors by recognizing their expertise gained through the years, but you also give yourself permission to take a step back, and be comfortable with where you are.
The big question for both older Millennials and professionals born in previous generations: what mistakes did you make when you were first starting out? As a group, the ESP Millennials caught themselves more than once referring to the youngest in our generation (those just now graduating from college) as "they", not "us". We had to ask ourselves – have even those within the Millennial generation been associating the "Millennial" term with professional novices?
Perhaps the most important tip for Gen X-ers and Baby Boomers to help bridge the generational gap, then, is to take a step back, remember what challenges they faced when they were first starting out in their careers, and see if there are any parallels in their current experience with Millennials at their workplace.
But taking a step back and reflecting on Millennials' inexperience isn't only the responsibility of the previous generations. Millennials, too, need to learn how to acknowledge the areas they have yet to grow in.
Finally, sometimes advancing your career in the long run means "taking a step back" early on. For many tech pros, higher education can feel like one such step back. The tech talent shortage has increased the number of tech pros able to find work without first earning their degree, and many have debated whether or not computer science degrees are still valuable. Factoring in the cost of school, those who choose to earn their degrees may feel that they start out their adult lives "behind" those who entered tech careers right out of high school. But the long-term benefits to choosing school can mean greater opportunities for career advancement in the future. Seek to understand the long-term outcomes of your hard work and early choices, and be okay with waiting to reap the rewards.
Millennials want to change the world – and that can be a really great asset of the generation. Generational-cycle science identifies Millennials with the Civic generation model: "focused on 'how to clean things up'".
But the world won't change overnight, nor should it. Positive change happens gradually, over time, from the inside. In order to enact change, we have to first embrace the current systems, and understand why they are in place – recognizing the good intentions of those who came before.
For Millennial IT pros, this means understanding that your previous experiences (in part-time jobs, colleges, and internships), and your expectations entering a new career might not translate. The working world is a meld of Baby Boomer, Gen-X, and Millennial practices – and we all have to "give" a little to help this world run smoothly.
If you seek flexibility, you too must be flexible.
This means being prepared for a few hiccups your first time in the professional world, and trying to be open to learning opportunities and growth within your current role before job hopping. Consider how often others really land their dream opportunities right out of college, and you'll probably discover – despite the few instances you read about on social media – that this doesn't commonly happen. Adjust to a supervisor who may prefer phone calls or in-person interactions to text or IM (or try meeting him or her halfway with email). In turn, you may earn yourself the flexible hours, remote working capabilities, and career advancement opportunities that you are searching for.
To any future IT pros who are still in school, we encourage you to use college as an opportunity not only to gain knowledge about the newest technologies, but to learn about building a resume, interviewing, and life in the professional world. Seek internship opportunities that will help you to gain the soft skills and professional experience you need to land a job.
Many on our team encountered difficulties when they were first starting out in their careers – and a large majority of our Millennial employees began their careers in our office. However, just as we have experienced success and a high level of happiness as a team, we are confident that Millennial IT pros – those sought-after commodities with the hottest skills on the job market – will experience great satisfaction in their careers, as well.
With a little introspect, and a lot more understanding on both sides of the generational divide, Millennial IT pros can overcome stereotypes, experience satisfaction, and thrive in their careers. Though the term "Civic generation" will probably never stick over "Millennial", when we recognize our historical role to be a generation that enacts positive change we are able to confidently move into the future that's being crafted. By adapting to the world that they are currently operating in, looking inward to make self-improvements, and advocating on behalf of a generation that is setting out to do great things, Millennial IT pros can earn their place as leaders and experts in the tech industry.
Are you a Millennial IT pro seeking new opportunities, or a tech hiring manager seeking fresh talent?
This entry was posted in About ESP, Job Seeking Tips, Workplace and tagged college grads, company culture, ESP, IT experience shortage, IT hiring, IT job search, IT staffing, IT trends, job market, Millennial IT Pros, Millennials, productivity, promotion, Tech talent shortage by ESP IT. Bookmark the permalink.


text:
Assets quibi short for quick bites raised billion
7 CBS • Super Bowl LVI SoFi Stadium Los Angeles Feb.
Bayern Munich soccer $3B 25.
It was one-way traffic as Taylor's cute pass was finished well by Elyounoussi but from a fractionally offside position.
There was a report of my name as a potential candidate for NBA coaching opportunities.
Max Scherzer, Washington Nationals 8.
The products we have created with him have been received with tremendous enthusiasm, and there will be more as we continue to grow the relationship with him.
Thomas is hard to miss standing a few steps behind the scorer's table.
From 2014, no team won more games or scored more goals than the Lightning, and the franchise ranked fifth overall in victories during Yzerman's time in Tampa Bay, compiling a mark over that span.
Several shorter versions of the spot will also air, including Nice Try, She's Taken and Earn It, in which Jost and his sweater encounter Rodgers at the piano and ask, Has anyone ever told you you look like Aaron Rodgers?
Mookie Betts, Los Angeles Dodgers 2.
Golden State Warriors NBA $4B 6.
New York Giants NFL $3B 10.
The third game will be Nov.
We are always looking for new ways to add value for our customers, and this partnership creates great custom basketball uniforms to do just that.
According to Brand Keys, the survey was created to predictively measure consumer's true reactions to brands within the context of the medium.
Rawlings is the official baseball, helmet, face guard and glove for MLB, the official baseball for MiLB and the official baseball and softball for the NCAA and the NAIA.
13 Pittsburgh Steelers at Buffalo Bills • Dec.
TNT will exclusively air the event, scheduled for Nov.
1 Dallas Cowboys at Philadelphia Eagles • Nov.
Aaron Judge, New York Yankees 3.
The ceremony moved to the Hilton New York in 2004, to the Nokia Theatre Times Square in 2005, then back to the Hilton in 2006 and 2008.
Juan Soto, Washington Nationals 6.
Boston Red Sox MLB $3B 17.
• With baseball in World Series mode, MLB has named the 14 finalists for the Hank Aaron Award and the MLB Players Assn.
• Turner Sports confirmed Capital One's The Match: Champions for Change, a premier golf event with Phil Mickelson, Charles Barkley, Stephen Curry and Peyton Manning.
• NBC will air a two-hour All-American Bowl: Declaration Day special on Jan.
Paul Hornung Award Honor Roll …
San Francisco Giants MLB $3B 23.
Tiger Woods $62 million custom basketball uniforms million $60 million Golf 9.
8 New Orleans Saints at Tampa Bay Buccaneers • Nov.
It's powered by tradition .
Giancarlo Stanton, New York Yankees 17.
Brian Dumoulin, Kris Letang, Marcus Pettersson, and John Marino are the four best defenders on this team.
Fernando Tatis Jr., San Diego Padres 5.
Cody Bellinger, Los Angeles Dodgers 7.
LeBron James $88 million $28 million $60 million NBA 6.
Among others who have toured China for their shoe brands include LeBron James, Damian Lillard, Derrick Rose, and Kobe Bryant.
Christian Yelich, Milwaukee Brewers 12.
26 Baltimore Ravens at Pittsburgh Steelers • Nov.


text:
Epidemiology of ocular trauma in the rural population of Northern India
Author Details: Meenu Babber, Namrata Patel, Reena Sharma, Namita Sharma, Sonali Singh
Article First Page : 296298
Article End Page : 296298
Objective: To discover the epidemiology of ocular trauma and its effect on visual impairment and blindness in a rural population of northern India.
Methods: It is a population-based cross-sectional study. We surveyed 1024 people who visited the out patient department of U.P.U.M.S. Saifai during the study period from January 2017- June 2017. 100 cases of the ocular trauma of all age group, due to various causes enrolled in the study. All cases went through a rational interview and comprehensive examination of anterior and posterior segments of the eye.
Results: We obtained a history of ocular trauma from 100 (9.7%) persons in which 6 persons were with bilateral involvement. Mean age of the persons was 27.1 years including 82% males. A significant association was recorded between gender and ocular trauma (p=0.0001) although relation of the age at trauma with gender was not statistically significant (P = 1.0). Blunt trauma is the most common mode of ocular injury involving 94% persons. Poor visual acuity was noted with penetrating injuries as compared to blunt injuries. The Most common setting of ocular trauma was agricultural work (48%). Blindness was significantly correlated with the site of ocular trauma (P = 0.02).
Conclusion: The magnitude of visual impairment and blindness due to trauma is considerably high, therefore to reduce the burden, educational programmes with the focus on providing at least appropriate first aid care should be implemented to increase awareness regarding eye health in the rural population.
Keywords: Blindness, Epidemiology, Ocular trauma, Rural.


I love "leaving small singed footprints on cobbled stones."
Pearl, I like the links that are suggested in your word choices, from "singing sacred silent songs" to "singed" to "signs".
It is amazing how the wordle words seem to write themselves.
A small little tiny man with a pointed blue hat is sitting in your attic and channeling through you.
Words come from the muse or muses... I let them run free on the page. ...listening to catch a single molten note... captivating!
You sang my up and you sang me down. Where do these feelings and images come from I wonder? I follow in light pursuit.
You have left your footprints clearly. Thank you for sharing.
I, too, enjoyed the small singed footprints on cobbled stones. This reads like a dark fairy tale. Really intriguing.
I too am straining to hear that single molten note. It is everything.
Wow, that's a long breath of a write, like "a single molten note".
"leaving small singed footprints on cobbled stones"
"the dim weak fire drained dawn"
Although I hadn't a clue as to where you were leading me, I found the wordle journey very moving. Some lovely lines.
Hi...Thanks for stopping by my blog :-). Feel free to pass on the information about Wikimedia Commons. I would assume that one of Wikimedia's key mission statements is to create a large database of free-to-access photography and sketches. The more individuals who use (or at least know about) their site, the closer Wiki is to achieving its goals :-).


text:
You are at:Home»Featured»ETFs Set to Benefit as Bank Dividends Rise
ETFs Set to Benefit as Bank Dividends Rise
By Todd Shriberon February 20, 2014
The Federal Reserve's annual Comprehensive Capital Analysis and Review (CCAR) program is underway, meaning the central bank is reviewing plans by major U.S. banks to return capital to shareholders. That includes dividends and share repurchases.
This year's CCAR program is reviewing 30 large U.S. banks and the results are expected to be revealed next month. Financial services ETFs such as the Financial Select Sector SPDR (NYSArca: XLF) are expected to see at least some of their constituents announce higher payouts in the second quarter.
"Markit believes average dividend growth in 2014 will be on par with 2013. The most significant changes are concentrated in three banks: Bank of America (NYSE: BAC), Citigroup (NYSE: C), and Morgan Stanley (NYSE: MS). Though trailing the group in recent years, these three appear poised for major dividend growth in 2014. Expectations for the remainder are more pedestrian, thanks to Fed guidelines discouraging payouts greater than 30%. Though payouts exceeding 30% are not explicitly prohibited, the Fed notes such actions would attract their increased attention. Because payouts across most banks already approach 30%, we have lower projections for banks outside the top five," according to the research firm.
Bank of America and Citigroup are XLF's fourth- and fifth-largest holdings, respectively, combining for 12.2% of the ETF's weight. Morgan Stanley receives a 1.5% allocation in XLF, the largest U.S. sector ETF by assets. [Rotating Through Strong Sector ETFs]
Markit is forecasting dividend increases to five cents a share per quarter from a penny a share for Bank of America and Citi. The research firm also expects Morgan Stanley will double its quarterly payout to 10 cents per share. Other big dividend increases on a percentage basis are expected from Zions Banorp (NasdaqGM: ZION) and Regions Financial (NYSE: RF). Markit sees dividend increases for that pair of 75% and 67%, respectively.
Markit's outlook for dividend increases in the financial services sector jibes with other forecasts. Bloomberg recently ranked the top 25 potential dividend growers pulled from a universe of 130 S&P 500 constituents expected to boost payouts over the next three years. The banks that appear on the list are as follows in ascending order: Comerica (NYSE: CMA), Bank of New York Mellon (NYSE: BK), KeyCorp (NYSE: KEY), Morgan Stanley, Huntington Bancshares (NasdaqGM: HBAN), Discover Financial Services (NYSE: DFS), SunTrust (NYSE: STI), Regions Financial and Citigroup. [Bank ETFs for Dividend Growth]
bank dividendsCCARCurrent AffairsDividend ETFsFeature StoriesfeaturedIndexingKBEKBWBLead ETFs


text:
Q: json4s NoSuchMethodError when trying to save PipelineModel I am trying to perform a simple operation of saving a spark PipelineModel to hdfs via the save method.
I get the following exception even when trying to run spark's own example (see here)
My code is fairly simple and tries to use only spark.ml PipelineStages
package org.apache.spark.ml.util
import org.apache.spark.ml._
import org.apache.spark.ml.feature._
import org.scalatest.FunSuite

class Foo extends FunSuite {

... create spark context/session/sql context somewhere ...

    test("bar") {
        import sqlContext.implicits._
        val df = sparkContext.parallelize(
        (1, 4, "TH") ::
        (2, 5, "TH") ::
        (3, 6, "TH") ::
        (4, 7, "TH") ::
        (5, 8, "US") ::
        (6, 9, "US") :: Nil).toDF("id", "x", "a")

        val tr0 = new StringIndexer().setInputCol("a").setOutputCol("a_ind")
        val tr1 = new OneHotEncoder().setInputCol("a_ind").setOutputCol("a_vec").setDropLast(false)
        val tr2 = new PolynomialExpansion().setDegree(3).setInputCol("x").setOutputCol("x_vec")
        val tr3 = new VectorAssembler().setInputCols(Array("x_vec", "a_vec"))
        val pipe = new Pipeline().setStages(Array(tr0, tr1, tr2, tr3)).fit(df)

        pipe.write.overwrite().save("/tmp/foobar")
    }

}

The exception message is :
org.json4s.Formats.emptyValueStrategy()Lorg/json4s/prefs/EmptyValueStrategy;
java.lang.NoSuchMethodError: org.json4s.Formats.emptyValueStrategy()Lorg/json4s/prefs/EmptyValueStrategy;

This repeats regardless of what pipeline you try to create, could it be related to this?
What's going on?

A: Issue solved, the json4s version 3.2.11 was not used for some reason. once it was fixed everything is fine. –

redpajama_set_name: RedPajamaStackExchange


the only scene I have not figured out is the one where you need to find the hummingbirds.....where are they?
I know you have to pick up the birdseed, but I'm trying to figure out where to put it!!!!!
There are 3 hummingbird feeders. One on the left, one on the right and one in the front middle of the screen. They look like black poles with clear glass containers on top. After you fill all three with the bird food the hummingbirds will start to appear.
This is my favorite one, but it took me awhile to figure out that what I thought were garden lights were hummingbird feeders lol. The birds are easier to click than the cuckoo clock birds are because they stay at the feeder awhile, and they add a lot to the garden scene visually.


We wrote in our last blog about how some of our team are on a journey to learn more about what happens to our waste, whether that's waste for landfill or for recycling. Packaging market research out in the field!
We visited Agrivert which deals with our food waste, Viridor which takes in our black bin waste, and a Materials Recovery Facility, the first purpose-built recycling factory in the UK.
Our journey was sparked by personal and professional interest – after all, at NOA we specialise in packaging industry research – and we wanted to see for ourselves what happens to waste and whether we're making progress. Blue Planet II was a huge wake-up call to the problem of plastic.
Certainly not. There is a lot being done in the recycling field. However, as we hinted in our last blog, lack of consistency is causing confusion to consumers. One expert we've been speaking to thinks the answer here may be one box for plastic, metal and glass, another for paper and cardboard, a landfill bin and a food waste bin. We will have to see what DEFRA decides in its latest deliberations.
There is also a huge debate regarding what cardboard can or cannot be recycled. For example, what about the bottom of a pizza box? It's made of cardboard, but is often spattered with food – tomatoes, oil, cheese etc. Can these be recycled? The answer is generally a "No"!
Also, disposing of all the recycled material is not that straightforward. China, as we've said in a previous blog, closed its doors to the world's waste for processing and recycling, which caused a backlog for several months at the end of 2017 and into 2018 – you may remember around Christmas, just before China's ban came in, ships carrying tonnes of recyclable plastic were being held up in Hong Kong harbour.
The BBC's recent programme Drowning in Plastic reiterated the extent of the plastic pollution on our planet. Clearly more needs to be done, not just with 'old' plastic but how much new plastic we are producing. Nearly all plastic ever produced – some 79% – still exists in some form or another on our planet. We cannot cope with businesses producing much more!
One answer may be the government's review of the PRN system. PRNs – or Packaging Waste Recovery Notes – affect larger producers, packers and retailers of packaging, who are required to purchase PRNs, which go towards the cost of recycling packaging waste. The system is being looked at – watch this space for more news on how these funds are (and could be) being used.
Another innovation is #IKEAtoyapp, an App which gives children ideas for things they can make out of the cardboard packaging. Here's a marvellous video from the clever IKEA marketing people, which shows some of the suggestions. Cardboard shark anyone?
Many ideas are being put forward – take a look at our blog on alternatives to plastic – but far more research needs to be done in this area and at NOA, that's just what we're doing.
At NOA, we specialise in research, coaching and marketing services for the packaging industry. We are passionate about the packaging industry both on a personal level and a global level and the whole subject of packaging materials, the waste that is produced and what happens to it is one of our favourite topics. To find out how we could help you research your burning topics, or to invest in our most recent cardboard corrugated packaging industry report, please get in touch.
How do Europe's changing Retail Trends affect our packaging?


Share on Facebook Share on Twitter Share on Google+ Share on Pinterest Share by Email × Question about Canon PIXMA MP600 all-In-One InkJet Printer 1 Answer Canon MP630 error code 6502 Helped me with my ciss and the MG5650. See all Canon Pixma MP500 All-In-One InkJet Printer Questions Related Topics error code v chip code 6502 error 6502 error code 6502 mp5 no power pinework MP E 65 Faulty button or it's affiliates.
Have a manual for Canon PIXMA MP600 all-In-One InkJet Printer? Error mesaages 6502. Gepubliceerd op 10 aug. 2012 Categorie Muziek Licentie Standaard YouTube-licentie Laden... Question about Canon PIXMA Printers & Copiers 1 Answer Canon PIXMA MP500 - "Error Code 6502" ...Error Code 6502" I recently replaced my ink cartridges (everything was fine beforehand).
Only unplugged before the button combination)So.. Change sensor or repair disconnected wires Sep 25, 2009 | Canon PIXMA MP830 All-In-One InkJet... 1 Answer Error code 6502 That error says it's a ink tank position error, make sure Solution: Unplug the printer.Remove the faulty CartridgePlug in the printer and press and hold power buttonKeep it held down. ... Inloggen Statistieken 16.062 weergaven 1 Vind je dit een leuke video?
Or just drag it here! Wait until printer settles down, if power is off, turn on. Pixma MP500 All-In-One InkJet... Reply Leave a Reply Cancel reply Your email address will not be published.
Clara Mídias 13.912 weergaven 1:35 CISS installation for Canon MG6320 MG7120 MG6240, MG5520, MG5420, MG5422, MX922 - Duur: 20:45. All Best: Pineworks Posted on Jan 25, 2010 Helpful 3 Not Helpful Comment Flag You can't post conmments that contain an email address. × Comment Anonymously Video Images Add Your Answer Ask Anonymously Popular Questions 10 Answers Reset Ink levels for canon mx310 Canon PIXMA MX310 All-In-One... 16 Answers Canon MP210 Ink Counter Reset Canon PIXMA MP210 Photo... 19 Answers Canon pixma CDRCIA Informática.
alfredo vicente 14.924 weergaven 0:55 Resetter Contador de impressão(almofadas), Canon IP4910, IP7210, MG5410 - Duur: 1:40. So now open the cover and install only the printhead and close the cover. PIXMA MP830... The email address entered is already associated to an account.Login to post Please use English characters only.
Showed error code 6502 immediately. Master 4,041 Answers Re: error code 6502 This might work Error Code 6502 appears generally after chaging a cartridge.Solution: Unplug the printer. Have a manual for Canon Pixma MP500 All-In-One InkJet Printer? You can't post answers that contain an email address.
The ink tank LEDs are busted3. Hope this helps.Thanks!Please rate this answer. I'll research it some more and add it in later... Try reseating them.
When the cartridge carriage comes to the center, remove all cartridges3. inkproducts.com 24.645 weergaven 12:54 ix6560 - Duur: 1:11. 陳明雲 779 weergaven 1:11 Meer suggesties laden... Laden... Learn more You're viewing YouTube in Dutch.
Ensure that no tape, glue etc is covering the chip or LED on the rear of the cartridge. That error says it's a ink tank position error, make sure there ... Press Resume twice, and this should reset the fault. Service error 6502 generally means that your ink cartridge chips cannot be recognised.
Solution 1: Unplug the printer. Nov 20, 2011 | Canon PIXMA MP830 All-In-One InkJet... 3 Answers I have cannon IP3680, but from today it's making problem (Service error 6502), would u please tell me a easy Try this first. 1. Well, why not?
Vice President: An expert whose answer got voted for 100 times. kennenargentina 20.120 weergaven 2:17 Actual method of Resetting Canon MG5400 MG5410 MG5420 MG5430 MG5440 MG5450 MG5460 MG5470 MG5480 - Duur: 4:55. Plug cord back in & turn printer on. 4. Mar 01, 2011 | Canon Printers & Copiers 2 Answers ERROR 6502 Error 6502 (Ink tank position sensor error) the sensor is receiving too much light.
Hi guys!I´m having trobles with this printer!HEEEEEEEEEEEEEEEEELLLLLLLLLLPPPPPPPPPPPPPP!I´ve the full reset chips... in french ! ITJungles 503.744 weergaven 1:39 6502 Program Counter Setup - Duur: 3:28:28. Андрей Йердна 3:28:28 Canon MG5310 error U052 - Descripción del error - No Solución - Duur: 6:39.


text:
Edwards to take Senate oath on Tuesday
By Bill Moss, Published: September 12, 2016
Chuck Edwards, newly appointed by Gov. Pat McCrory to fill the 48th District state Senate seat upon Sen. Tom Apodaca's retirement, will be sworn in to the office at 4 p.m. Tuesday at the Historic Courthouse.
Henderson County Commission Chairman Tommy Thompson will be master of ceremonies. Chief District Court Judge Athena Brooks will administer the oath. In case of rain, the ceremony will be held in the Community Room on the second floor of the Historic Courthouse. The public is invited.
"I am humbled to receive this honor, and I pledge to do all that I can possibly do in the remainder of the current term to prove myself worthy of the trust that has been placed in me," Edwards, who won the Republican nomination for the seat in the March primary, said in a statement. "I want it known that I intend to serve each and every person in this district with equal resolve for positive outcomes regardless of political party affiliation or ideology."
Edwards faces Democrat Norm Bossert in the Nov. 8 election.


You can connect your iPhone X to net use your cellular information network or a WiFi network. the most cost effective usign free WiFi.A mobile information you'll start or of to cut back your budget.
If you would like some facilitate whereas get a retardant with cellular network services, voicemail, and asking, At&T Lte not operating you're liberal to contact the service supplier.
You can select your information connections use associate degree LTE, 4G, and 3G service on GSM cellular networks support synchronal voice and information communications. The nextt generations is 5G wait it for increadible speed. reckoning on your network affiliation, you'll not be ready to receive calls whereas iPhone transfers information over the cellular network.
GSM systems: On a footing or GPRS association, approaching calls could go foursquare to telephone message amid info exchanges. For approaching calls that you simply reply, info exchanges area unit stopped.
CDMA systems: On EV-DO associations, info exchanges area unit stopped once you answer approaching calls. On 1xRTT associations, approaching calls could go foursquare to telephone message amid info exchanges. For approaching calls that you simply reply, info exchanges area unit delayed.
iPhone X info exchange resumes once you finish the decision.
In the event that Cellular information is off, all info administrations utilize simply Wi-Fi together with email, net studying, push notices, and completely different administrations. within the event that Cellular information is on, bearer charges could apply. maybe, utilizing bound highlights and administrations that exchange info, as an instance, Siri and Messages, might originate charges to your info style.
Turn Voice Roaming on or off (CDMA): flip Voice Roaming off to take care of a strategic distance from charges from utilizing alternative bearer's systems. At the purpose once your bearer's system is not accessible, iPhone will not have cell (information or voice) profit.
Tricks to show information Roaming on or off: information Roaming grants net access over a cell info prepare once you are in an exceedingly territory not secured by your bearer's system. once you are voyaging, you'll kill information Roaming to abstain from wandering charges.
Empower or cripple 4G/LTE (shifts via bearer): exploitation 4G or LTE masses net info speedier occasionally nonetheless could diminish battery execution. This various is not accessible altogether regions. On iPhone SE, iPhone 6, iPhone half-dozen and, and later, there area unit potentialities for killing 4G/LTE or for selecting Voice and information (VoLTE) or information solely. If your information 4G LTE not operating simply decision exploitation the quantity that we have a tendency to provide.
Voice and information (a few transporters): select LTE to stack info speedier. (This to boot activates VoLTE.) select slower speeds to expand battery life.
Set up Personal Hotspot: Personal Hotspot shares the web association on iPhone together with your computer and completely different iOS gadgets.
Tips: flip Wi-Fi Assist on or off: If Wi-Fi network is poor, Wi-Fi Assist utilizes cell info to assist the flag.
Set whether or not cell info is employed for applications and administrations. visit Settings > Cellular, at that time flip cell info on or off for any application that may utilize cell info. On the off probability that a setting is off, iPhone utilizes simply Wi-Fi for that administration. The iTunes setting incorporates each iTunes Match and programmed downloads from the iTunes Store and also the App Store.


View alumni that have participated in Grant Union High School Golf. If you participated in Golf while at Grant Union HS Sacramento, CA, register now and add your name to the list with a message to your old friends.
Looking for Grant Union Sacramento, CA alumni who participated in Golf but are not listed? Classmates.com® has hundreds of more Grant Union Sacramento, CA alumni listed.