code
stringlengths 2
1.05M
| repo_name
stringlengths 5
101
| path
stringlengths 4
991
| language
stringclasses 3
values | license
stringclasses 5
values | size
int64 2
1.05M
|
|---|---|---|---|---|---|
module Main where
import Lib
main :: IO ()
main = putStrLn "Hello, Main here."
|
epost/psc-query
|
psc-query/Main.hs
|
Haskell
|
bsd-3-clause
| 81
|
{-# OPTIONS_GHC -fno-warn-tabs #-}
import Common
import Hex
import Xor
main = do
putStrLn "=== Challange5 ==="
putStrLn $ hexEncode $ xorBytes message key
where
key = strToVec "ICE"
message = strToVec "Burning 'em, if you ain't quick and nimble\nI go crazy when I hear a cymbal"
|
andrewcchen/matasano-cryptopals-solutions
|
set1/Challange5.hs
|
Haskell
|
bsd-3-clause
| 286
|
module Trainer where
import System.Random
import Trainer.Internal
randomListIndex :: Double -> IO Int
randomListIndex hi = do r1 <- randomRIO (0,1)
r2 <- randomRIO (0,1)
return (floor $ positiveStdNormal hi r1 r2)
|
epsilonhalbe/VocabuLambda
|
Trainer.hs
|
Haskell
|
bsd-3-clause
| 264
|
-- polyacounting.hs
module Math.PolyaCounting where
-- Cameron, Combinatorics, p247-253
import Math.PermutationGroups
import Math.SchreierSims
import Math.QQ
import Math.MPoly
import Math.CombinatoricsCounting (factorial, choose)
-- ROTATION GROUP OF CUBE (AS PERMUTATION OF FACES)
-- 1
-- 2 3 4 5
-- 6
cubeF = fromCycles [[1],[2,3,4,5],[6]]
cubeV = fromCycles [[1,2,3],[4,5,6]]
cubeE = fromCycles [[1,3],[2,4],[5,6]]
cubeGp = schreierSimsTransversals 6 [cubeF, cubeV, cubeE]
-- ROTATION GROUP OF DODECAHEDRON (AS PERMUTATION OF FACES)
-- The top faces are numbered (looking from above)
-- 2
-- 6 3
-- 1
-- 5 4
-- The bottom faces are numbered so that opposite faces add up to 13 (still looking from above)
-- 9 8
-- 12
-- 10 7
-- 11
dodecF = fromCycles [[1],[2,3,4,5,6],[11,10,9,8,7],[12]] -- rotation about a face
dodecV = fromCycles [[1,2,3],[4,6,8],[9,7,5],[12,11,10]] -- rotation about a vertex
dodecE = fromCycles [[1,2],[3,6],[4,9],[5,8],[7,10],[11,12]] -- rotation about an edge
dodecGp = schreierSimsTransversals 12 [dodecF, dodecV, dodecE]
-- in fact any two generate the group
-- The order of the group is 60. It's isomorphic to A5. See:
-- http://en.wikipedia.org/wiki/Icosahedral_symmetry
cycleIndexElt g = monomial (cycleType g)
cycleIndexGp gp = sum [cycleIndexElt g | g <- fix (eltsSS gp)] / fromInteger (orderSS gp)
fix gs = let n = maximum [length xs | PL xs <- gs]
in map (\g -> if g == PL [] then PL [1..n] else g) gs
countingPoly gp vs = substMP (cycleIndexGp gp) [sum [v^i | v <- vs] | i <- [0..]]
polyaCount' gp vs = evalMP (countingPoly gp vs) (repeat 1)
polyaCount gp vs = sum [c | (c,as) <- termsMP (countingPoly gp vs)]
-- COUNTING NON-ISOMORPHIC GRAPHS
toEdge (a,b) = if a < b then (a,b) else (b,a)
(a,b) -^ g = toEdge (a .^ g, b .^ g) -- action on edge induced from action on points
edges :: [(Int,Int)]
edges = doEdges 2
where doEdges n = [(i,n) | i <- [1..n-1]] ++ doEdges (n+1)
numEdgesKn n = fromInteger (toInteger n `choose` 2)
edgesKn n = take (numEdgesKn n) edges
edgeToPoint (a,b) = (b-2)*(b-1) `div` 2 + a
pointToEdge c = edges !! (c-1)
-- given an elt of Sn, return the induced action on the edges of Kn
inducedPermutation n g = PL [edgeToPoint (edge -^ g) | edge <- edgesKn n]
generatorsEdgeGp n = map (inducedPermutation n) (generatorsSn n)
edgeGp n = schreierSimsTransversals m (generatorsEdgeGp n)
where m = numEdgesKn n
{-
partitions n = boundedPartitions n n
where boundedPartitions n k -- partitions of n where the parts are bounded to be <= k
| n <= 0 = [[]]
| k == 0 = []
| k > n = boundedPartitions n (k-1)
| otherwise = map (k:) (boundedPartitions (n-k) k) ++ boundedPartitions n (k-1)
-}
cycleTypesSn n = doCycleTypes n n [[]]
where doCycleTypes n 1 types = map (n:) types
doCycleTypes n i types = concat [doCycleTypes (n-a*i) (i-1) (map (a:) types) | a <- [0..n `div` i] ]
-- the argument is [a_1, ..., a_n], where we're asking about elements with cycle structure 1^a_1 ... n^a_n
numEltsWithCycleType n as = (factorial n) `div` product [i^a * factorial a | (i,a) <- zip [1..] as]
cycleIndexSn n = sum [fromInteger (numEltsWithCycleType n as) * monomial as | as <- cycleTypesSn n] / fromInteger (factorial n)
-- given n, and a cycle type for Sn, calculate the induced cycle index on the edges of Kn
inducedCycleType :: Int -> [Int] -> [Int]
inducedCycleType n as =
let cyclePowers = [(i,a) | (i,a) <- zip [1..] as, a /= 0]
withinCycles = [(i, (i-1) `div` 2 * a) | (i,a) <- cyclePowers] -- each cycle induces a cycle on edges within the cycle
++ [(i `div` 2,a) | (i,a) <- cyclePowers, even i] -- but in the even case, the edge joining opposite points of the cycle has half the period
acrossCycles = [(lcm i j, a * b * gcd i j) | (i,a) <- cyclePowers, (j,b) <- cyclePowers, i < j] -- if the points of an edge fall in cycles of different length, the period of the cycle on the edge is the gcd
++ [(i, i * (a * (a-1) `div` 2)) | (i,a) <- cyclePowers, a > 1] -- when the points of an edge fall in different cycles of the same length, the cycle on the edge also has this length
-- there are (a `choose` 2) choices for pairs of cycles, and given a pair, there are i choices for edges
in collectPowers (withinCycles ++ acrossCycles) -- withinCycles $+ collectPowers acrossCycles
where collectPowers powers = [sum [a | (i,a) <- powers, i == j] | j <- [1..numEdgesKn n]] -- can be done more efficiently
inducedCycleIndex n as =
let cyclePowers = [(i,a) | (i,a) <- zip [1..] as, a /= 0]
withinCycles = [(i, (i-1) `div` 2 * a) | (i,a) <- cyclePowers, i > 1] -- each cycle induces a cycle on edges within the cycle
++ [(i `div` 2,a) | (i,a) <- cyclePowers, even i] -- but in the even case, the edge joining opposite points of the cycle has half the period
acrossCycles = [(lcm i j, a * b * gcd i j) | (i,a) <- cyclePowers, (j,b) <- cyclePowers, i < j] -- if the points of an edge fall in cycles of different length, the period of the cycle on the edge is the gcd
++ [(i, i * (a * (a-1) `div` 2)) | (i,a) <- cyclePowers, a > 1] -- when the points of an edge fall in different cycles of the same length, the cycle on the edge also has this length
-- there are (a `choose` 2) choices for pairs of cycles, and given a pair, there are i choices for edges
in product [x_ i ^ a | (i,a) <- withinCycles ++ acrossCycles]
inducedCycleIndexSn n = sum [fromInteger (numEltsWithCycleType n as) * inducedCycleIndex n as | as <- cycleTypesSn n] / fromInteger (factorial n)
graphCountingPoly n = substMP (inducedCycleIndexSn n) [1+t^i | i <- [0..]]
|
nfjinjing/bench-euler
|
src/Math/PolyaCounting.hs
|
Haskell
|
bsd-3-clause
| 5,948
|
module Scurry.Comm.Message(
ScurryMsg(..),
) where
import Control.Monad
import Data.Binary
import qualified Data.ByteString as BSS
import Data.Word
import Scurry.Types.Network
import Scurry.Peer
type PingID = Word32
-- |These are the messages we get across the network.
-- They are the management and data protocol.
data ScurryMsg = SFrame BSS.ByteString -- | An ethernet frame.
| SJoin PeerRecord -- | A network join request.
| SJoinReply PeerRecord [EndPoint] -- | A network join reply.
| SKeepAlive PeerRecord -- | A keep alive message.
| SNotifyPeer EndPoint -- | A message to notify others of a peer.
| SRequestPeer -- | A message to request peer listings on the network.
| SPing PingID -- | A Ping command used for diagnostics.
| SEcho PingID -- | A Echo command used to respond to the Ping command.
| SLANProbe -- | A message to probe the local LAN for other members.
| SLANSuggest ScurryPort -- | A message to inform a peer that they may share a LAN with another.
| SAddrRequest -- | A message to request an available VPN address
-- | SAddrReject -- | A message to reject the address a peer has chosen
| SAddrPropose ScurryAddress ScurryMask -- | A message to suggest an address to a peer
-- | SAddrSelect ScurryAddress -- | A message to inform every one we're using an address
| SUnknown -- | An unknown message
deriving (Show)
instance Binary ScurryMsg where
get = do tag <- getWord8
case tag of
0 -> liftM SFrame get -- SFrame
1 -> liftM SJoin get -- SJoin
2 -> liftM2 SJoinReply get get -- SJoinReply
3 -> liftM SKeepAlive get -- SKeepAlive
4 -> liftM SNotifyPeer get -- SNotifyPeer
5 -> return SRequestPeer -- SRequestPeer
6 -> liftM SPing get -- SPing
7 -> liftM SEcho get -- SEcho
8 -> return SLANProbe -- SLANProbe
9 -> liftM SLANSuggest get -- SLANSuggest
10 -> return SAddrRequest -- SAddrRequest
-- 11 -> return SAddrReject -- SAddrReject
12 -> liftM2 SAddrPropose get get -- SAddrPropose
-- 13 -> get >>= (return . SAddrSelect) -- SAddrSelect
_ -> return SUnknown -- Unknown Message
put (SFrame fp) = putWord8 0 >> put fp
put (SJoin m) = putWord8 1 >> put m
put (SJoinReply m p) = putWord8 2 >> put m >> put p
put (SKeepAlive r) = putWord8 3 >> put r
put (SNotifyPeer p) = putWord8 4 >> put p
put SRequestPeer = putWord8 5
put (SPing pp) = putWord8 6 >> put pp
put (SEcho pe) = putWord8 7 >> put pe
put SLANProbe = putWord8 8
put (SLANSuggest ps) = putWord8 9 >> put ps
put SAddrRequest = putWord8 10
-- put SAddrReject = putWord8 11
put (SAddrPropose a m) = putWord8 12 >> put a >> put m
-- put (SAddrSelect p) = putWord8 13 >> put p
put SUnknown = putWord8 255
|
dmagyar/scurry
|
src/Scurry/Comm/Message.hs
|
Haskell
|
bsd-3-clause
| 3,581
|
{-# LANGUAGE RankNTypes #-}
{-
Copyright (C) 2012-2017 Kacper Bak, Jimmy Liang, Michal Antkiewicz <http://gsd.uwaterloo.ca>
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
-}
{- |
This is in a separate module from the module "Language.Clafer" so that other modules that require
ClaferEnv can just import this module without all the parsing/compiline/generating functionality.
-}
module Language.ClaferT
( ClaferEnv(..)
, irModuleTrace
, uidIClaferMap
, makeEnv
, getAst
, getIr
, ClaferM
, ClaferT
, CErr(..)
, CErrs(..)
, ClaferErr
, ClaferErrs
, ClaferSErr
, ClaferSErrs
, ErrPos(..)
, PartialErrPos(..)
, throwErrs
, throwErr
, catchErrs
, getEnv
, getsEnv
, modifyEnv
, putEnv
, runClafer
, runClaferT
, Throwable(..)
, Span(..)
, Pos(..)
) where
import Control.Monad.Except
import Control.Monad.Identity
import Control.Monad.State
import Data.List
import qualified Data.Map as Map
import Language.Clafer.ClaferArgs
import Language.Clafer.Common
import Language.Clafer.Front.AbsClafer
import Language.Clafer.Front.LexClafer
import Language.Clafer.Intermediate.Intclafer
import Language.Clafer.Intermediate.Tracing
{-
- Examples.
-
- If you need ClaferEnv:
- runClafer args $
- do
- env <- getEnv
- env' = ...
- putEnv env'
-
- Remember to putEnv if you do any modification to the ClaferEnv or else your updates
- are lost!
-
-
- Throwing errors:
-
- throwErr $ ParseErr (ErrFragPos fragId fragPos) "failed parsing"
- throwErr $ ParseErr (ErrModelPos modelPos) "failed parsing"
-
- There is two ways of defining the position of the error. Either define the position
- relative to a fragment, or relative to the model. Pick the one that is convenient.
- Once thrown, the "partial" positions will be automatically updated to contain both
- the model and fragment positions.
- Use throwErrs to throw multiple errors.
- Use catchErrs to catch errors (usually not needed).
-
-}
data ClaferEnv
= ClaferEnv
{ args :: ClaferArgs
, modelFrags :: [String] -- original text of the model fragments
, cAst :: Maybe Module
, cIr :: Maybe (IModule, GEnv, Bool)
, frags :: [Pos] -- line numbers of fragment markers
, astModuleTrace :: Map.Map Span [Ast] -- can keep the Ast map since it never changes
, otherTokens :: [Token] -- non-parseable tokens: comments and escape blocks
} deriving Show
-- | This simulates a field in the ClaferEnv that will always recompute the map,
-- since the IR always changes and the map becomes obsolete
irModuleTrace :: ClaferEnv -> Map.Map Span [Ir]
irModuleTrace env = traceIrModule $ getIModule $ cIr env
where
getIModule (Just (imodule, _, _)) = imodule
getIModule Nothing = error "BUG: irModuleTrace: cannot request IR map before desugaring."
-- | This simulates a field in the ClaferEnv that will always recompute the map,
-- since the IR always changes and the map becomes obsolete
-- maps from a UID to an IClafer with the given UID
uidIClaferMap :: ClaferEnv -> UIDIClaferMap
uidIClaferMap env = createUidIClaferMap $ getIModule $ cIr env
where
getIModule (Just (iModule, _, _)) = iModule
getIModule Nothing = error "BUG: uidIClaferMap: cannot request IClafer map before desugaring."
getAst :: (Monad m) => ClaferT m Module
getAst = do
env <- getEnv
case cAst env of
(Just a) -> return a
_ -> throwErr (ClaferErr "No AST. Did you forget to add fragments or parse?" :: CErr Span) -- Indicates a bug in the Clafer translator.
getIr :: (Monad m) => ClaferT m (IModule, GEnv, Bool)
getIr = do
env <- getEnv
case cIr env of
(Just i) -> return i
_ -> throwErr (ClaferErr "No IR. Did you forget to compile?" :: CErr Span) -- Indicates a bug in the Clafer translator.
makeEnv :: ClaferArgs -> ClaferEnv
makeEnv args' =
ClaferEnv
{ args = args''
, modelFrags = []
, cAst = Nothing
, cIr = Nothing
, frags = []
, astModuleTrace = Map.empty
, otherTokens = []
}
where
args'' = if (CVLGraph `elem` (mode args') ||
Html `elem` (mode args') ||
Graph `elem` (mode args'))
then args'{keep_unused=True}
else args'
-- | Monad for using Clafer.
type ClaferM = ClaferT Identity
-- | Monad Transformer for using Clafer.
type ClaferT m = ExceptT ClaferErrs (StateT ClaferEnv m)
type ClaferErr = CErr ErrPos
type ClaferErrs = CErrs ErrPos
type ClaferSErr = CErr Span
type ClaferSErrs = CErrs Span
-- | Possible errors that can occur when using Clafer
-- | Generate errors using throwErr/throwErrs:
data CErr p
-- | Generic error
= ClaferErr
{ msg :: String
}
-- | Error generated by the parser
| ParseErr
{ pos :: p -- ^ Position of the error
, msg :: String
}
-- | Error generated by semantic analysis
| SemanticErr
{ pos :: p
, msg :: String
}
deriving Show
-- | Clafer keeps track of multiple errors.
data CErrs p =
ClaferErrs {errs :: [CErr p]}
deriving Show
data ErrPos =
ErrPos {
-- | The fragment where the error occurred.
fragId :: Int,
-- | Error positions are relative to their fragments.
-- | For example an error at (Pos 2 3) means line 2 column 3 of the fragment, not the entire model.
fragPos :: Pos,
-- | The error position relative to the model.
modelPos :: Pos
}
deriving Show
-- | The full ErrPos requires lots of information that needs to be consistent. Every time we throw an error,
-- | we need BOTH the (fragId, fragPos) AND modelPos. This makes it easier for developers using ClaferT so they
-- | only need to provide part of the information and the rest is automatically calculated. The code using
-- | ClaferT is more concise and less error-prone.
-- |
-- | modelPos <- modelPosFromFragPos fragdId fragPos
-- | throwErr $ ParserErr (ErrPos fragId fragPos modelPos)
-- |
-- | vs
-- |
-- | throwErr $ ParseErr (ErrFragPos fragId fragPos)
-- |
-- | Hopefully making the error handling easier will make it more universal.
data PartialErrPos =
-- | Position relative to the start of the fragment. Will calculate model position automatically.
-- | fragId starts at 0
-- | The position is relative to the start of the fragment.
ErrFragPos {
pFragId :: Int,
pFragPos :: Pos
} |
ErrFragSpan {
pFragId :: Int,
pFragSpan :: Span
} |
-- | Position relative to the start of the complete model. Will calculate fragId and fragPos automatically.
-- | The position is relative to the entire complete model.
ErrModelPos {
pModelPos :: Pos
}
|
ErrModelSpan {
pModelSpan :: Span
}
deriving Show
class ClaferErrPos p where
toErrPos :: Monad m => p -> ClaferT m ErrPos
instance ClaferErrPos Span where
toErrPos = toErrPos . ErrModelSpan
instance ClaferErrPos ErrPos where
toErrPos = return . id
instance ClaferErrPos PartialErrPos where
toErrPos (ErrFragPos frgId frgPos) =
do
f <- getsEnv frags
let pos' = ((Pos 1 1 : f) !! frgId) `addPos` frgPos
return $ ErrPos frgId frgPos pos'
toErrPos (ErrFragSpan frgId (Span frgPos _)) = toErrPos $ ErrFragPos frgId frgPos
toErrPos (ErrModelPos modelPos') =
do
f <- getsEnv frags
let fragSpans = zipWith Span (Pos 1 1 : f) f
case findFrag modelPos' fragSpans of
Just (frgId, Span fragStart _) -> return $ ErrPos frgId (modelPos' `minusPos` fragStart) modelPos'
Nothing -> return $ ErrPos 1 noPos noPos -- error $ show modelPos' ++ " not within any frag spans: " ++ show fragSpans -- Indicates a bug in the Clafer translator
where
findFrag pos'' spans =
find (inSpan pos'' . snd) (zip [0..] spans)
toErrPos (ErrModelSpan (Span modelPos'' _)) = toErrPos $ ErrModelPos modelPos''
class Throwable t where
toErr :: t -> Monad m => ClaferT m ClaferErr
instance ClaferErrPos p => Throwable (CErr p) where
toErr (ClaferErr mesg) = return $ ClaferErr mesg
toErr err =
do
pos' <- toErrPos $ pos err
return $ err{pos = pos'}
-- | Throw many errors.
throwErrs :: (Monad m, Throwable t) => [t] -> ClaferT m a
throwErrs throws =
do
errors <- mapM toErr throws
throwError $ ClaferErrs errors
-- | Throw one error.
throwErr :: (Monad m, Throwable t) => t -> ClaferT m a
throwErr throw = throwErrs [throw]
-- | Catch errors
catchErrs :: Monad m => ClaferT m a -> ([ClaferErr] -> ClaferT m a) -> ClaferT m a
catchErrs e h = e `catchError` (h . errs)
addPos :: Pos -> Pos -> Pos
addPos (Pos l c) (Pos 1 d) = Pos l (c + d - 1) -- Same line
addPos (Pos l _) (Pos m d) = Pos (l + m - 1) d -- Different line
minusPos :: Pos -> Pos -> Pos
minusPos (Pos l c) (Pos 1 d) = Pos l (c - d + 1) -- Same line
minusPos (Pos l c) (Pos m _) = Pos (l - m + 1) c -- Different line
inSpan :: Pos -> Span -> Bool
inSpan pos' (Span start end) = pos' >= start && pos' <= end
-- | Get the ClaferEnv
getEnv :: Monad m => ClaferT m ClaferEnv
getEnv = get
getsEnv :: Monad m => (ClaferEnv -> a) -> ClaferT m a
getsEnv = gets
-- | Modify the ClaferEnv
modifyEnv :: Monad m => (ClaferEnv -> ClaferEnv) -> ClaferT m ()
modifyEnv = modify
-- | Set the ClaferEnv. Remember to set the env after every change.
putEnv :: Monad m => ClaferEnv -> ClaferT m ()
putEnv = put
-- | Uses the ErrorT convention:
-- | Left is for error (a string containing the error message)
-- | Right is for success (with the result)
runClaferT :: Monad m => ClaferArgs -> ClaferT m a -> m (Either [ClaferErr] a)
runClaferT args' exec =
mapLeft errs `liftM` evalStateT (runExceptT exec) (makeEnv args')
where
mapLeft :: (a -> c) -> Either a b -> Either c b
mapLeft f (Left l) = Left (f l)
mapLeft _ (Right r) = Right r
-- | Convenience
runClafer :: ClaferArgs -> ClaferM a -> Either [ClaferErr] a
runClafer args' = runIdentity . runClaferT args'
|
gsdlab/clafer
|
src/Language/ClaferT.hs
|
Haskell
|
mit
| 11,024
|
{-# LANGUAGE CPP #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE RecordWildCards #-}
-- | High-level scenarios which can be launched.
module Pos.Launcher.Scenario
( runNode
, runNode'
, nodeStartMsg
) where
import Universum
import qualified Data.HashMap.Strict as HM
import Formatting (bprint, build, int, sformat, shown, (%))
import Serokell.Util (listJson)
import Pos.Chain.Genesis as Genesis (Config (..),
GenesisDelegation (..), GenesisWStakeholders (..),
configBootStakeholders, configFtsSeed,
configHeavyDelegation)
import Pos.Chain.Txp (TxpConfiguration, bootDustThreshold)
import Pos.Chain.Update (UpdateConfiguration, curSoftwareVersion,
lastKnownBlockVersion, ourSystemTag)
import Pos.Context (NodeContext (..), getOurPublicKey, npSecretKey)
import Pos.Core (addressHash)
import Pos.Core.Conc (mapConcurrently)
import Pos.Crypto (pskDelegatePk, toPublic)
import qualified Pos.DB.BlockIndex as DB
import qualified Pos.GState as GS
import Pos.Infra.Diffusion.Types (Diffusion)
import Pos.Infra.Reporting (reportError)
import Pos.Infra.Slotting (waitSystemStart)
import Pos.Infra.Util.LogSafe (logInfoS)
import Pos.Launcher.Resource (NodeResources (..))
import Pos.Util.AssertMode (inAssertMode)
import Pos.Util.CompileInfo (HasCompileInfo, compileInfo)
import Pos.Util.Util (HasLens', lensOf)
import Pos.Util.Wlog (WithLogger, askLoggerName, logInfo)
import Pos.Worker (allWorkers)
import Pos.WorkMode.Class (WorkMode)
-- | Entry point of full node.
-- Initialization, running of workers, running of plugins.
runNode'
:: forall ext ctx m.
( HasCompileInfo
, WorkMode ctx m
)
=> Genesis.Config
-> NodeResources ext
-> [ (Text, Diffusion m -> m ()) ]
-> [ (Text, Diffusion m -> m ()) ]
-> Diffusion m -> m ()
runNode' genesisConfig NodeResources {..} workers' plugins' = \diffusion -> do
logInfo $ "Built with: " <> pretty compileInfo
nodeStartMsg
inAssertMode $ logInfo "Assert mode on"
pk <- getOurPublicKey
let pkHash = addressHash pk
logInfoS $ sformat ("My public key is: "%build%", pk hash: "%build)
pk pkHash
let genesisStakeholders = configBootStakeholders genesisConfig
logInfo $ sformat
("Genesis stakeholders ("%int%" addresses, dust threshold "%build%"): "%build)
(length $ getGenesisWStakeholders genesisStakeholders)
(bootDustThreshold genesisStakeholders)
genesisStakeholders
let genesisDelegation = configHeavyDelegation genesisConfig
let formatDlgPair (issuerId, delegateId) =
bprint (build%" -> "%build) issuerId delegateId
logInfo $ sformat ("GenesisDelegation (stakeholder ids): "%listJson)
$ map (formatDlgPair . second (addressHash . pskDelegatePk))
$ HM.toList
$ unGenesisDelegation genesisDelegation
firstGenesisHash <- GS.getFirstGenesisBlockHash $ configGenesisHash
genesisConfig
logInfo $ sformat
("First genesis block hash: "%build%", genesis seed is "%build)
firstGenesisHash
(configFtsSeed genesisConfig)
tipHeader <- DB.getTipHeader
logInfo $ sformat ("Current tip header: "%build) tipHeader
waitSystemStart
let
runWithReportHandler :: (Text, Diffusion m -> m ()) -> m ()
runWithReportHandler (workerName, action) = action diffusion `catch` (reportHandler workerName)
void (mapConcurrently runWithReportHandler (workers' ++ plugins'))
exitFailure
where
reportHandler :: Text -> SomeException -> m b
reportHandler action (SomeException e) = do
loggerName <- askLoggerName
let msg = "Worker/plugin with work name "%shown%" and logger name "%shown%" failed with exception: "%shown
reportError $ sformat msg action loggerName e
exitFailure
-- | Entry point of full node.
-- Initialization, running of workers, running of plugins.
runNode
:: ( HasCompileInfo
, WorkMode ctx m
)
=> Genesis.Config
-> TxpConfiguration
-> NodeResources ext
-> [ (Text, Diffusion m -> m ()) ]
-> Diffusion m -> m ()
runNode genesisConfig txpConfig nr plugins =
runNode' genesisConfig nr workers' plugins
where workers' = allWorkers sid genesisConfig txpConfig nr
sid = addressHash . toPublic . npSecretKey . ncNodeParams . nrContext
$ nr
-- | This function prints a very useful message when node is started.
nodeStartMsg
:: (MonadReader r m, HasLens' r UpdateConfiguration, WithLogger m)
=> m ()
nodeStartMsg = do
uc <- view (lensOf @UpdateConfiguration)
logInfo (msg uc)
where
msg uc = sformat ("Application: " %build% ", last known block version "
%build% ", systemTag: " %build)
(curSoftwareVersion uc)
(lastKnownBlockVersion uc)
(ourSystemTag uc)
|
input-output-hk/cardano-sl
|
lib/src/Pos/Launcher/Scenario.hs
|
Haskell
|
apache-2.0
| 5,177
|
{-
Copyright 2012 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-}
{-# LANGUAGE OverloadedStrings #-}
module Plush.Server.Utilities (
-- * Responses
notFound, badRequest,
respApp,
-- * JSON Applications
JsonApplication,
jsonApp,
returnJson, returnResponse,
-- * Keyed Applications
KeyedRequest,
keyedApp,
)
where
import qualified Blaze.ByteString.Builder.ByteString as B
import Control.Applicative ((<$>), (<*>))
import Control.Monad (mzero)
import Data.Aeson
import Network.HTTP.Types
import Network.Wai
-- | 404 \"File not found\"
notFound :: Response
notFound = responseLBS status404
[ ("Content-Type", "text/plain") ] "File not found"
-- | 400 \"Bad Request\"
badRequest :: Response
badRequest = responseLBS status400
[ ("Content-Type", "text/plain") ] "Bad request"
-- | An application that returns a fixed response no matter the request.
respApp :: Response -> Application
respApp resp _ = ($ resp)
-- | Like 'Application', but takes a request type @/a/@ and returns a response
-- type @/b/@.
--
-- Both types are indended to be trasmitted as JSON, so @/a/@ should be an
-- instance of 'FromJSON', and @/b/@ should be an instance of 'ToJSON'.
--
-- The actual type returns @'Either' 'Response' /b/@ so that if an error
-- occurs, the application can return an error response of some sort, rather
-- than JSON.
type JsonApplication a b = a -> IO (Either Response b)
-- | Transforms a 'JsonApplication' into an 'Application'. If a value of type
-- @/a/@ cannot be parsed from the JSON in the request, then 'badRequest'
-- results.
jsonApp :: (FromJSON a, ToJSON b) => JsonApplication a b -> Application
jsonApp jApp req respond = do
body <- strictRequestBody req
case decode body of
Nothing -> respond badRequest
Just a -> jApp a >>= respond . either id jsonResponse
where
jsonResponse =
responseBuilder status200 [ ("Content-Type", "application/json") ]
. B.fromLazyByteString . encode
-- | Utility for returning a JSON response in a JsonApplication
returnJson :: (ToJSON b) => b -> IO (Either Response b)
returnJson = return . Right
-- | Utility for returning 'Response' response in a JsonApplication
returnResponse :: (ToJSON b) => Response -> IO (Either Response b)
returnResponse = return . Left
-- | A request with the form @{ key: /k/, req: /r/ }@, where @/r/@ is an
-- inner request.
data KeyedRequest a = KeyedRequest String a
instance (FromJSON a) => FromJSON (KeyedRequest a) where
parseJSON (Object v) = KeyedRequest <$> v .: "key" <*> v .: "req"
parseJSON _ = mzero
-- | Transforms a 'JsonApplication' into one that takes a 'KeyedRequest'.
-- The first argument is the /key/, and if it matches the key in the request
-- then the inner value is passed on to the inner application. Otherwise,
-- a 'badRequest' results.
keyedApp :: (FromJSON a, ToJSON b) => String -> JsonApplication a b
-> JsonApplication (KeyedRequest a) b
keyedApp key jApp (KeyedRequest key' a) | key' == key = jApp a
keyedApp _ _ _ = returnResponse badRequest
|
mzero/plush
|
src/Plush/Server/Utilities.hs
|
Haskell
|
apache-2.0
| 3,631
|
{-# LANGUAGE BangPatterns #-}
-- This is a non-exposed internal module
--
-- The code in this module has been ripped from containers-0.5.5.1:Data.Map.Base [1] almost
-- verbatimely to avoid a dependency of 'template-haskell' on the containers package.
--
-- [1] see https://hackage.haskell.org/package/containers-0.5.5.1
--
-- The original code is BSD-licensed and copyrighted by Daan Leijen, Andriy Palamarchuk, et al.
module Language.Eta.Meta.Lib.Map
( Map
, empty
, insert
, Eta.REPL.Map.lookup
) where
import Eta.REPL.Map
|
rahulmutt/ghcvm
|
libraries/eta-meta/Language/Eta/Meta/Lib/Map.hs
|
Haskell
|
bsd-3-clause
| 549
|
{-# LANGUAGE Haskell98 #-}
{-# LINE 1 "Data/ByteString/Lazy/Builder/Extras.hs" #-}
-- | We decided to rename the Builder modules. Sorry about that.
--
-- The old names will hang about for at least once release cycle before we
-- deprecate them and then later remove them.
--
module Data.ByteString.Lazy.Builder.Extras (
module Data.ByteString.Builder.Extra
) where
import Data.ByteString.Builder.Extra
|
phischu/fragnix
|
tests/packages/scotty/Data.ByteString.Lazy.Builder.Extras.hs
|
Haskell
|
bsd-3-clause
| 406
|
{-# LANGUAGE RecordWildCards #-}
-- | Build configuration
module Stack.Config.Build where
import Data.Maybe
import Data.Monoid.Extra
import Stack.Types.Config
-- | Interprets BuildOptsMonoid options.
buildOptsFromMonoid :: BuildOptsMonoid -> BuildOpts
buildOptsFromMonoid BuildOptsMonoid{..} = BuildOpts
{ boptsLibProfile = fromFirst
(boptsLibProfile defaultBuildOpts)
(buildMonoidLibProfile <>
First (if tracing || profiling then Just True else Nothing))
, boptsExeProfile = fromFirst
(boptsExeProfile defaultBuildOpts)
(buildMonoidExeProfile <>
First (if tracing || profiling then Just True else Nothing))
, boptsLibStrip = fromFirst
(boptsLibStrip defaultBuildOpts)
(buildMonoidLibStrip <>
First (if noStripping then Just False else Nothing))
, boptsExeStrip = fromFirst
(boptsExeStrip defaultBuildOpts)
(buildMonoidExeStrip <>
First (if noStripping then Just False else Nothing))
, boptsHaddock = fromFirst
(boptsHaddock defaultBuildOpts)
buildMonoidHaddock
, boptsHaddockOpts = haddockOptsFromMonoid buildMonoidHaddockOpts
, boptsOpenHaddocks = fromFirst
(boptsOpenHaddocks defaultBuildOpts)
buildMonoidOpenHaddocks
, boptsHaddockDeps = getFirst buildMonoidHaddockDeps
, boptsHaddockInternal = fromFirst
(boptsHaddockInternal defaultBuildOpts)
buildMonoidHaddockInternal
, boptsHaddockHyperlinkSource = fromFirst
(boptsHaddockHyperlinkSource defaultBuildOpts)
buildMonoidHaddockHyperlinkSource
, boptsInstallExes = fromFirst
(boptsInstallExes defaultBuildOpts)
buildMonoidInstallExes
, boptsPreFetch = fromFirst
(boptsPreFetch defaultBuildOpts)
buildMonoidPreFetch
, boptsKeepGoing = getFirst buildMonoidKeepGoing
, boptsForceDirty = fromFirst
(boptsForceDirty defaultBuildOpts)
buildMonoidForceDirty
, boptsTests = fromFirst (boptsTests defaultBuildOpts) buildMonoidTests
, boptsTestOpts =
testOptsFromMonoid buildMonoidTestOpts additionalArgs
, boptsBenchmarks = fromFirst
(boptsBenchmarks defaultBuildOpts)
buildMonoidBenchmarks
, boptsBenchmarkOpts =
benchmarkOptsFromMonoid buildMonoidBenchmarkOpts additionalArgs
, boptsReconfigure = fromFirst
(boptsReconfigure defaultBuildOpts)
buildMonoidReconfigure
, boptsCabalVerbose = fromFirst
(boptsCabalVerbose defaultBuildOpts)
buildMonoidCabalVerbose
, boptsSplitObjs = fromFirst
(boptsSplitObjs defaultBuildOpts)
buildMonoidSplitObjs
}
where
-- These options are not directly used in bopts, instead they
-- transform other options.
tracing = getAny buildMonoidTrace
profiling = getAny buildMonoidProfile
noStripping = getAny buildMonoidNoStrip
-- Additional args for tracing / profiling
additionalArgs =
if tracing || profiling
then Just $ "+RTS" : catMaybes [trac, prof, Just "-RTS"]
else Nothing
trac =
if tracing
then Just "-xc"
else Nothing
prof =
if profiling
then Just "-p"
else Nothing
haddockOptsFromMonoid :: HaddockOptsMonoid -> HaddockOpts
haddockOptsFromMonoid HaddockOptsMonoid{..} =
defaultHaddockOpts
{hoAdditionalArgs = hoMonoidAdditionalArgs}
testOptsFromMonoid :: TestOptsMonoid -> Maybe [String] -> TestOpts
testOptsFromMonoid TestOptsMonoid{..} madditional =
defaultTestOpts
{ toRerunTests = fromFirst (toRerunTests defaultTestOpts) toMonoidRerunTests
, toAdditionalArgs = fromMaybe [] madditional <> toMonoidAdditionalArgs
, toCoverage = fromFirst (toCoverage defaultTestOpts) toMonoidCoverage
, toDisableRun = fromFirst (toDisableRun defaultTestOpts) toMonoidDisableRun
}
benchmarkOptsFromMonoid :: BenchmarkOptsMonoid -> Maybe [String] -> BenchmarkOpts
benchmarkOptsFromMonoid BenchmarkOptsMonoid{..} madditional =
defaultBenchmarkOpts
{ beoAdditionalArgs =
fmap (\args -> unwords args <> " ") madditional <>
getFirst beoMonoidAdditionalArgs
, beoDisableRun = fromFirst
(beoDisableRun defaultBenchmarkOpts)
beoMonoidDisableRun
}
|
mrkkrp/stack
|
src/Stack/Config/Build.hs
|
Haskell
|
bsd-3-clause
| 4,419
|
module Comment00004 where
dropBitMask xs
| t = 1
-- | otherwise = go
|
charleso/intellij-haskforce
|
tests/gold/parser/Comment00004.hs
|
Haskell
|
apache-2.0
| 80
|
{-# LANGUAGE RecordWildCards #-}
module Test.Haddock
( module Test.Haddock.Config
, runAndCheck, runHaddock, checkFiles
) where
import Control.Monad
import Data.Maybe
import System.Directory
import System.Exit
import System.FilePath
import System.IO
import System.Process
import qualified Data.ByteString.Char8 as BS
import Test.Haddock.Config
import Test.Haddock.Process
import Test.Haddock.Utils
data CheckResult
= Fail
| Pass
| NoRef
| Error String
| Accepted
deriving Eq
runAndCheck :: Config c -> IO ()
runAndCheck cfg = do
runHaddock cfg
checkFiles cfg
checkFiles :: Config c -> IO ()
checkFiles cfg@(Config { .. }) = do
putStrLn "Testing output files..."
files <- ignore <$> getDirectoryTree (cfgOutDir cfg)
failed <- liftM catMaybes . forM files $ \file -> do
putStr $ "Checking \"" ++ file ++ "\"... "
status <- maybeAcceptFile cfg file =<< checkFile cfg file
case status of
Fail -> putStrLn "FAIL" >> (return $ Just file)
Pass -> putStrLn "PASS" >> (return Nothing)
NoRef -> putStrLn "PASS [no .ref]" >> (return Nothing)
Error msg -> putStrLn ("ERROR (" ++ msg ++ ")") >> return Nothing
Accepted -> putStrLn "ACCEPTED" >> return Nothing
if null failed
then do
putStrLn "All tests passed!"
exitSuccess
else do
maybeDiff cfg failed
exitFailure
where
ignore = filter (not . dcfgCheckIgnore cfgDirConfig)
maybeDiff :: Config c -> [FilePath] -> IO ()
maybeDiff (Config { cfgDiffTool = Nothing }) _ = pure ()
maybeDiff cfg@(Config { cfgDiffTool = (Just diff) }) files = do
putStrLn "Diffing failed cases..."
forM_ files $ diffFile cfg diff
runHaddock :: Config c -> IO ()
runHaddock cfg@(Config { .. }) = do
createEmptyDirectory $ cfgOutDir cfg
putStrLn "Generating documentation..."
forM_ cfgPackages $ \tpkg -> do
haddockStdOut <- openFile cfgHaddockStdOut WriteMode
let pc = processConfig
{ pcArgs = concat
[ cfgHaddockArgs
, pure $ "--odir=" ++ outDir cfgDirConfig tpkg
, tpkgFiles tpkg
]
, pcEnv = Just $ cfgEnv
, pcStdOut = Just $ haddockStdOut
}
handle <- runProcess' cfgHaddockPath pc
waitForSuccess "Failed to run Haddock on specified test files" handle
checkFile :: Config c -> FilePath -> IO CheckResult
checkFile cfg file = do
hasRef <- doesFileExist $ refFile dcfg file
if hasRef
then do
mout <- readOut cfg file
mref <- readRef cfg file
return $ case (mout, mref) of
(Just out, Just ref)
| ccfgEqual ccfg out ref -> Pass
| otherwise -> Fail
_ -> Error "Failed to parse input files"
else return NoRef
where
ccfg = cfgCheckConfig cfg
dcfg = cfgDirConfig cfg
-- We use ByteString here to ensure that no lazy I/O is performed.
-- This way to ensure that the reference file isn't held open in
-- case after `diffFile` (which is problematic if we need to rewrite
-- the reference file in `maybeAcceptFile`)
-- | Read the reference artifact for a test
readRef :: Config c -> FilePath -> IO (Maybe c)
readRef cfg file =
ccfgRead ccfg . BS.unpack
<$> BS.readFile (refFile dcfg file)
where
ccfg = cfgCheckConfig cfg
dcfg = cfgDirConfig cfg
-- | Read (and clean) the test output artifact for a test
readOut :: Config c -> FilePath -> IO (Maybe c)
readOut cfg file =
fmap (ccfgClean ccfg file) . ccfgRead ccfg . BS.unpack
<$> BS.readFile (outFile dcfg file)
where
ccfg = cfgCheckConfig cfg
dcfg = cfgDirConfig cfg
diffFile :: Config c -> FilePath -> FilePath -> IO ()
diffFile cfg diff file = do
Just out <- readOut cfg file
Just ref <- readRef cfg file
writeFile outFile' $ ccfgDump ccfg out
writeFile refFile' $ ccfgDump ccfg ref
putStrLn $ "Diff for file \"" ++ file ++ "\":"
hFlush stdout
handle <- runProcess' diff $ processConfig
{ pcArgs = [outFile', refFile']
, pcStdOut = Just $ stdout
}
waitForProcess handle >> return ()
where
dcfg = cfgDirConfig cfg
ccfg = cfgCheckConfig cfg
outFile' = outFile dcfg file <.> "dump"
refFile' = outFile dcfg file <.> "ref" <.> "dump"
maybeAcceptFile :: Config c -> FilePath -> CheckResult -> IO CheckResult
maybeAcceptFile cfg file result
| cfgAccept cfg && result `elem` [NoRef, Fail] = do
Just out <- readOut cfg file
writeFile (refFile dcfg file) $ ccfgDump ccfg out
pure Accepted
where
dcfg = cfgDirConfig cfg
ccfg = cfgCheckConfig cfg
maybeAcceptFile _ _ result = pure result
outDir :: DirConfig -> TestPackage -> FilePath
outDir dcfg tpkg = dcfgOutDir dcfg </> tpkgName tpkg
outFile :: DirConfig -> FilePath -> FilePath
outFile dcfg file = dcfgOutDir dcfg </> file
refFile :: DirConfig -> FilePath -> FilePath
refFile dcfg file = dcfgRefDir dcfg </> file
|
Helkafen/haddock
|
haddock-test/src/Test/Haddock.hs
|
Haskell
|
bsd-2-clause
| 5,180
|
{-# LANGUAGE FlexibleInstances #-}
module SafeInfered05_A where
class C a where
f :: a -> String
instance C [Int] where
f _ = "[Int]"
|
forked-upstream-packages-for-ghcjs/ghc
|
testsuite/tests/safeHaskell/safeInfered/SafeInfered05_A.hs
|
Haskell
|
bsd-3-clause
| 141
|
module T8603 where
import Control.Monad
import Data.Functor
import Control.Monad.Trans.Class( lift )
import Control.Monad.Trans.State( StateT )
newtype RV a = RV { getPDF :: [(Rational,a)] } deriving (Show, Eq)
instance Functor RV where
fmap f = RV . map (\(x,y) -> (x, f y)) . getPDF
instance Monad RV where
return x = RV [(1,x)]
rv >>= f = RV $
do (p,a) <- getPDF rv
guard (p > 0)
(q,b) <- getPDF $ f a
guard (q > 0)
return (p*q, b)
type RVState s a = StateT s RV a
uniform :: [a] -> RV a
uniform x = RV [(1/fromIntegral (length x), y) | y <- x]
testRVState1 :: RVState s Bool
testRVState1
= do prize <- lift uniform [1,2,3]
return False
-- lift :: (MonadTrans t, Monad m) => m a -> t m a
|
urbanslug/ghc
|
testsuite/tests/typecheck/should_fail/T8603.hs
|
Haskell
|
bsd-3-clause
| 745
|
-- list comprehensions
-- Applying an expression to each value in a list
ghci> [x*2 | x <- [1..10]]
[2,4,6,8,10,12,14,16,18,20]
-- And also filtering out some of the values
ghci> [x*2 | x <- [1..10], x*2 > 12 ]
[14,16,18,20]
-- Using a function to filter out some of the vaalues
ghci> [x | x <- [50..100], x `mod` 7 == 4]
[53,60,67,74,81,88,95]
-- Put the comprehension into a function, to allow reuse:
ghci> let boomBangs xs = [ if x < 3 then "BOOM!" else "BANG!" | x <- xs, odd x ]
ghci> boomBangs [1..10]
["BOOM!","BANG!","BANG!","BANG!","BANG!"]
-- Can include multiple predicates, sepaarted by commas
ghci>[ x | x <- [10..20], x /= 13, x /= 15, x /= 19]
[10,11,12,14,16,17,18,20]
-- Can draw from more than one lists
-- In which case, every combination of elements is generated.
-- This taks first value from first list, then loops through all values from the second list
-- Then takes second vlaue from the first list.
ghci>[ x + y | x <- [1..2], y <- [ 10, 100, 1000] ]
[11,101,1001,12,102,1002]
-- Combining lists og words
ghci> let nouns = ["cat","dog","frog"]
ghci> let adjectives = ["happy","smily","grumpy"]
ghci> [adjective ++ " " ++ noun | adjective <- adjectives, noun <- nouns]
["happy cat","happy dog","happy frog","smily cat","smily dog","smily frog",
"grumpy cat","grumpy dog","grumpy frog"]
-- Using underscore as a temporary variable, as we don't care about the values
ghci>let length' xs = sum [ 1 | _ <- xs ]
ghci>length "hello world"
11
|
claremacrae/haskell_snippets
|
list_comprehensions.hs
|
Haskell
|
mit
| 1,470
|
module RandomExample where
import Control.Applicative (liftA3)
import Control.Monad (replicateM)
import Control.Monad.Trans.State
import System.Random
-- newtype State s a =
-- State { runState :: s -> (a, s) }
-- Six-sided die
data Die =
DieOne
| DieTwo
| DieThree
| DieFour
| DieFive
| DieSix
deriving (Eq, Show)
intToDie :: Int -> Die
intToDie n =
case n of
1 -> DieOne
2 -> DieTwo
3 -> DieThree
4 -> DieFour
5 -> DieFive
6 -> DieSix
-- Use this tactic _extremely_ sparingly.
x -> error $ "intToDie got non 1-6 integer: " ++ show x
rollDieThreeTimes :: (Die, Die, Die)
rollDieThreeTimes = do
-- this will produce the same results every
-- time because it is free of effects.
-- This is fine for this demonstration.
let s = mkStdGen 0
(d1, s1) = randomR (1, 6) s
(d2, s2) = randomR (1, 6) s1
(d3, _) = randomR (1, 6) s2
(intToDie d1, intToDie d2, intToDie d3)
rollDie :: State StdGen Die
rollDie = state $ do
(n, s) <- randomR (1, 6)
return (intToDie n, s)
rollDie' :: State StdGen Die
rollDie' =
intToDie <$> state (randomR (1, 6))
rollDieThreeTimes' :: State StdGen (Die, Die, Die)
rollDieThreeTimes' =
liftA3 (,,) rollDie rollDie rollDie
nDie :: Int -> State StdGen [Die]
nDie n = replicateM n rollDie
-- keep rolling until we reach or exceed 20
rollsToGetTwenty :: StdGen -> Int
rollsToGetTwenty g = go 0 0 g
where go :: Int -> Int -> StdGen -> Int
go sum count gen
| sum >= 20 = count
| otherwise =
let (die, nextGen) = randomR (1, 6) gen
in go (sum + die) (count + 1) nextGen
rollsToGetN :: Int -> StdGen -> Int
rollsToGetN i g = go 0 0 g
where go :: Int -> Int -> StdGen -> Int
go sum count gen
| sum >= i = count
| otherwise =
let (die, nextGen) = randomR (1, 6) gen
in go (sum + die) (count + 1) nextGen
rollsCountLogged :: Int -> StdGen -> (Int, [Die])
rollsCountLogged i g = go 0 0 g []
where go :: Int -> Int -> StdGen -> [Die] -> (Int, [Die])
go sum count gen acc
| sum >= i = (count, acc)
| otherwise =
let (die, nextGen) = randomR (1, 6) gen
in go (sum + die) (count + 1) nextGen (intToDie die : acc)
|
mitochon/hexercise
|
src/haskellbook/ch23/ch23.hs
|
Haskell
|
mit
| 2,290
|
import Network.SimpleServe (listen, makeStore)
main :: IO ()
main = do
store <- makeStore
listen store
|
ngasull/hs-simple-serve
|
src/Main.hs
|
Haskell
|
mit
| 108
|
{-
Parser.hs: Parser for the Flounder interface definition language
Part of Flounder: a strawman device definition DSL for Barrelfish
Copyright (c) 2009, ETH Zurich.
All rights reserved.
This file is distributed under the terms in the attached LICENSE file.
If you do not find this file, copies can be found by writing to:
ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
-}
module Parser where
import FuguBackend
import qualified System
import Text.ParserCombinators.Parsec as Parsec
import Text.ParserCombinators.Parsec.Expr
import Text.ParserCombinators.Parsec.Pos
import qualified Text.ParserCombinators.Parsec.Token as P
import Text.ParserCombinators.Parsec.Language( javaStyle )
import Char
import Numeric
import Data.List
import Text.Printf
parse filename = parseFromFile errorFile filename
lexer = P.makeTokenParser (javaStyle
{ P.reservedNames = [ "errors",
"success",
"failure"
]
, P.reservedOpNames = ["*","/","+","-"]
, P.commentStart = "/*"
, P.commentEnd = "*/"
, P.commentLine = "//"
})
whiteSpace = P.whiteSpace lexer
reserved = P.reserved lexer
identifier = P.identifier lexer
stringLit = P.stringLiteral lexer
comma = P.comma lexer
commaSep = P.commaSep lexer
commaSep1 = P.commaSep1 lexer
parens = P.parens lexer
braces = P.braces lexer
squares = P.squares lexer
semiSep = P.semiSep lexer
symbol = P.symbol lexer
errorFile =
do
whiteSpace
errors <- many1 errorClass
return errors
errorClass =
do
reserved "errors"
name <- identifier
classE <- identifier
errors <- braces $ many1 (errorCase classE)
symbol ";" <?> " ';' missing from end of " ++ name ++ " error definition"
return $ ErrorClass name errors
errorCase classE =
do
successCase classE
<|> (failureCase classE)
<|> (defaultSuccessCase classE)
defaultSuccessCase classE =
do
reserved "default"
(ErrorField _ name descr) <- successCase classE
return $ ErrorField DefaultSuccess name descr
successCase classE =
do
reserved "success"
acronym <- identifier
description <- stringLit
symbol "," <?> " ',' missing from end of " ++ acronym ++ " definition"
return $ ErrorField Success (classE ++ acronym) description
failureCase classE =
do
reserved "failure"
acronym <- identifier
description <- stringLit
symbol "," <?> " ',' missing from end of " ++ acronym ++ " definition"
return $ ErrorField Failure (classE ++ acronym) description
|
modeswitch/barrelfish
|
tools/fugu/Parser.hs
|
Haskell
|
mit
| 2,938
|
-- String array joining in Haskell
-- http://www.codewars.com/kata/5436bb1df0c10d280900131f
module JoinedWords where
joinS :: [String] -> String -> String
joinS l s = drop (length s) (foldl (\str w -> str ++ s ++ w) "" l)
|
gafiatulin/codewars
|
src/7 kyu/JoinedWords.hs
|
Haskell
|
mit
| 224
|
module Main where
import Marc
import Data.List
import System.Environment
import Options.Applicative
data MarcDumpOptions = MarcDumpOptions
{
file :: String
,recordNumbersAndOffsets :: Bool
}
runWithOptions :: MarcDumpOptions -> IO ()
runWithOptions opts = do
s <- readFile $ file opts
let records = readBatchFromString s
mapM_ (putStrLn . marcDumpFormat) records
main :: IO ()
main = execParser opts >>= runWithOptions
where
parser = MarcDumpOptions <$> argument str (metavar "file")
<*> switch (short 'p' <>
long "print" <>
help "print numbers")
opts = info parser (
fullDesc
<> progDesc "MARCDUMP utility"
<> header "MARCDUmp")
|
ccatalfo/marc
|
src/Main.hs
|
Haskell
|
mit
| 714
|
import Text.ParserCombinators.Parsec hiding (spaces)
import System.Environment
import Control.Monad
data LispVal = Atom String
| List [LispVal]
| DottedList [LispVal] LispVal
| Number Integer
| String String
| Bool Bool
parseString :: Parser LispVal
parseString = do
char '"'
x <- many (noneOf "\"")
char '"'
return $ String x
parseAtom :: Parser LispVal
parseAtom = do
first <- letter <|> symbol
rest <- many (letter <|> digit <|> symbol)
let atom = first:rest
return $ case atom of
"#t" -> Bool True
"#f" -> Bool False
_ -> Atom atom
parseNumber :: Parser LispVal
parseNumber = do
x <- many1 digit
return $ Number $ read x
parseExpr :: Parser LispVal
parseExpr = parseAtom
<|> parseString
<|> parseNumber
symbol :: Parser Char
symbol = oneOf "!#$%&|*+-/:<=>?@^_~"
spaces :: Parser ()
spaces = skipMany1 space
readExpr :: String -> String
readExpr input = case parse parseExpr "lisp" input of
Left err -> "No match: " ++ show err
Right _ -> "Found value"
main :: IO ()
main = do
(expr:_) <- getArgs
putStrLn $ readExpr expr
|
mmwtsn/write-yourself-a-scheme
|
02-parsing/exercises/01-with-do.hs
|
Haskell
|
mit
| 1,145
|
module Bassbull where
import qualified Data.ByteString.Lazy as BL
import qualified Data.Foldable as F
import Data.Csv.Streaming
-- a simple type alias for data
type BaseballStats = (BL.ByteString, Int, BL.ByteString, Int)
getAtBatsSum :: FilePath -> IO Int
getAtBatsSum battingCsv = do
csvData <- BL.readFile battingCsv
return $ F.foldr summer 0 (baseballStats csvData)
baseballStats :: BL.ByteString -> Records BaseballStats
baseballStats = decode NoHeader
summer :: (a, b, c, Int) -> Int -> Int
summer = (+) . fourth
fourth :: (a, b, c, d) -> d
fourth (_, _, _, d) = d
|
Sgoettschkes/learning
|
haskell/HowIStart/bassbull/src/Bassbull.hs
|
Haskell
|
mit
| 583
|
{-# LANGUAGE BangPatterns #-}
-- Copyright © 2012 Bart Massey
-- [This program is licensed under the "MIT License"]
-- Please see the file COPYING in the source
-- distribution of this software for license terms.
import Control.Exception
import Control.Monad
import Data.Array.IO
import qualified Data.Bits as B
import qualified Data.ByteString.Lazy as BS
import Data.Char
import Data.Word
import System.Console.ParseArgs
import System.IO
data ArgInd = ArgEncrypt | ArgDecrypt | ArgKey | ArgReps
deriving (Ord, Eq, Show)
argd :: [ Arg ArgInd ]
argd = [
Arg {
argIndex = ArgEncrypt,
argName = Just "encrypt",
argAbbr = Just 'e',
argData = Nothing,
argDesc = "Use encryption mode."
},
Arg {
argIndex = ArgDecrypt,
argName = Just "decrypt",
argAbbr = Just 'd',
argData = Nothing,
argDesc = "Use decryption mode."
},
Arg {
argIndex = ArgKey,
argName = Just "key",
argAbbr = Just 'k',
argData = argDataOptional "keytext" ArgtypeString,
argDesc = "Encryption or decryption key (dangerous)."
},
Arg {
argIndex = ArgReps,
argName = Just "reps",
argAbbr = Just 'r',
argData = argDataDefaulted "repcount" ArgtypeInt 20,
argDesc = "Number of key sched reps (20 default, 1 for CS1)."
} ]
type CState = IOUArray Word8 Word8
fi :: (Integral a, Num b) => a -> b
fi = fromIntegral
initKeystream :: String -> [Word8] -> Int -> IO CState
initKeystream key iv reps = do
let keystream = concat $ replicate reps $
take 256 $ cycle $ map (fi . ord) key ++ iv
state <- newListArray (0, 255) [0..255]
mixArray keystream state (0, 0)
where
mixArray :: [Word8] -> CState -> (Word8, Word8) -> IO CState
mixArray (k : ks) a (i, j0) = do
si <- readArray a i
let j = j0 + si + k
sj <- readArray a j
writeArray a i sj
writeArray a j si
mixArray ks a (i + 1, j)
mixArray [] a (0, _) = return a
mixArray _ _ _ = error "internal error: bad mix state"
readIV :: IO [Word8]
readIV = do
ivs <- BS.hGet stdin 10
let ivl = BS.unpack ivs
return ivl
makeIV :: IO [Word8]
makeIV =
withBinaryFile "/dev/urandom" ReadMode $ \h ->
do
hSetBuffering h NoBuffering
ivs <- BS.hGet h 10
BS.hPut stdout ivs
return $ BS.unpack ivs
{-
accumMapM :: (Functor m, Monad m) => (a -> b -> m (a, b)) -> a -> [b] -> m [b]
accumMapM _ _ [] = return []
accumMapM a acc (b : bs) = do
(acc', b') <- a acc b
fmap (b' :) $ accumMapM a acc' bs
-}
accumMapM_ :: Monad m => (a -> b -> m a) -> a -> [b] -> m ()
accumMapM_ _ _ [] = return ()
accumMapM_ a acc (b : bs) = do
acc' <- a acc b
accumMapM_ a acc' bs
type Accum = ((Word8, Word8), CState)
stepRC4 :: Accum -> Char -> IO Accum
stepRC4 ((!i0, !j0), !state) !b = do
let !i = i0 + 1
!si <- readArray state i
let !j = j0 + si
!sj <- readArray state j
writeArray state j si
writeArray state i sj
!k <- readArray state (si + sj)
putChar $ chr $ fi $ B.xor k $ fi $ ord b
return ((i, j), state)
applyKeystream :: CState -> String -> IO ()
applyKeystream state intext =
accumMapM_ stepRC4 ((0, 0), state) intext
applyStreamCipher :: CState -> IO ()
applyStreamCipher state =
getContents >>= applyKeystream state
-- http://stackoverflow.com/a/4064482
getKey :: String -> IO String
getKey prompt = do
bracket
(openFile "/dev/tty" ReadWriteMode)
(\h -> hClose h)
(\h -> do
hPutStr h prompt
hFlush h
old <- hGetEcho h
key <- bracket_
(hSetEcho h False)
(hSetEcho h old)
(hGetLine h)
hPutStrLn h ""
return key)
main :: IO ()
main = do
hSetBinaryMode stdin True
hSetBinaryMode stdout True
hSetBuffering stdin $ BlockBuffering $ Just $ 64 * 1024
hSetBuffering stdout $ BlockBuffering $ Just $ 64 * 1024
argv <- parseArgsIO ArgsComplete argd
let e = gotArg argv ArgEncrypt
let d = gotArg argv ArgDecrypt
unless ((e && not d) || (d && not e)) $
usageError argv "Exactly one of -e or -d is required."
k <- case gotArg argv ArgKey of
True -> return $ getRequiredArg argv ArgKey
False -> getKey "key:"
let r = getRequiredArg argv ArgReps
unless (r > 0) $
usageError argv "Reps must be positive."
iv <- if e then makeIV else readIV
s <- initKeystream k iv r
applyStreamCipher s
|
BartMassey/ciphersaber
|
ciphersaber.hs
|
Haskell
|
mit
| 4,381
|
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE FlexibleInstances #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}
module Lucid.Server where
import Control.Monad
import qualified Data.ByteString.Char8 as SC
import Happstack.Server
import Lucid
-- | happstack server utils
serve :: ServerPart Response -> IO ()
serve response =
simpleHTTP (nullConf {port = 8001}) $ do
decodeBody (defaultBodyPolicy "/tmp/" 4096 4096 4096)
response
includeLibDir :: ServerPart Response -> ServerPart Response
includeLibDir page = msum
[ dir "" page
, dir "lib" $ serveDirectory EnableBrowsing [] "lib"
]
instance ToMessage (Html ()) where
toContentType _ = SC.pack "text/html; charset=UTF-8"
toMessage = renderBS
|
tonyday567/hdcharts
|
src/Lucid/Server.hs
|
Haskell
|
mit
| 753
|
{-# LANGUAGE QuasiQuotes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE OverloadedStrings #-}
module Hydrazine.Server.Boxen where
import Servant
import Control.Monad.Trans.Either
import Data.Functor.Identity
import Data.Time.LocalTime
import Control.Monad
import Data.Maybe
import Control.Monad.Trans.Class
import Control.Monad.Trans.Except
import qualified Hasql as H
import qualified Data.Text as T
import Hydrazine.JSON
import Hydrazine.Server.Postgres
getBoxen :: DBConn -> EitherT ServantErr IO [BoxInfo]
getBoxen conn = do
runTx conn (
do (boxen :: [(Int,T.Text,T.Text,Maybe Int,Maybe LocalTime,Bool)])
<- lift $ H.listEx $ [H.stmt|
SELECT id
, name
, mac
, boot_image
, boot_until
, boot_forever
FROM boxen
ORDER BY name ASC
|]
boxInfos <- forM boxen (\(boxId,_,_,mImg,_,_)
-> do mName <- case mImg of
Nothing -> return Nothing
Just imgId -> do
(mname :: Maybe (Identity T.Text))
<- lift $ H.maybeEx $ [H.stmt|
SELECT name
FROM images
WHERE id = ?
|] imgId
return (mname >>= (Just . unwrapId))
(bFlags :: [(T.Text,Maybe T.Text)])
<- lift $ H.listEx $ [H.stmt|
SELECT key
, value
FROM bootflags
WHERE box_id = ?
ORDER BY key ASC
|] boxId
(logs :: [(T.Text,LocalTime)])
<- lift $ H.listEx $ [H.stmt|
SELECT image_name
, boot_time
FROM boots
WHERE boots.box_id = ?
ORDER BY boots.boot_time DESC
|] boxId
return (mName,bFlags,logs)
)
return $ zip boxen boxInfos
)
( right . map (\((_,name,macaddr,_,mUntil,bForever),(mName,bFlags,logs)) ->
BoxInfo { boxName = name
, mac = formatMac macaddr
, boot = let fs = map (\(k,v) -> BootFlag k v) bFlags
in case mName of
Nothing -> Nothing
Just iName -> Just $ BootSettings
iName (BootUntil bForever mUntil) fs
, bootlogs = map (\(n,t) -> BootInstance n t) logs
})
)
getBox :: DBConn -> T.Text -> EitherT ServantErr IO BoxInfo
getBox conn n = do
runTx conn (
do (mBox :: Maybe (Int,T.Text,T.Text,Maybe Int,Maybe LocalTime,Bool))
<- lift $ H.maybeEx $ [H.stmt|
SELECT id
, name
, mac
, boot_image
, boot_until
, boot_forever
FROM boxen
WHERE name = ?
ORDER BY name ASC
|] n
when (isNothing mBox) $
throwE err404 { errBody = "machine not found" }
let box@(boxId,_,_,mImg,_,_) = fromJust mBox
mName <- case mImg of
Nothing -> return Nothing
Just imgId -> do
(mname :: Maybe (Identity T.Text))
<- lift $ H.maybeEx $ [H.stmt|
SELECT name
FROM images
WHERE id = ?
|] imgId
return (mname >>= (Just . unwrapId))
(bFlags :: [(T.Text,Maybe T.Text)])
<- lift $ H.listEx $ [H.stmt|
SELECT key
, value
FROM bootflags
WHERE box_id = ?
ORDER BY key ASC
|] boxId
(logs :: [(T.Text,LocalTime)])
<- lift $ H.listEx $ [H.stmt|
SELECT image_name
, boot_time
FROM boots
WHERE boots.box_id = ?
ORDER BY boots.boot_time DESC
|] boxId
return (box,mName,bFlags,logs)
)
(
\((_,_,macaddr,_,mUntil,bForever),mName,bFlags,logs) ->
right $
BoxInfo { boxName = n
, mac = formatMac macaddr
, boot = mName >>= (\iName -> Just $ BootSettings
iName (BootUntil bForever mUntil) (map (\(k,v) -> BootFlag k v) bFlags))
, bootlogs = map (\(i,t) -> BootInstance i t) logs
}
)
newBox :: DBConn -> T.Text -> NewBox -> EitherT ServantErr IO EmptyValue
newBox conn n (NewBox m) = do
runTx conn (do
(res :: Maybe (Identity Int)) <- lift $ H.maybeEx $ [H.stmt|
SELECT id
FROM "boxen"
WHERE name = ?
|] n
when (res /= Nothing) (throwE
err400 { errBody = "a box with that name already exists" })
(res' :: Maybe (Identity Int)) <- lift $ H.maybeEx $ [H.stmt|
SELECT id
FROM "boxen"
WHERE mac = ?
|] (stripMac m)
when (res' /= Nothing) (throwE
err400 { errBody = "a box with that MAC address already exists" })
lift $ H.unitEx $ [H.stmt|
INSERT INTO "boxen"
(name,mac)
VALUES
(?,?)
|] n (stripMac m)
) (returnEmptyValue)
updateBox :: DBConn -> T.Text -> UpdateBox -> EitherT ServantErr IO EmptyValue
updateBox conn name (UpdateBox img til fs) =
runTx conn (do
(boxId :: Maybe (Identity Int))
<- lift $ H.maybeEx $ [H.stmt|
SELECT id
FROM "boxen"
WHERE name = ?
|] name
when (isNothing boxId) $
throwE err400 { errBody = "a box with that name doesn't exist" }
when (isJust img) $
if (fromJust img) == ""
then lift $ H.unitEx $ [H.stmt|
UPDATE "boxen"
SET boot_image = NULL
WHERE name = ?
|] name
else do
(imgId :: Maybe (Identity Int))
<- lift $ H.maybeEx $ [H.stmt|
SELECT id
FROM "images"
WHERE name = ?
|] img
when (isNothing imgId) $
throwE err400 { errBody = "image doesn't exist" }
lift $ H.unitEx $ [H.stmt|
UPDATE "boxen"
SET boot_image = ?
WHERE name = ?
|] (unwrapId $ fromJust imgId) name
when (isNothing fs) $ do
lift $ H.unitEx $ [H.stmt|
DELETE FROM "bootflags"
WHERE box_id = ?
|] (unwrapId $ fromJust boxId)
(bfs :: [(T.Text,Maybe T.Text)])
<- lift $ H.listEx $ [H.stmt|
SELECT key
, value
FROM "defaultbootflags"
WHERE image_id = ?
|] (unwrapId $ fromJust imgId)
forM_ bfs (\(key,val) ->
lift $ H.unitEx $ [H.stmt|
INSERT INTO "bootflags"
(box_id,key,value)
VALUES
(?,?,?)
|] (unwrapId $ fromJust boxId) key val
)
when (isJust til) $
let (BootUntil bForever mUntil) = fromJust til
in lift $ H.unitEx $ [H.stmt|
UPDATE "boxen"
SET boot_forever = ?
, boot_until = ?
WHERE name = ?
|] bForever mUntil name
when (isJust fs) $ do
lift $ H.unitEx $ [H.stmt|
DELETE FROM "bootflags"
WHERE box_id = ?
|] (unwrapId $ fromJust boxId)
forM_ (fromJust fs) (\(BootFlag key val) ->
lift $ H.unitEx $ [H.stmt|
INSERT INTO "bootflags"
(box_id,key,value)
VALUES
(?,?,?)
|] (unwrapId $ fromJust boxId) key val
)
) (returnEmptyValue)
deleteBox :: DBConn -> T.Text -> EitherT ServantErr IO ()
deleteBox conn name =
runTx_ conn (do
(mBoxId :: Maybe (Identity Int))
<- lift $ H.maybeEx $ [H.stmt|
SELECT id
FROM "boxen"
WHERE name = ?
|] name
when (isNothing mBoxId) $
throwE err400 { errBody = "a box with that name doesn't exist" }
let boxId = unwrapId $ fromJust mBoxId
lift $ H.unitEx $ [H.stmt|
DELETE FROM "boots"
WHERE box_id = ?
|] boxId
lift $ H.unitEx $ [H.stmt|
DELETE FROM "bootflags"
WHERE box_id = ?
|] boxId
lift $ H.unitEx $ [H.stmt|
DELETE FROM "boxen"
WHERE id = ?
|] boxId
)
|
dgonyeo/hydrazine
|
src/Hydrazine/Server/Boxen.hs
|
Haskell
|
mit
| 10,840
|
-- mood.hs
module MoodIsBlahOrWoot where
data Mood = Blah | Woot deriving Show
changeMood Blah = Woot
changeMood _ = Blah
|
Lyapunov/haskell-programming-from-first-principles
|
chapter_4/mood.hs
|
Haskell
|
mit
| 127
|
module Problem17 where
import Data.Char (isSpace)
main = print $ sum $ map (length . filter (not . isSpace) . spellIt) [1..1000]
spellIt :: Int -> String
spellIt 1000 = "one thousand"
spellIt n | n >= 100 = spellIt (n `div` 100) ++ " hundred" ++ sep " and " (spellIt (n `rem` 100))
| n >= 90 = "ninety" ++ sep " " (spellIt (n `rem` 90))
| n >= 80 = "eighty" ++ sep " " (spellIt (n `rem` 80))
| n >= 70 = "seventy" ++ sep " " (spellIt (n `rem` 70))
| n >= 60 = "sixty" ++ sep " " (spellIt (n `rem` 60))
| n >= 50 = "fifty" ++ sep " " (spellIt (n `rem` 50))
| n >= 40 = "forty" ++ sep " " (spellIt (n `rem` 40))
| n >= 30 = "thirty" ++ sep " " (spellIt (n `rem` 30))
| n >= 20 = "twenty" ++ sep " " (spellIt (n `rem` 20))
where
sep a "" = ""
sep a b = a ++ b
spellIt 19 = "nineteen"
spellIt 18 = "eighteen"
spellIt 17 = "seventeen"
spellIt 16 = "sixteen"
spellIt 15 = "fifteen"
spellIt 14 = "fourteen"
spellIt 13 = "thirteen"
spellIt 12 = "twelve"
spellIt 11 = "eleven"
spellIt 10 = "ten"
spellIt 9 = "nine"
spellIt 8 = "eight"
spellIt 7 = "seven"
spellIt 6 = "six"
spellIt 5 = "five"
spellIt 4 = "four"
spellIt 3 = "three"
spellIt 2 = "two"
spellIt 1 = "one"
spellIt 0 = ""
|
DevJac/haskell-project-euler
|
src/Problem17.hs
|
Haskell
|
mit
| 1,304
|
{-# LANGUAGE NoImplicitPrelude #-}
-- |
-- Module: TestCase
-- Description: All test cases aggregated and exported as tests :: [Test].
-- Copyright: Copyright (c) 2015-2016 Jan Sipr
-- License: MIT
--
-- Stability: stable
-- Portability: NoImplicitPrelude
--
-- All test cases aggregated and exported as @'tests' :: ['Test']@.
module TestCase (tests)
where
import Test.Framework (Test, testGroup)
import qualified TestCase.Network.SIP.Parser as Parser (tests)
import qualified TestCase.Network.SIP.Parser.Header as Parser.Header (tests)
import qualified TestCase.Network.SIP.Parser.Line as Parser.Line (tests)
import qualified TestCase.Network.SIP.Parser.RequestMethod as
Parser.RequestMethod (tests)
import qualified TestCase.Network.SIP.Parser.Uri as Parser.Uri (tests)
import qualified TestCase.Network.SIP.Serialization as Serialization (tests)
import qualified TestCase.Network.SIP.Serialization.FirstLine as
Serialization.FirstLine (tests)
import qualified TestCase.Network.SIP.Serialization.Header as
Serialization.Header (tests)
import qualified TestCase.Network.SIP.Serialization.Status as
Serialization.Status (tests)
import qualified TestCase.Network.SIP.Serialization.Uri as
Serialization.Uri (tests)
tests :: [Test]
tests =
[ testGroup "TestCase.Network.SIP.Parser.Header" Parser.Header.tests
, testGroup "TestCase.Network.SIP.Parser.Line" Parser.Line.tests
, testGroup "TestCase.Network.SIP.Parser" Parser.tests
, testGroup "TestCase.Network.SIP.Parser.RequestMethod"
Parser.RequestMethod.tests
, testGroup "TestCase.Network.SIP.Parser.Uri" Parser.Uri.tests
, testGroup "TestCase.Network.SIP.Serialization"
Serialization.tests
, testGroup "TestCase.Network.SIP.Serialization.FirstLine"
Serialization.FirstLine.tests
, testGroup "TestCase.Network.SIP.Serialization.Header"
Serialization.Header.tests
, testGroup "TestCase.Network.SIP.Serialization.Status"
Serialization.Status.tests
, testGroup "TestCase.Network.SIP.Serialization.Uri"
Serialization.Uri.tests
]
|
Siprj/ragnarok
|
test/TestCase.hs
|
Haskell
|
mit
| 2,111
|
{-# language NoImplicitPrelude, DoAndIfThenElse, OverloadedStrings, ExtendedDefaultRules #-}
{-# LANGUAGE CPP, ScopedTypeVariables #-}
-- | Description : Argument parsing and basic messaging loop, using Haskell
-- Chans to communicate with the ZeroMQ sockets.
module Main (main) where
import IHaskellPrelude
import qualified Data.Text as T
import qualified Data.Text.Lazy as LT
import qualified Data.ByteString as BS
import qualified Data.ByteString.Lazy as LBS
import qualified Data.ByteString.Char8 as CBS
-- Standard library imports.
import Control.Concurrent (threadDelay)
import Control.Concurrent.Chan
import Control.Arrow (second)
import Data.Aeson
import System.Directory
import System.Process (readProcess, readProcessWithExitCode)
import System.Exit (exitSuccess, ExitCode(ExitSuccess))
import Control.Exception (try, SomeException)
import System.Environment (getArgs)
#if MIN_VERSION_ghc(7,8,0)
import System.Environment (setEnv)
#endif
import System.Posix.Signals
import qualified Data.Map as Map
import qualified Data.Text.Encoding as E
import Data.List (break, last)
import Data.Version (showVersion)
-- IHaskell imports.
import IHaskell.Convert (convert)
import IHaskell.Eval.Completion (complete)
import IHaskell.Eval.Inspect (inspect)
import IHaskell.Eval.Evaluate
import IHaskell.Display
import IHaskell.Eval.Info
import IHaskell.Eval.Widgets (widgetHandler)
import IHaskell.Flags
import IHaskell.IPython
import IHaskell.Types
import IHaskell.Publish
import IHaskell.IPython.ZeroMQ
import IHaskell.IPython.Types
import qualified IHaskell.IPython.Message.UUID as UUID
import qualified IHaskell.IPython.Stdin as Stdin
-- Cabal imports.
import Paths_ihaskell(version)
-- GHC API imports.
import GHC hiding (extensions, language)
-- | Compute the GHC API version number using the dist/build/autogen/cabal_macros.h
ghcVersionInts :: [Int]
ghcVersionInts = map (fromJust . readMay) . words . map dotToSpace $ VERSION_ghc
where
dotToSpace '.' = ' '
dotToSpace x = x
consoleBanner :: Text
consoleBanner =
"Welcome to IHaskell! Run `IHaskell --help` for more information.\n" <>
"Enter `:help` to learn more about IHaskell built-ins."
main :: IO ()
main = do
args <- parseFlags <$> getArgs
case args of
Left errorMessage -> hPutStrLn stderr errorMessage
Right args -> ihaskell args
ihaskell :: Args -> IO ()
ihaskell (Args (ShowDefault helpStr) args) = showDefault helpStr args
ihaskell (Args ConvertLhs args) = showingHelp ConvertLhs args $ convert args
ihaskell (Args InstallKernelSpec args) = showingHelp InstallKernelSpec args $ do
let kernelSpecOpts = parseKernelArgs args
replaceIPythonKernelspec kernelSpecOpts
ihaskell (Args (Kernel (Just filename)) args) = do
let kernelSpecOpts = parseKernelArgs args
runKernel kernelSpecOpts filename
ihaskell a@(Args (Kernel Nothing) _) = do
hPutStrLn stderr "No kernel profile JSON specified."
hPutStrLn stderr "This may be a bug!"
hPrint stderr a
showDefault :: String -> [Argument] -> IO ()
showDefault helpStr flags =
case find (== Version) flags of
Just _ ->
putStrLn (showVersion version)
Nothing ->
putStrLn helpStr
showingHelp :: IHaskellMode -> [Argument] -> IO () -> IO ()
showingHelp mode flags act =
case find (== Help) flags of
Just _ ->
putStrLn $ help mode
Nothing ->
act
-- | Parse initialization information from the flags.
parseKernelArgs :: [Argument] -> KernelSpecOptions
parseKernelArgs = foldl' addFlag defaultKernelSpecOptions
where
addFlag kernelSpecOpts (ConfFile filename) =
kernelSpecOpts { kernelSpecConfFile = return (Just filename) }
addFlag kernelSpecOpts KernelDebug =
kernelSpecOpts { kernelSpecDebug = True }
addFlag kernelSpecOpts (GhcLibDir libdir) =
kernelSpecOpts { kernelSpecGhcLibdir = libdir }
addFlag kernelSpecOpts (KernelspecInstallPrefix prefix) =
kernelSpecOpts { kernelSpecInstallPrefix = Just prefix }
addFlag kernelSpecOpts KernelspecUseStack =
kernelSpecOpts { kernelSpecUseStack = True }
addFlag kernelSpecOpts flag = error $ "Unknown flag" ++ show flag
-- | Run the IHaskell language kernel.
runKernel :: KernelSpecOptions -- ^ Various options from when the kernel was installed.
-> String -- ^ File with kernel profile JSON (ports, etc).
-> IO ()
runKernel kernelOpts profileSrc = do
let debug = kernelSpecDebug kernelOpts
libdir = kernelSpecGhcLibdir kernelOpts
useStack = kernelSpecUseStack kernelOpts
-- Parse the profile file.
let profileErr = error $ "ihaskell: "++profileSrc++": Failed to parse profile file"
profile <- liftM (fromMaybe profileErr . decode) $ LBS.readFile profileSrc
-- Necessary for `getLine` and their ilk to work.
dir <- getIHaskellDir
Stdin.recordKernelProfile dir profile
#if MIN_VERSION_ghc(7,8,0)
when useStack $ do
-- Detect if we have stack
runResult <- try $ readProcessWithExitCode "stack" [] ""
let stack =
case runResult :: Either SomeException (ExitCode, String, String) of
Left _ -> False
Right (exitCode, stackStdout, _) -> exitCode == ExitSuccess && "The Haskell Tool Stack" `isInfixOf` stackStdout
-- If we're in a stack directory, use `stack` to set the environment
-- We can't do this with base <= 4.6 because setEnv doesn't exist.
when stack $ do
stackEnv <- lines <$> readProcess "stack" ["exec", "env"] ""
forM_ stackEnv $ \line ->
let (var, val) = break (== '=') line
in case tailMay val of
Nothing -> return ()
Just val' -> setEnv var val'
#endif
-- Serve on all sockets and ports defined in the profile.
interface <- serveProfile profile debug
-- Create initial state in the directory the kernel *should* be in.
state <- initialKernelState
modifyMVar_ state $ \kernelState -> return $
kernelState { kernelDebug = debug }
-- Receive and reply to all messages on the shell socket.
interpret libdir True $ \hasSupportLibraries -> do
-- Ignore Ctrl-C the first time. This has to go inside the `interpret`, because GHC API resets the
-- signal handlers for some reason (completely unknown to me).
liftIO ignoreCtrlC
liftIO $ modifyMVar_ state $ \kernelState -> return $
kernelState { supportLibrariesAvailable = hasSupportLibraries }
-- Initialize the context by evaluating everything we got from the command line flags.
let noPublish _ = return ()
noWidget s _ = return s
evaluator line = void $ do
-- Create a new state each time.
stateVar <- liftIO initialKernelState
state <- liftIO $ takeMVar stateVar
evaluate state line noPublish noWidget
confFile <- liftIO $ kernelSpecConfFile kernelOpts
case confFile of
Just filename -> liftIO (readFile filename) >>= evaluator
Nothing -> return ()
forever $ do
-- Read the request from the request channel.
request <- liftIO $ readChan $ shellRequestChannel interface
-- Create a header for the reply.
replyHeader <- createReplyHeader (header request)
-- We handle comm messages and normal ones separately. The normal ones are a standard
-- request/response style, while comms can be anything, and don't necessarily require a response.
if isCommMessage request
then do
oldState <- liftIO $ takeMVar state
let replier = writeChan (iopubChannel interface)
widgetMessageHandler = widgetHandler replier replyHeader
tempState <- handleComm replier oldState request replyHeader
newState <- flushWidgetMessages tempState [] widgetMessageHandler
liftIO $ putMVar state newState
liftIO $ writeChan (shellReplyChannel interface) SendNothing
else do
-- Create the reply, possibly modifying kernel state.
oldState <- liftIO $ takeMVar state
(newState, reply) <- replyTo interface request replyHeader oldState
liftIO $ putMVar state newState
-- Write the reply to the reply channel.
liftIO $ writeChan (shellReplyChannel interface) reply
where
ignoreCtrlC =
installHandler keyboardSignal (CatchOnce $ putStrLn "Press Ctrl-C again to quit kernel.")
Nothing
isCommMessage req = msgType (header req) `elem` [CommDataMessage, CommCloseMessage]
-- Initial kernel state.
initialKernelState :: IO (MVar KernelState)
initialKernelState = newMVar defaultKernelState
-- | Create a new message header, given a parent message header.
createReplyHeader :: MessageHeader -> Interpreter MessageHeader
createReplyHeader parent = do
-- Generate a new message UUID.
newMessageId <- liftIO UUID.random
let repType = fromMaybe err (replyType $ msgType parent)
err = error $ "No reply for message " ++ show (msgType parent)
return
MessageHeader
{ identifiers = identifiers parent
, parentHeader = Just parent
, metadata = Map.fromList []
, messageId = newMessageId
, sessionId = sessionId parent
, username = username parent
, msgType = repType
}
-- | Compute a reply to a message.
replyTo :: ZeroMQInterface -> Message -> MessageHeader -> KernelState -> Interpreter (KernelState, Message)
-- Reply to kernel info requests with a kernel info reply. No computation needs to be done, as a
-- kernel info reply is a static object (all info is hard coded into the representation of that
-- message type).
replyTo _ KernelInfoRequest{} replyHeader state =
return
(state, KernelInfoReply
{ header = replyHeader
, protocolVersion = "5.0"
, banner = "IHaskell " ++ (showVersion version) ++ " GHC " ++ VERSION_ghc
, implementation = "IHaskell"
, implementationVersion = showVersion version
, languageInfo = LanguageInfo
{ languageName = "haskell"
, languageVersion = VERSION_ghc
, languageFileExtension = ".hs"
, languageCodeMirrorMode = "ihaskell"
}
})
replyTo _ CommInfoRequest{} replyHeader state =
let comms = Map.mapKeys (UUID.uuidToString) (openComms state) in
return
(state, CommInfoReply
{ header = replyHeader
, commInfo = Map.map (\(Widget w) -> targetName w) comms
})
-- Reply to a shutdown request by exiting the main thread. Before shutdown, reply to the request to
-- let the frontend know shutdown is happening.
replyTo interface ShutdownRequest { restartPending = restartPending } replyHeader _ = liftIO $ do
writeChan (shellReplyChannel interface) $ ShutdownReply replyHeader restartPending
exitSuccess
-- Reply to an execution request. The reply itself does not require computation, but this causes
-- messages to be sent to the IOPub socket with the output of the code in the execution request.
replyTo interface req@ExecuteRequest { getCode = code } replyHeader state = do
-- Convenience function to send a message to the IOPub socket.
let send msg = liftIO $ writeChan (iopubChannel interface) msg
-- Log things so that we can use stdin.
dir <- liftIO getIHaskellDir
liftIO $ Stdin.recordParentHeader dir $ header req
-- Notify the frontend that the kernel is busy computing. All the headers are copies of the reply
-- header with a different message type, because this preserves the session ID, parent header, and
-- other important information.
busyHeader <- liftIO $ dupHeader replyHeader StatusMessage
send $ PublishStatus busyHeader Busy
-- Construct a function for publishing output as this is going. This function accepts a boolean
-- indicating whether this is the final output and the thing to display. Store the final outputs in
-- a list so that when we receive an updated non-final output, we can clear the entire output and
-- re-display with the updated output.
displayed <- liftIO $ newMVar []
updateNeeded <- liftIO $ newMVar False
pagerOutput <- liftIO $ newMVar []
let execCount = getExecutionCounter state
-- Let all frontends know the execution count and code that's about to run
inputHeader <- liftIO $ dupHeader replyHeader InputMessage
send $ PublishInput inputHeader (T.unpack code) execCount
-- Run code and publish to the frontend as we go.
let widgetMessageHandler = widgetHandler send replyHeader
publish = publishResult send replyHeader displayed updateNeeded pagerOutput (usePager state)
updatedState <- evaluate state (T.unpack code) publish widgetMessageHandler
-- Notify the frontend that we're done computing.
idleHeader <- liftIO $ dupHeader replyHeader StatusMessage
send $ PublishStatus idleHeader Idle
-- Take pager output if we're using the pager.
pager <- if usePager state
then liftIO $ readMVar pagerOutput
else return []
return
(updatedState, ExecuteReply
{ header = replyHeader
, pagerOutput = pager
, executionCounter = execCount
, status = Ok
})
-- Check for a trailing empty line. If it doesn't exist, we assume the code is incomplete,
-- otherwise we assume the code is complete. Todo: Implement a mechanism that only requests
-- a trailing empty line, when multiline code is entered.
replyTo _ req@IsCompleteRequest{} replyHeader state = do
isComplete <- isInputComplete
let reply = IsCompleteReply { header = replyHeader, reviewResult = isComplete }
return (state, reply)
where
isInputComplete = do
let code = lines $ inputToReview req
if nub (last code) == " "
then return CodeComplete
else return $ CodeIncomplete $ indent 4
indent n = take n $ repeat ' '
replyTo _ req@CompleteRequest{} replyHeader state = do
let code = getCode req
pos = getCursorPos req
(matchedText, completions) <- complete (T.unpack code) pos
let start = pos - length matchedText
end = pos
reply = CompleteReply replyHeader (map T.pack completions) start end Map.empty True
return (state, reply)
replyTo _ req@InspectRequest{} replyHeader state = do
result <- inspect (T.unpack $ inspectCode req) (inspectCursorPos req)
let reply =
case result of
Just (Display datas) -> InspectReply
{ header = replyHeader
, inspectStatus = True
, inspectData = datas
}
_ -> InspectReply { header = replyHeader, inspectStatus = False, inspectData = [] }
return (state, reply)
-- TODO: Implement history_reply.
replyTo _ HistoryRequest{} replyHeader state = do
let reply = HistoryReply
{ header = replyHeader
-- FIXME
, historyReply = []
}
return (state, reply)
-- Accomodating the workaround for retrieving list of open comms from the kernel
--
-- The main idea is that the frontend opens a comm at kernel startup, whose target is a widget that
-- sends back the list of live comms and commits suicide.
--
-- The message needs to be written to the iopub channel, and not returned from here. If returned,
-- the same message also gets written to the shell channel, which causes issues due to two messages
-- having the same identifiers in their headers.
--
-- Sending the message only on the shell_reply channel doesn't work, so we send it as a comm message
-- on the iopub channel and return the SendNothing message.
replyTo interface open@CommOpen{} replyHeader state = do
let send msg = liftIO $ writeChan (iopubChannel interface) msg
incomingUuid = commUuid open
target = commTargetName open
targetMatches = target == "ipython.widget"
valueMatches = commData open == object ["widget_class" .= "ipywidgets.CommInfo"]
commMap = openComms state
uuidTargetPairs = map (second targetName) $ Map.toList commMap
pairProcessor (x, y) = T.pack (UUID.uuidToString x) .= object ["target_name" .= T.pack y]
currentComms = object $ map pairProcessor $ (incomingUuid, "comm") : uuidTargetPairs
replyValue = object [ "method" .= "custom"
, "content" .= object ["comms" .= currentComms]
]
msg = CommData replyHeader (commUuid open) replyValue
-- To the iopub channel you go
when (targetMatches && valueMatches) $ send msg
return (state, SendNothing)
-- TODO: What else can be implemented?
replyTo _ message _ state = do
liftIO $ hPutStrLn stderr $ "Unimplemented message: " ++ show message
return (state, SendNothing)
-- | Handle comm messages
handleComm :: (Message -> IO ()) -> KernelState -> Message -> MessageHeader -> Interpreter KernelState
handleComm send kernelState req replyHeader = do
-- MVars to hold intermediate data during publishing
displayed <- liftIO $ newMVar []
updateNeeded <- liftIO $ newMVar False
pagerOutput <- liftIO $ newMVar []
let widgets = openComms kernelState
uuid = commUuid req
dat = commData req
communicate value = do
head <- dupHeader replyHeader CommDataMessage
send $ CommData head uuid value
toUsePager = usePager kernelState
-- Create a publisher according to current state, use that to build
-- a function that executes an IO action and publishes the output to
-- the frontend simultaneously.
let run = capturedIO publish kernelState
publish = publishResult send replyHeader displayed updateNeeded pagerOutput toUsePager
-- Notify the frontend that the kernel is busy
busyHeader <- liftIO $ dupHeader replyHeader StatusMessage
liftIO . send $ PublishStatus busyHeader Busy
newState <- case Map.lookup uuid widgets of
Nothing -> return kernelState
Just (Widget widget) ->
case msgType $ header req of
CommDataMessage -> do
disp <- run $ comm widget dat communicate
pgrOut <- liftIO $ readMVar pagerOutput
liftIO $ publish $ FinalResult disp (if toUsePager then pgrOut else []) []
return kernelState
CommCloseMessage -> do
disp <- run $ close widget dat
pgrOut <- liftIO $ readMVar pagerOutput
liftIO $ publish $ FinalResult disp (if toUsePager then pgrOut else []) []
return kernelState { openComms = Map.delete uuid widgets }
-- Notify the frontend that the kernel is idle once again
idleHeader <- liftIO $ dupHeader replyHeader StatusMessage
liftIO . send $ PublishStatus idleHeader Idle
return newState
|
sumitsahrawat/IHaskell
|
main/Main.hs
|
Haskell
|
mit
| 18,868
|
{-
- Whidgle.Rules
-
- A mixture of game rules and heuristics.
-}
-- export everything
module Whidgle.Rules where
import Control.Lens
import Data.Function
import Whidgle.Types
-- How many steps away an opponent can be before we consider the possibility of attack behavior.
reasonablyClose :: Int
reasonablyClose = 10
-- The number of turns to plan for in the future.
nearFuture :: Int
nearFuture = 300
-- Constants dealing to avoidance of enemies.
attackDamage, wiggleRoom, gobboRoom, tavernRoom, tavernAvoid :: Int
attackDamage = 20 -- assume attacks do at least this much damage
wiggleRoom = 10 -- don't fight without at least this much wiggle-room
gobboRoom = 10 -- with less than this health, avoid gobbos
tavernRoom = 90 -- with less than this health, drink when near a tavern
tavernAvoid = 95 -- with more than this health, never drink near a tavern
-- Determine whether we need a drink.
needsDrink :: Int -> Hero -> Bool
-- be far more willing to drink when near a tavern than when far
-- dist * 5 : assumes about an opportunity cost of 2.5g/tile when drinking
needsDrink dist us =
us^.heroLife <= max (tavernRoom - dist * 5) wiggleRoom
-- Determines whether a hero should assail another hero.
-- (minding that we can't trust others to follow the same logic)
canFight :: Int -> Hero -> Hero -> Bool
canFight dist assailant target =
assailant^.heroLife - dist > target^.heroLife + wiggleRoom + attackDamage
-- Determines whether a hero can even assail another hero. If it's false, the
-- assailant will just get maimed to death.
canEverFight :: Int -> Hero -> Hero -> Bool
canEverFight dist assailant target =
assailant^.heroLife - dist > target^.heroLife + attackDamage
-- Determines whether a hero can take a mine without dying.
canTakeMine :: Int -> Hero -> Bool
canTakeMine dist us =
us^.heroLife - dist > gobboRoom + attackDamage
-- The score which indicates a venue is no longer worth pursuing, or that it must be pursued.
-- Think of it as an unenforced ceiling.
overwhelming :: Int
overwhelming = 1000
-- returns true if we should attack something given their current avoidance ratio
shouldAttackRatio :: (Int, Int) -> Bool
shouldAttackRatio = (<0.7) . uncurry ((/) `on` fromIntegral) -- require 7/10 misses at most
initialAvoidanceRatio :: (Int, Int)
initialAvoidanceRatio = (0, 2) -- begin assuming we've successfully attacked twice
|
Zekka/whidgle
|
src/Whidgle/Rules.hs
|
Haskell
|
mit
| 2,374
|
module Hecate.Error (module Hecate.Error) where
import Control.Exception (Exception)
import Data.Typeable (Typeable)
import TOML (TOMLError)
-- | 'AppError' represents application errors
data AppError
= CsvDecoding String
| TOML TOMLError
| Configuration String
| Aeson String
| GPG String
| Database String
| FileSystem String
| AmbiguousInput String
| Migration String
| Default String
deriving (Typeable)
instance Show AppError where
show (CsvDecoding s) = "CSV Decoding Error: " ++ s
show (TOML e) = show e
show (Configuration s) = "Configuration Error: " ++ s
show (Aeson s) = "Aeson Error: " ++ s
show (GPG s) = s
show (Database s) = "Database Error: " ++ s
show (FileSystem s) = "Filesystem Error: " ++ s
show (AmbiguousInput s) = "Ambiguous Input: " ++ s
show (Migration s) = "Migration Error: " ++ s
show (Default s) = "Error: " ++ s
instance Exception AppError
|
henrytill/hecate
|
src/Hecate/Error.hs
|
Haskell
|
apache-2.0
| 1,021
|
module Redigo where
|
aloiscochard/redigo
|
src/Redigo.hs
|
Haskell
|
apache-2.0
| 20
|
{-# LANGUAGE CPP #-}
{-# LANGUAGE ForeignFunctionInterface #-}
{-# LANGUAGE JavaScriptFFI #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE PackageImports #-}
{-
Copyright 2015 Google Inc. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-}
{-
Thanks to Luite Stegeman, whose code this is heavily based on.
Note that this code is very dependent on the internals of GHCJS, so
complain if this is broken. It's not unlikely.
-}
{- If you want to do these things you are a bad person and you should feel bad -}
module Internal.DeepEq where
import Control.Exception (evaluate)
import Control.Monad
import "base" Prelude
import System.IO.Unsafe
import Unsafe.Coerce
#ifdef ghcjs_HOST_OS
import GHCJS.Foreign
import GHCJS.Types
import JavaScript.Array
-- traverse the object and get the thunks out of it
foreign import javascript unsafe "cw$getThunks($1)"
js_getThunks :: Int -> IO JSArray
foreign import javascript unsafe "cw$deepEq($1, $2)"
js_deepEq :: Int -> Int -> IO Bool
data JSRefD a = JSRefD a
evaluateFully :: a -> IO a
evaluateFully x = do
x' <- evaluate x
ths <- js_getThunks (unsafeCoerce x')
when (not $ isNull $ unsafeCoerce ths) $ forM_ (toList ths) evalElem
return x'
where
evalElem :: JSRef Int -> IO ()
evalElem y =
let (JSRefD o) = unsafeCoerce y in void (evaluateFully o)
deepEq :: a -> a -> Bool
deepEq x y = unsafePerformIO $ do
x' <- evaluateFully x
y' <- evaluateFully y
js_deepEq (unsafeCoerce x') (unsafeCoerce y')
#else
evaluateFully :: a -> IO a
evaluateFully x = error "Only available with GHCJS"
deepEq :: a -> a -> Bool
deepEq x y = error "Only available with GHCJS"
#endif
|
d191562687/codeworld
|
codeworld-base/src/Internal/DeepEq.hs
|
Haskell
|
apache-2.0
| 2,323
|
module Segments.Common.Time where
import Data.Time (formatTime, defaultTimeLocale)
import Data.Time.LocalTime (getZonedTime)
import Segments.Base
-- powerline.segments.common.time.date
timeDateSegment :: SegmentHandler
timeDateSegment args _ = do
let isTime = argLookup args "istime" False
let fmt = argLookup args "format" "%Y-%m-%d"
let hlGroup = flip HighlightGroup Nothing $
if isTime
then "time"
else "date"
t <- getZonedTime
return2 $ Segment hlGroup $ formatTime defaultTimeLocale fmt t
|
rdnetto/powerline-hs
|
src/Segments/Common/Time.hs
|
Haskell
|
apache-2.0
| 583
|
module HEP.Util.Parsing where
import Control.Monad.Identity
import Control.Exception (bracket)
import Text.Parsec
import System.IO
readConfig :: (Show a) => FilePath -> (ParsecT String () Identity a) -> IO a
readConfig fp parser = do
putStrLn fp
bracket (openFile fp ReadMode) hClose $ \fh -> do
str <- hGetContents fh
let r = parse parser "" str
case r of
Right result -> do putStrLn (show result)
return $! result
Left err -> error (show err)
|
wavewave/HEPUtil
|
src/HEP/Util/Parsing.hs
|
Haskell
|
bsd-2-clause
| 512
|
{-# LANGUAGE TemplateHaskell, QuasiQuotes, OverloadedStrings #-}
module Handler.Forening where
import Import
getForeningR :: Forening -> Handler Html
getForeningR forening = standardLayout $(widgetFile "forening")
|
dtekcth/DtekPortalen
|
src/Handler/Forening.hs
|
Haskell
|
bsd-2-clause
| 216
|
{-# LANGUAGE OverloadedLists #-}
module FnReps.Polynomial.UnaryChebSparse where
import FnReps.Polynomial.UnaryChebSparse.DCTMultiplication
--import Numeric.AERN.MPFRBasis.Interval
import Numeric.AERN.DoubleBasis.Interval ()
import qualified Data.HashMap.Strict as HM
{-|
Unary polynomials over the domain [-1,1] with interval coefficients in the Chebyshev basis.
The interval coefficients are supposed to have a very small width.
-}
data UnaryChebSparse =
UnaryChebSparse
{
unaryChebSparse_terms :: HM.HashMap Int RA
}
-- deriving (Show)
instance Show UnaryChebSparse where
show (UnaryChebSparse terms) =
"(UnaryChebSparse " ++ show (HM.toList terms) ++ ")"
instance Eq UnaryChebSparse where
(==) = error "cannot compare UnaryChebSparse interval polynomials for equality, please use ==? instead of == etc."
instance Ord UnaryChebSparse where
compare = error "cannot compare UnaryChebSparse interval polynomials for equality, please use >? instead of > etc."
instance Num UnaryChebSparse where
fromInteger n = UnaryChebSparse (HM.singleton 0 (fromInteger n))
abs _ = error $ "abs not implemented for UnaryChebSparse interval polynomials."
signum _ = error $ "signum not implemented for UnaryChebSparse interval polynomials."
negate (UnaryChebSparse terms) =
UnaryChebSparse $ fmap negate terms
(UnaryChebSparse termsL) + (UnaryChebSparse termsR) =
UnaryChebSparse $ HM.unionWith (+) termsL termsR
(UnaryChebSparse terms1) * (UnaryChebSparse terms2) =
UnaryChebSparse $ multiplyDCT_terms terms1 terms2
|
michalkonecny/aern
|
aern-fnreps/src/FnReps/Polynomial/UnaryChebSparse.hs
|
Haskell
|
bsd-3-clause
| 1,628
|
{-# LANGUAGE TemplateHaskell, TypeFamilies #-}
module Linear.NURBS.Types (
Weight(..), weightPoint, weightValue, ofWeight, weight, wpoint,
Span(..), spanStart, spanEnd,
KnotData(..), knotData, knotDataAt, knotDataSpan,
NURBS(..), nurbsPoints, nurbsKnot, nurbsKnoti, nurbsDegree
) where
import Prelude.Unicode
import Control.Lens
import Linear.Vector hiding (basis)
import Linear.Affine
import Linear.Metric
-- | Point with weight
data Weight f a = Weight { _weightPoint ∷ f a, _weightValue ∷ a } deriving (Eq, Ord, Read, Show)
makeLenses ''Weight
-- | Make point with weight
ofWeight ∷ Additive f ⇒ f a → a → Weight f a
pt `ofWeight` w = Weight pt w
-- | Weight lens
weight ∷ (Additive f, Fractional a) ⇒ Lens' (Weight f a) a
weight = lens fromw tow where
fromw (Weight _ w) = w
tow (Weight pt w) w' = Weight ((w' / w) *^ pt) w'
-- | Point lens
wpoint ∷ (Additive f, Additive g, Fractional a) ⇒ Lens (Weight f a) (Weight g a) (f a) (g a)
wpoint = lens fromw tow where
fromw (Weight pt w) = (1.0 / w) *^ pt
tow (Weight _ w) pt' = Weight (w *^ pt') w
instance Functor f ⇒ Functor (Weight f) where
fmap f (Weight pt w) = Weight (fmap f pt) (f w)
instance Traversable f ⇒ Traversable (Weight f) where
traverse f (Weight pt w) = Weight <$> traverse f pt <*> f w
instance Additive f ⇒ Additive (Weight f) where
zero = Weight zero 0
Weight lx lw ^+^ Weight rx rw = Weight (lx ^+^ rx) (lw + rw)
Weight lx lw ^-^ Weight rx rw = Weight (lx ^-^ rx) (lw - rw)
lerp a (Weight lx lw) (Weight rx rw) = Weight (lerp a lx rx) (a * lw + (1 - a) * rw)
liftU2 f (Weight lx lw) (Weight rx rw) = Weight (liftU2 f lx rx) (f lw rw)
liftI2 f (Weight lx lw) (Weight rx rw) = Weight (liftI2 f lx rx) (f lw rw)
instance Affine f ⇒ Affine (Weight f) where
type Diff (Weight f) = Weight (Diff f)
Weight lx lw .-. Weight rx rw = Weight (lx .-. rx) (lw - rw)
Weight lx lw .+^ Weight x w = Weight (lx .+^ x) (lw + w)
Weight lx lw .-^ Weight x w = Weight (lx .-^ x) (lw - w)
instance Foldable f ⇒ Foldable (Weight f) where
foldMap f (Weight x w) = foldMap f x `mappend` f w
instance Metric f ⇒ Metric (Weight f) where
dot (Weight lx lw) (Weight rx rw) = dot lx rx + lw * rw
-- | Knot span
data Span a = Span {
_spanStart ∷ a,
_spanEnd ∷ a }
deriving (Eq, Ord, Read)
makeLenses ''Span
instance Functor Span where
fmap f (Span s e) = Span (f s) (f e)
instance Foldable Span where
foldMap f (Span s e) = f s `mappend` f e
instance Traversable Span where
traverse f (Span s e) = Span <$> f s <*> f e
instance Show a ⇒ Show (Span a) where
show (Span s e) = show (s, e)
-- | Knot evaluation data, used to compute basis functions
data KnotData a = KnotData {
_knotDataAt ∷ a,
_knotDataSpan ∷ Span a,
_knotData ∷ [(Span a, a)] }
deriving (Eq, Ord, Read, Show)
makeLenses ''KnotData
-- | NURBS
data NURBS f a = NURBS {
_nurbsPoints ∷ [Weight f a],
_nurbsKnot ∷ [a],
_nurbsDegree ∷ Int }
deriving (Eq, Ord, Read, Show)
makeLenses ''NURBS
instance Functor f ⇒ Functor (NURBS f) where
fmap f (NURBS pts k d) = NURBS (map (fmap f) pts) (map f k) d
instance Foldable f ⇒ Foldable (NURBS f) where
foldMap f (NURBS pts k _) = mconcat (map (foldMap f) pts) `mappend` mconcat (map f k)
nurbsKnoti ∷ Lens' (NURBS f a) [a]
nurbsKnoti = lens fromn ton where
fromn (NURBS wpts k d)
| length k ≡ succ (length wpts) = k
| otherwise = drop d $ reverse $ drop d $ reverse k
ton (NURBS wpts k d) k'
| length k ≡ succ (length wpts) = NURBS wpts k' d
| otherwise = NURBS wpts (replicate d (k' ^?! _head) ++ k' ++ replicate d (k' ^?! _last)) d
|
mvoidex/nurbs
|
src/Linear/NURBS/Types.hs
|
Haskell
|
bsd-3-clause
| 3,622
|
import Data.List (findIndex, sortBy)
import Data.Function (on)
import Data.Maybe (fromJust)
import Data.Array
import Data.Array.ST
import Control.Monad (forM_)
import Control.Monad.ST
import Text.Printf
squares = ["GO", "A1", "CC1", "A2", "T1", "R1", "B1", "CH1", "B2", "B3", "JAIL", "C1", "U1", "C2", "C3", "R2", "D1", "CC2", "D2", "D3", "FP", "E1", "CH2", "E2", "E3", "R3", "F1", "F2", "U2", "F3", "G2J", "G1", "G2", "CC3", "G3", "R4", "CH3", "H1", "T2", "H2"]
nDice = 4
nSquare = length squares
getIndex :: String -> Int
getIndex square = fromJust $ findIndex (== square) squares
fall :: String -> [String]
fall "G2J" = ["JAIL"]
fall cc@('C':'C':c) = "GO" : "JAIL" : replicate 14 cc
fall ch@('C':'H':c) = "GO" : "JAIL" : "C1" : "E3" : "H2" : "R1" : nextR : nextR : nextU : back3 : replicate 6 ch where
index = getIndex ch
back3 = squares !! ((index - 3) `mod` nSquare)
nextR = case c of
"1" -> "R2"
"2" -> "R3"
"3" -> "R1"
nextU = case c of
"1" -> "U1"
"2" -> "U2"
"3" -> "U1"
fall x = [x]
type State = (Int, Int) -- (sqr, doubles)
type StateArray = Array State Double
go' :: State -> Double -> [(State, Double)]
go' (sqr, doubles) prob = concat $ do
x <- [1 .. nDice]
y <- [1 .. nDice]
let doubles' = if x == y then (doubles + 1) else 0
let sqr' = squares !! ((sqr + x + y) `mod` nSquare)
let (sqr'', doubles'') = tryGoJail (sqr', doubles')
let falls = fall sqr''
let prob'' = prob / ((fromIntegral nDice) ^ 2) / (fromIntegral (length falls))
return $ zip (zip (map getIndex falls) (repeat doubles'')) (repeat prob'') where
tryGoJail (_, 3) = ("JAIL", 0)
tryGoJail x = x
go :: StateArray -> StateArray
go probs = runSTArray $ do
ret <- newArray ((0, 0), (nSquare - 1, 2)) 0 :: ST s (STArray s State Double)
forM_ [0 .. nSquare - 1] $ \sqr -> do
forM_ [0 .. 2] $ \doubles -> do
let expands = go' (sqr, doubles) (probs!(sqr, doubles))
forM_ expands $ \((sqr', doubles'), prob') -> do
old <- readArray ret (sqr', doubles')
writeArray ret (sqr', doubles') (old + prob')
return ret
goIter :: StateArray -> Int -> StateArray
goIter probs 0 = probs
goIter probs count = goIter (go probs) (count - 1)
solve :: Array Int Double
solve = runSTArray $ do
ret <- newArray (0, nSquare - 1) 0 :: ST s (STArray s Int Double)
let probs = goIter init 233
forM_ [0 .. nSquare - 1] $ \sqr -> do
writeArray ret sqr ((probs!(sqr, 0)) + (probs!(sqr, 1)) + (probs!(sqr, 2)))
return ret
where init = listArray ((0, 0), (nSquare - 1, 2)) (1 : repeat 0)
main = putStrLn $ concat $ map (printNum . fst) $ take 3 $ reverse $ sortBy (compare `on` snd) (assocs solve) where
printNum :: Int -> String
printNum = printf "%02d"
|
foreverbell/project-euler-solutions
|
src/84.hs
|
Haskell
|
bsd-3-clause
| 2,834
|
-- !!! Testing Refs
import Data.IORef
a1 =
newIORef 'a' >>= \ v ->
readIORef v >>= \ x ->
print x
a2 =
newIORef 'a' >>= \ v ->
writeIORef v 'b' >>
readIORef v >>= \ x ->
print x
a3 =
newIORef 'a' >>= \ v1 ->
newIORef 'a' >>= \ v2 ->
print (v1 == v1, v1 == v2, v2 == v2)
|
FranklinChen/Hugs
|
tests/rts/refs.hs
|
Haskell
|
bsd-3-clause
| 293
|
module EmbedTest where
import Syntax
import Driving
import Util.Miscellaneous
checkStep = Invoke "cS"
step = Invoke "s"
getAnswer = Invoke "gA"
getTime = Invoke "gT"
add = Invoke "a"
checkPerson = Invoke "cP"
movePerson = Invoke "mP"
moveLight = Invoke "mL"
times = Invoke "t"
ololo = Invoke "ololo"
g1 = [checkStep([C "St" [C "T" [], C "T" [], C "T" []],V 3,C "T" []]) , step([C "St" [C "T" [], C "T" [], C "T" []],V 3,V 7]) , getAnswer([V 4, V 7, C "some" [V 8]]) , getTime([V 3, V 10]) , add([V 10,V 8, V 9])]
g2 = [checkPerson([C "St" [C "T" [], C "T" [], C "T" []],V 36,C "T" []]) , movePerson([C "St" [C "T" [], C "T" [], C "T" []],V 36,V 21]) , moveLight([V 21,V 7]) , checkStep([V 7, V 26,C "T" []]) , step([V 7, V 26,V 30]) , getAnswer([V 27,V 30,C "some" [V 31]]) , getTime([V 26,V 33]) , add([V 33,V 31,V 32]) , times([V 36,C "S" [V 41]]) , add([V 41,C "S" [V 32],V 9])]
g3 = [checkPerson([C "St" [C "T" [], C "T" [], C "T" []],V 36,C "T" []]) , movePerson([C "St" [C "T" [], C "T" [], C "T" []],V 36,V 21]) , moveLight([V 21,V 7]) , checkStep([V 7, V 26,C "T" []]) , ololo([]), step([V 7, V 26,V 30]) , getAnswer([V 27,V 30,C "some" [V 31]]) , getTime([V 26,V 33]) , add([V 33,V 31,V 32]) , times([V 36,C "S" [V 41]]) , add([V 41,C "S" [V 32],V 9])]
test = embedGoals g1 g2
test' = map (map trd3) (split (map (\ x -> (undefined, undefined, x)) g3) g1)
|
kajigor/uKanren_transformations
|
test/EmbedTest.hs
|
Haskell
|
bsd-3-clause
| 1,502
|
{-# Language TypeFamilies #-}
module Data.Source.ByteString.Lazy.Char8.Offset where
import Data.Char
import Data.Source.Class
import qualified Data.ByteString.Lazy as B
data Src
= Src
{ loc :: Int
, str :: B.ByteString
} deriving (Eq,Ord,Show,Read)
mkSrc :: B.ByteString -> Src
mkSrc = Src 0
instance Source Src where
type Location Src = Int
type Element Src = Char
type Token Src = B.ByteString
type Error Src = ()
offset = loc
uncons (Src loc bs)
= Right $ B.uncons bs >>= \(w,t) ->
let ch = chr $ fromIntegral w
in return (ch, Src (loc+1) t)
view (Src loc bs) _ eh nh
= case B.uncons bs of
Nothing -> eh
Just (w,t) -> let ch = chr $ fromIntegral w
in nh ch $ Src (loc+1) t
location (Src ofs _)
= ofs
token (Src lloc lbs) (Src rloc _)
= B.take (fromIntegral $ rloc - lloc) lbs
|
permeakra/source
|
Data/Source/ByteString/Lazy/Char8/Offset.hs
|
Haskell
|
bsd-3-clause
| 932
|
{-# LANGUAGE BangPatterns, CPP, Rank2Types, ScopedTypeVariables,
TypeOperators #-}
-- |
-- Module: Data.BloomFilter
-- Copyright: Bryan O'Sullivan
-- License: BSD3
--
-- Maintainer: Bryan O'Sullivan <bos@serpentine.com>
-- Stability: unstable
-- Portability: portable
--
-- A fast, space efficient Bloom filter implementation. A Bloom
-- filter is a set-like data structure that provides a probabilistic
-- membership test.
--
-- * Queries do not give false negatives. When an element is added to
-- a filter, a subsequent membership test will definitely return
-- 'True'.
--
-- * False positives /are/ possible. If an element has not been added
-- to a filter, a membership test /may/ nevertheless indicate that
-- the element is present.
--
-- This module provides low-level control. For an easier to use
-- interface, see the "Data.BloomFilter.Easy" module.
module Data.BloomFilter
(
-- * Overview
-- $overview
-- ** Ease of use
-- $ease
-- ** Performance
-- $performance
-- * Types
Hash
, Bloom
, MBloom
-- * Immutable Bloom filters
-- ** Creation
, unfoldB
, fromListB
, emptyB
, singletonB
-- ** Accessors
, lengthB
, elemB
, notElemB
-- ** Mutators
, insertB
, insertListB
-- * Mutable Bloom filters
-- ** Immutability wrappers
, createB
, modifyB
-- ** Creation
, newMB
, unsafeFreezeMB
, thawMB
-- ** Accessors
, lengthMB
, elemMB
-- ** Mutation
, insertMB
-- * The underlying representation
-- | If you serialize the raw bit arrays below to disk, do not
-- expect them to be portable to systems with different
-- conventions for endianness or word size.
-- | The raw bit array used by the immutable 'Bloom' type.
, bitArrayB
-- | The raw bit array used by the immutable 'MBloom' type.
, bitArrayMB
-- | Reconstruction
, constructB
) where
#include "MachDeps.h"
import Control.Monad (liftM, forM_)
import Control.Monad.ST (ST, runST)
import Control.DeepSeq (NFData(..))
import Data.Array.Base (unsafeAt, unsafeRead, unsafeWrite)
import Data.Array.ST (STUArray, thaw, unsafeFreeze)
import Data.Array.Unboxed (UArray, assocs)
import Data.Bits ((.&.), (.|.))
import Data.BloomFilter.Array (newArray)
import Data.BloomFilter.Util (FastShift(..), (:*)(..), nextPowerOfTwo)
import Data.Word (Word32)
-- Make sure we're not performing any expensive arithmetic operations.
import Prelude hiding ((/), div, divMod, mod, rem)
{-
import Debug.Trace
traceM :: (Show a, Monad m) => a -> m ()
traceM v = show v `trace` return ()
traces :: Show a => a -> b -> b
traces s = trace (show s)
-}
-- | A hash value is 32 bits wide. This limits the maximum size of a
-- filter to about four billion elements, or 512 megabytes of memory.
type Hash = Word32
-- | A mutable Bloom filter, for use within the 'ST' monad.
data MBloom s a = MB {
hashMB :: !(a -> [Hash])
, shiftMB :: {-# UNPACK #-} !Int
, maskMB :: {-# UNPACK #-} !Int
, bitArrayMB :: {-# UNPACK #-} !(STUArray s Int Hash)
}
-- | An immutable Bloom filter, suitable for querying from pure code.
data Bloom a = B {
hashB :: !(a -> [Hash])
, shiftB :: {-# UNPACK #-} !Int
, maskB :: {-# UNPACK #-} !Int
, bitArrayB :: {-# UNPACK #-} !(UArray Int Hash)
}
instance Show (MBloom s a) where
show mb = "MBloom { " ++ show (lengthMB mb) ++ " bits } "
instance Show (Bloom a) where
show ub = "Bloom { " ++ show (lengthB ub) ++ " bits } "
instance NFData (Bloom a) where
rnf !_ = ()
-- | Create a new mutable Bloom filter. For efficiency, the number of
-- bits used may be larger than the number requested. It is always
-- rounded up to the nearest higher power of two, but clamped at a
-- maximum of 4 gigabits, since hashes are 32 bits in size.
--
-- For a safer creation interface, use 'createB'. To convert a
-- mutable filter to an immutable filter for use in pure code, use
-- 'unsafeFreezeMB'.
newMB :: (a -> [Hash]) -- ^ family of hash functions to use
-> Int -- ^ number of bits in filter
-> ST s (MBloom s a)
newMB hash numBits = MB hash shift mask `liftM` newArray numElems numBytes
where twoBits | numBits < 1 = 1
| numBits > maxHash = maxHash
| isPowerOfTwo numBits = numBits
| otherwise = nextPowerOfTwo numBits
numElems = max 2 (twoBits `shiftR` logBitsInHash)
numBytes = numElems `shiftL` logBytesInHash
trueBits = numElems `shiftL` logBitsInHash
shift = logPower2 trueBits
mask = trueBits - 1
isPowerOfTwo n = n .&. (n - 1) == 0
maxHash :: Int
#if WORD_SIZE_IN_BITS == 64
maxHash = 4294967296
#else
maxHash = 1073741824
#endif
logBitsInHash :: Int
logBitsInHash = 5 -- logPower2 bitsInHash
logBytesInHash :: Int
logBytesInHash = 2 -- logPower2 (sizeOf (undefined :: Hash))
-- | Create an immutable Bloom filter, using the given setup function
-- which executes in the 'ST' monad.
--
-- Example:
--
-- @
--import "Data.BloomFilter.Hash" (cheapHashes)
--
--filter = createB (cheapHashes 3) 1024 $ \mf -> do
-- insertMB mf \"foo\"
-- insertMB mf \"bar\"
-- @
--
-- Note that the result of the setup function is not used.
createB :: (a -> [Hash]) -- ^ family of hash functions to use
-> Int -- ^ number of bits in filter
-> (forall s. (MBloom s a -> ST s z)) -- ^ setup function (result is discarded)
-> Bloom a
{-# INLINE createB #-}
createB hash numBits body = runST $ do
mb <- newMB hash numBits
_ <- body mb
unsafeFreezeMB mb
-- | Create an empty Bloom filter.
--
-- This function is subject to fusion with 'insertB'
-- and 'insertListB'.
emptyB :: (a -> [Hash]) -- ^ family of hash functions to use
-> Int -- ^ number of bits in filter
-> Bloom a
{-# INLINE [1] emptyB #-}
emptyB hash numBits = createB hash numBits (\_ -> return ())
-- | Create a Bloom filter with a single element.
--
-- This function is subject to fusion with 'insertB'
-- and 'insertListB'.
singletonB :: (a -> [Hash]) -- ^ family of hash functions to use
-> Int -- ^ number of bits in filter
-> a -- ^ element to insert
-> Bloom a
{-# INLINE [1] singletonB #-}
singletonB hash numBits elt = createB hash numBits (\mb -> insertMB mb elt)
-- | Given a filter's mask and a hash value, compute an offset into
-- a word array and a bit offset within that word.
hashIdx :: Int -> Word32 -> (Int :* Int)
hashIdx mask x = (y `shiftR` logBitsInHash) :* (y .&. hashMask)
where hashMask = 31 -- bitsInHash - 1
y = fromIntegral x .&. mask
-- | Hash the given value, returning a list of (word offset, bit
-- offset) pairs, one per hash value.
hashesM :: MBloom s a -> a -> [Int :* Int]
hashesM mb elt = hashIdx (maskMB mb) `map` hashMB mb elt
-- | Hash the given value, returning a list of (word offset, bit
-- offset) pairs, one per hash value.
hashesU :: Bloom a -> a -> [Int :* Int]
hashesU ub elt = hashIdx (maskB ub) `map` hashB ub elt
-- | Insert a value into a mutable Bloom filter. Afterwards, a
-- membership query for the same value is guaranteed to return @True@.
insertMB :: MBloom s a -> a -> ST s ()
insertMB mb elt = do
let mu = bitArrayMB mb
forM_ (hashesM mb elt) $ \(word :* bit) -> do
old <- unsafeRead mu word
unsafeWrite mu word (old .|. (1 `shiftL` bit))
-- | Query a mutable Bloom filter for membership. If the value is
-- present, return @True@. If the value is not present, there is
-- /still/ some possibility that @True@ will be returned.
elemMB :: a -> MBloom s a -> ST s Bool
elemMB elt mb = loop (hashesM mb elt)
where mu = bitArrayMB mb
loop ((word :* bit):wbs) = do
i <- unsafeRead mu word
if i .&. (1 `shiftL` bit) == 0
then return False
else loop wbs
loop _ = return True
-- | Query an immutable Bloom filter for membership. If the value is
-- present, return @True@. If the value is not present, there is
-- /still/ some possibility that @True@ will be returned.
elemB :: a -> Bloom a -> Bool
elemB elt ub = all test (hashesU ub elt)
where test (off :* bit) = (bitArrayB ub `unsafeAt` off) .&. (1 `shiftL` bit) /= 0
modifyB :: (forall s. (MBloom s a -> ST s z)) -- ^ mutation function (result is discarded)
-> Bloom a
-> Bloom a
{-# INLINE modifyB #-}
modifyB body ub = runST $ do
mb <- thawMB ub
_ <- body mb
unsafeFreezeMB mb
-- | Create a new Bloom filter from an existing one, with the given
-- member added.
--
-- This function may be expensive, as it is likely to cause the
-- underlying bit array to be copied.
--
-- Repeated applications of this function with itself are subject to
-- fusion.
insertB :: a -> Bloom a -> Bloom a
{-# NOINLINE insertB #-}
insertB elt = modifyB (flip insertMB elt)
-- | Create a new Bloom filter from an existing one, with the given
-- members added.
--
-- This function may be expensive, as it is likely to cause the
-- underlying bit array to be copied.
--
-- Repeated applications of this function with itself are subject to
-- fusion.
insertListB :: [a] -> Bloom a -> Bloom a
{-# NOINLINE insertListB #-}
insertListB elts = modifyB $ \mb -> mapM_ (insertMB mb) elts
{-# RULES "Bloom insertB . insertB" forall a b u.
insertB b (insertB a u) = insertListB [a,b] u
#-}
{-# RULES "Bloom insertListB . insertB" forall x xs u.
insertListB xs (insertB x u) = insertListB (x:xs) u
#-}
{-# RULES "Bloom insertB . insertListB" forall x xs u.
insertB x (insertListB xs u) = insertListB (x:xs) u
#-}
{-# RULES "Bloom insertListB . insertListB" forall xs ys u.
insertListB xs (insertListB ys u) = insertListB (xs++ys) u
#-}
{-# RULES "Bloom insertListB . emptyB" forall h n xs.
insertListB xs (emptyB h n) = fromListB h n xs
#-}
{-# RULES "Bloom insertListB . singletonB" forall h n x xs.
insertListB xs (singletonB h n x) = fromListB h n (x:xs)
#-}
-- | Query an immutable Bloom filter for non-membership. If the value
-- /is/ present, return @False@. If the value is not present, there
-- is /still/ some possibility that @True@ will be returned.
notElemB :: a -> Bloom a -> Bool
notElemB elt ub = any test (hashesU ub elt)
where test (off :* bit) = (bitArrayB ub `unsafeAt` off) .&. (1 `shiftL` bit) == 0
-- | Create an immutable Bloom filter from a mutable one. The mutable
-- filter /must not/ be modified afterwards, or a runtime crash may
-- occur. For a safer creation interface, use 'createB'.
unsafeFreezeMB :: MBloom s a -> ST s (Bloom a)
unsafeFreezeMB mb = B (hashMB mb) (shiftMB mb) (maskMB mb) `liftM`
unsafeFreeze (bitArrayMB mb)
-- | Copy an immutable Bloom filter to create a mutable one. There is
-- no non-copying equivalent.
thawMB :: Bloom a -> ST s (MBloom s a)
thawMB ub = MB (hashB ub) (shiftB ub) (maskB ub) `liftM` thaw (bitArrayB ub)
-- bitsInHash :: Int
-- bitsInHash = sizeOf (undefined :: Hash) `shiftL` 3
-- | Return the size of a mutable Bloom filter, in bits.
lengthMB :: MBloom s a -> Int
lengthMB = shiftL 1 . shiftMB
-- | Return the size of an immutable Bloom filter, in bits.
lengthB :: Bloom a -> Int
lengthB = shiftL 1 . shiftB
-- | Build an immutable Bloom filter from a seed value. The seeding
-- function populates the filter as follows.
--
-- * If it returns 'Nothing', it is finished producing values to
-- insert into the filter.
--
-- * If it returns @'Just' (a,b)@, @a@ is added to the filter and
-- @b@ is used as a new seed.
unfoldB :: forall a b. (a -> [Hash]) -- ^ family of hash functions to use
-> Int -- ^ number of bits in filter
-> (b -> Maybe (a, b)) -- ^ seeding function
-> b -- ^ initial seed
-> Bloom a
{-# INLINE unfoldB #-}
unfoldB hashes numBits f k = createB hashes numBits (loop k)
where loop :: forall s. b -> MBloom s a -> ST s ()
loop j mb = case f j of
Just (a, j') -> insertMB mb a >> loop j' mb
_ -> return ()
-- | Create an immutable Bloom filter, populating it from a list of
-- values.
--
-- Here is an example that uses the @cheapHashes@ function from the
-- "Data.BloomFilter.Hash" module to create a hash function that
-- returns three hashes.
--
-- @
--import "Data.BloomFilter.Hash" (cheapHashes)
--
--filt = fromListB (cheapHashes 3) 1024 [\"foo\", \"bar\", \"quux\"]
-- @
fromListB :: (a -> [Hash]) -- ^ family of hash functions to use
-> Int -- ^ number of bits in filter
-> [a] -- ^ values to populate with
-> Bloom a
{-# INLINE [1] fromListB #-}
fromListB hashes numBits list = createB hashes numBits $ forM_ list . insertMB
{-# RULES "Bloom insertListB . fromListB" forall h n xs ys.
insertListB xs (fromListB h n ys) = fromListB h n (xs ++ ys)
#-}
{-
-- This is a simpler definition, but GHC doesn't inline the unfold
-- sensibly.
fromListB hashes numBits = unfoldB hashes numBits convert
where convert (x:xs) = Just (x, xs)
convert _ = Nothing
-}
-- | Slow, crummy way of computing the integer log of an integer known
-- to be a power of two.
logPower2 :: Int -> Int
logPower2 k = go 0 k
where go j 1 = j
go j n = go (j+1) (n `shiftR` 1)
-- $overview
--
-- Each of the functions for creating Bloom filters accepts two parameters:
--
-- * The number of bits that should be used for the filter. Note that
-- a filter is fixed in size; it cannot be resized after creation.
--
-- * A function that accepts a value, and should return a fixed-size
-- list of hashes of that value. To keep the false positive rate
-- low, the hashes computes should, as far as possible, be
-- independent.
--
-- By choosing these parameters with care, it is possible to tune for
-- a particular false positive rate. The @suggestSizing@ function in
-- the "Data.BloomFilter.Easy" module calculates useful estimates for
-- these parameters.
-- $ease
--
-- This module provides both mutable and immutable interfaces for
-- creating and querying a Bloom filter. It is most useful as a
-- low-level way to create a Bloom filter with a custom set of
-- characteristics, perhaps in combination with the hashing functions
-- in 'Data.BloomFilter.Hash'.
--
-- For a higher-level interface that is easy to use, see the
-- 'Data.BloomFilter.Easy' module.
-- $performance
--
-- The implementation has been carefully tuned for high performance
-- and low space consumption.
--
-- For efficiency, the number of bits requested when creating a Bloom
-- filter is rounded up to the nearest power of two. This lets the
-- implementation use bitwise operations internally, instead of much
-- more expensive multiplication, division, and modulus operations.
-- Reconstruction
{-# INLINE constructB #-}
constructB :: (a -> [Hash])
-> UArray Int Hash
-> Bloom a
constructB hash array = B hash shift mask array
where
assc = assocs array
numElems = length assc
numBytes = numElems * (2 ^ logBytesInHash)
trueBits = numElems `shiftL` logBitsInHash
shift = logPower2 trueBits
mask = trueBits - 1
|
brinchj/bloomfilter
|
Data/BloomFilter.hs
|
Haskell
|
bsd-3-clause
| 15,366
|
-- | Facilities for composing SOAC functions. Mostly intended for use
-- by the fusion module, but factored into a separate module for ease
-- of testing, debugging and development. Of course, there is nothing
-- preventing you from using the exported functions whereever you
-- want.
--
-- Important: this module is \"dumb\" in the sense that it does not
-- check the validity of its inputs, and does not have any
-- functionality for massaging SOACs to be fusible. It is assumed
-- that the given SOACs are immediately compatible.
--
-- The module will, however, remove duplicate inputs after fusion.
module Futhark.Optimise.Fusion.Composing
( fuseMaps
, fuseRedomap
, mergeReduceOps
)
where
import Data.List
import qualified Data.HashMap.Lazy as HM
import qualified Data.HashSet as HS
import qualified Data.Map as M
import Data.Maybe
import qualified Futhark.Analysis.HORepresentation.SOAC as SOAC
import Futhark.Representation.AST
import Futhark.Binder
(Bindable(..), insertBinding, insertBindings, mkLet')
import Futhark.Construct (mapResult)
-- | @fuseMaps lam1 inp1 out1 lam2 inp2@ fuses the function @lam1@ into
-- @lam2@. Both functions must be mapping functions, although @lam2@
-- may have leading reduction parameters. @inp1@ and @inp2@ are the
-- array inputs to the SOACs containing @lam1@ and @lam2@
-- respectively. @out1@ are the identifiers to which the output of
-- the SOAC containing @lam1@ is bound. It is nonsensical to call
-- this function unless the intersection of @out1@ and @inp2@ is
-- non-empty.
--
-- If @lam2@ accepts more parameters than there are elements in
-- @inp2@, it is assumed that the surplus (which are positioned at the
-- beginning of the parameter list) are reduction (accumulator)
-- parameters, that do not correspond to array elements, and they are
-- thus not modified.
--
-- The result is the fused function, and a list of the array inputs
-- expected by the SOAC containing the fused function.
fuseMaps :: Bindable lore =>
Names -- ^ The producer var names that still need to be returned
-> Lambda lore -- ^ Function of SOAC to be fused.
-> [SOAC.Input] -- ^ Input of SOAC to be fused.
-> [(VName,Ident)] -- ^ Output of SOAC to be fused. The
-- first identifier is the name of the
-- actual output, where the second output
-- is an identifier that can be used to
-- bind a single element of that output.
-> Lambda lore -- ^ Function to be fused with.
-> [SOAC.Input] -- ^ Input of SOAC to be fused with.
-> (Lambda lore, [SOAC.Input]) -- ^ The fused lambda and the inputs of
-- the resulting SOAC.
fuseMaps unfus_nms lam1 inp1 out1 lam2 inp2 = (lam2', HM.elems inputmap)
where lam2' =
lam2 { lambdaParams = [ Param name t
| Ident name t <- lam2redparams ++ HM.keys inputmap ]
, lambdaBody = new_body2'
}
new_body2 = let bnds res = [ mkLet' [] [p] $ PrimOp $ SubExp e
| (p,e) <- zip pat res]
bindLambda res =
bnds res `insertBindings` makeCopiesInner (lambdaBody lam2)
in makeCopies $ mapResult bindLambda (lambdaBody lam1)
new_body2_rses = bodyResult new_body2
new_body2'= new_body2 { bodyResult = new_body2_rses ++
map (Var . identName) unfus_pat }
-- infusible variables are added at the end of the result/pattern/type
(lam2redparams, unfus_pat, pat, inputmap, makeCopies, makeCopiesInner) =
fuseInputs unfus_nms lam1 inp1 out1 lam2 inp2
--(unfus_accpat, unfus_arrpat) = splitAt (length unfus_accs) unfus_pat
fuseInputs :: Bindable lore =>
Names
-> Lambda lore -> [SOAC.Input] -> [(VName,Ident)]
-> Lambda lore -> [SOAC.Input]
-> ([Ident], [Ident], [Ident],
HM.HashMap Ident SOAC.Input,
Body lore -> Body lore, Body lore -> Body lore)
fuseInputs unfus_nms lam1 inp1 out1 lam2 inp2 =
(lam2redparams, unfus_vars, outbnds, inputmap, makeCopies, makeCopiesInner)
where (lam2redparams, lam2arrparams) =
splitAt (length lam2params - length inp2) lam2params
lam1params = map paramIdent $ lambdaParams lam1
lam2params = map paramIdent $ lambdaParams lam2
lam1inputmap = HM.fromList $ zip lam1params inp1
lam2inputmap = HM.fromList $ zip lam2arrparams inp2
(lam2inputmap', makeCopiesInner) = removeDuplicateInputs lam2inputmap
originputmap = lam1inputmap `HM.union` lam2inputmap'
outins = uncurry (outParams $ map fst out1) $
unzip $ HM.toList lam2inputmap'
outbnds= filterOutParams out1 outins
(inputmap, makeCopies) =
removeDuplicateInputs $ originputmap `HM.difference` outins
-- Cosmin: @unfus_vars@ is supposed to be the lam2 vars corresponding to unfus_nms (?)
getVarParPair x = case SOAC.isVarInput (snd x) of
Just nm -> Just (nm, fst x)
Nothing -> Nothing --should not be reached!
outinsrev = HM.fromList $ mapMaybe getVarParPair $ HM.toList outins
unfusible outname
| outname `HS.member` unfus_nms =
outname `HM.lookup` HM.union outinsrev (HM.fromList out1)
unfusible _ = Nothing
unfus_vars= mapMaybe (unfusible . fst) out1
outParams :: [VName] -> [Ident] -> [SOAC.Input]
-> HM.HashMap Ident SOAC.Input
outParams out1 lam2arrparams inp2 =
HM.fromList $ mapMaybe isOutParam $ zip lam2arrparams inp2
where isOutParam (p, inp)
| Just a <- SOAC.isVarInput inp,
a `elem` out1 = Just (p, inp)
isOutParam _ = Nothing
filterOutParams :: [(VName,Ident)]
-> HM.HashMap Ident SOAC.Input
-> [Ident]
filterOutParams out1 outins =
snd $ mapAccumL checkUsed outUsage out1
where outUsage = HM.foldlWithKey' add M.empty outins
where add m p inp =
case SOAC.isVarInput inp of
Just v -> M.insertWith (++) v [p] m
Nothing -> m
checkUsed m (a,ra) =
case M.lookup a m of
Just (p:ps) -> (M.insert a ps m, p)
_ -> (m, ra)
removeDuplicateInputs :: Bindable lore =>
HM.HashMap Ident SOAC.Input
-> (HM.HashMap Ident SOAC.Input, Body lore -> Body lore)
removeDuplicateInputs = fst . HM.foldlWithKey' comb ((HM.empty, id), M.empty)
where comb ((parmap, inner), arrmap) par arr =
case M.lookup arr arrmap of
Nothing -> ((HM.insert par arr parmap, inner),
M.insert arr (identName par) arrmap)
Just par' -> ((parmap, inner . forward par par'),
arrmap)
forward to from b =
mkLet' [] [to] (PrimOp $ SubExp $ Var from)
`insertBinding` b
fuseRedomap :: Bindable lore =>
Names -> [VName]
-> [SubExp] -> Lambda lore -> [SOAC.Input] -> [(VName,Ident)]
-> Lambda lore -> [SOAC.Input]
-> (Lambda lore, [SOAC.Input])
fuseRedomap unfus_nms outVars p_nes p_lam p_inparr outPairs c_lam c_inparr =
-- We hack the implementation of map o redomap to handle this case:
-- (i) we remove the accumulator formal paramter and corresponding
-- (body) result from from redomap's fold-lambda body
let acc_len = length p_nes
unfus_arrs = filter (`HS.member` unfus_nms) outVars
lam1_body = lambdaBody p_lam
lam1_accres = take acc_len $ bodyResult lam1_body
lam1_arrres = drop acc_len $ bodyResult lam1_body
lam1_hacked = p_lam { lambdaParams = drop acc_len $ lambdaParams p_lam
, lambdaBody = lam1_body { bodyResult = lam1_arrres }
, lambdaReturnType = drop acc_len $ lambdaReturnType p_lam }
-- (ii) we remove the accumulator's (global) output result from
-- @outPairs@, then ``map o redomap'' fuse the two lambdas
-- (in the usual way), and construct the extra return types
-- for the arrays that fall through.
(res_lam, new_inp) = fuseMaps (HS.fromList unfus_arrs) lam1_hacked p_inparr
(drop acc_len outPairs) c_lam c_inparr
(_,extra_rtps) = unzip $ filter (\(nm,_)->elem nm unfus_arrs) $
zip (drop acc_len outVars) $ drop acc_len $
lambdaReturnType p_lam
-- (iii) Finally, we put back the accumulator's formal parameter and
-- (body) result in the first position of the obtained lambda.
(accrtps, accpars) = ( take acc_len $ lambdaReturnType p_lam
, take acc_len $ lambdaParams p_lam )
res_body = lambdaBody res_lam
res_rses = bodyResult res_body
res_body'= res_body { bodyResult = lam1_accres ++ res_rses }
res_lam' = res_lam { lambdaParams = accpars ++ lambdaParams res_lam
, lambdaBody = res_body'
, lambdaReturnType = accrtps ++ lambdaReturnType res_lam ++ extra_rtps
}
in (res_lam', new_inp)
mergeReduceOps :: Bindable lore => Lambda lore -> Lambda lore -> Lambda lore
mergeReduceOps (Lambda par1 bdy1 rtp1) (Lambda par2 bdy2 rtp2) =
let body' = Body (bodyLore bdy1)
(bodyBindings bdy1 ++ bodyBindings bdy2)
(bodyResult bdy1 ++ bodyResult bdy2)
(len1, len2) = (length rtp1, length rtp2)
par' = take len1 par1 ++ take len2 par2 ++ drop len1 par1 ++ drop len2 par2
in Lambda par' body' (rtp1++rtp2)
|
mrakgr/futhark
|
src/Futhark/Optimise/Fusion/Composing.hs
|
Haskell
|
bsd-3-clause
| 9,930
|
{-# LANGUAGE CPP #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE MultiWayIf #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE UnicodeSyntax #-}
import Shake
import Foreign.Storable (sizeOf)
import System.Console.GetOpt
import System.IO
import Control.Applicative
import Control.Concurrent
import Control.Eternal
import Control.Exception
import Control.Monad
main ∷ IO ()
main = do
shakeArgs ← getArgs
current ← getCurrentDirectory
let (actions, _, _) = getOpt RequireOrder shakeOptions shakeArgs
Options { optPlatform = platform
, optForce = force
, optPretend = test
} ← foldl (>>=) (return defaultOptions) actions
shakeIt shakeArgs current force test platform
data Options = Options
{ optPlatform ∷ String
, optForce ∷ Bool
, optPretend ∷ Bool
}
defaultOptions ∷ Options
defaultOptions = Options {
optPlatform = if | os ∈ ["win32", "mingw32", "cygwin32"] →
if sizeOf (undefined :: Int) == 8 then "Win_x64"
else "Win"
| os ∈ ["darwin"] → "Mac"
| otherwise → "Linux"
, optForce = False
, optPretend = False
}
shakeOptions ∷ [OptDescr (Options → IO Options)]
shakeOptions = [
Option "v" ["version"] (NoArg showV) "Display Version",
Option "h" ["help"] (NoArg displayHelp) "Display Help",
Option "p" ["platform"] (ReqArg getp "STRING") "operating system platform",
Option "f" ["force"] (NoArg forceRebuild) "force script rebuild",
Option "P" ["pretend"] (NoArg pretend) "pretend building (testing shake script)"
]
getp ∷ ∀ (m :: * → *). Monad m ⇒ String → Options → m Options
forceRebuild ∷ ∀ (m ∷ * → *). Monad m ⇒ Options → m Options
pretend ∷ ∀ (m ∷ * → *). Monad m ⇒ Options → m Options
-- note ο is not o but greek ο instead ^__^
getp arg ο = return ο { optPlatform = arg }
forceRebuild ο = return ο { optForce = True }
pretend ο = return ο { optPretend = True }
displayHelp ο = do
prg ← getProgName
hPutStrLn stderr (usageInfo prg shakeOptions)
return ο { optForce = True }
|
Heather/Shake.it.off
|
src/Main.hs
|
Haskell
|
bsd-3-clause
| 2,343
|
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE ExistentialQuantification #-}
{-# LANGUAGE DataKinds #-}
module Control.Eff.Internal.Eff (Eff(..),run,runM,runTCQ,send) where
import Control.Eff.Internal.Union
import Control.Eff.Internal.TCQ
data Eff r a = Pure a | forall x. Eff (Union r x) (TCQ (Eff r) x a)
instance Functor (Eff r) where
{-# INLINE fmap #-}
fmap f (Pure a) = Pure (f a)
fmap f (Eff u q) = Eff u (Then q (Singleton (Pure . f)))
instance Applicative (Eff r) where
{-# INLINE pure #-}
pure = Pure
{-# INLINE (<*>) #-}
Pure f <*> Pure x = Pure $ f x
Pure f <*> Eff u q = Eff u (Then q (Singleton (Pure . f)))
Eff u q <*> Pure x = Eff u (Then q (Singleton (Pure . ($x))))
Eff u q <*> ex = Eff u (Then q (Singleton (<$> ex)))
instance Monad (Eff r) where
{-# INLINE return #-}
return = Pure
{-# INLINE (>>=) #-}
Pure x >>= f = f x
Eff u q >>= f = Eff u (Then q (Singleton f))
{-# INLINE runTCQ #-}
runTCQ :: TCQ (Eff r) a b -> a -> Eff r b
runTCQ tcq x = case viewl tcq of
FirstL k -> k x
ConsL k t -> case k x of
Pure n -> runTCQ t n
Eff u q -> Eff u (Then q t)
run :: Eff '[] a -> a
run (Pure x) = x
run (Eff _ _) = error "User is a magician"
runM :: Monad m => Eff '[m] a -> m a
runM (Pure x) = return x
runM (Eff u q) = extract u >>= runM . runTCQ q
{-# INLINE send #-}
send :: Member q r => q a -> Eff r a
send qa = Eff (inject qa) (Singleton Pure)
|
Lazersmoke/reee-monads
|
src/Control/Eff/Internal/Eff.hs
|
Haskell
|
bsd-3-clause
| 1,522
|
{-# LANGUAGE PackageImports #-}
import "hitweb" Application (getApplicationDev)
import Network.Wai.Handler.Warp
(runSettings, defaultSettings, settingsPort)
import Control.Concurrent (forkIO)
import System.Directory (doesFileExist, removeFile)
import System.Exit (exitSuccess)
import Control.Concurrent (threadDelay)
main :: IO ()
main = do
putStrLn "Starting devel application"
(port, app) <- getApplicationDev
forkIO $ runSettings defaultSettings
{ settingsPort = port
} app
loop
loop :: IO ()
loop = do
threadDelay 100000
e <- doesFileExist "yesod-devel/devel-terminate"
if e then terminateDevel else loop
terminateDevel :: IO ()
terminateDevel = exitSuccess
|
NicolasDP/hitweb
|
devel.hs
|
Haskell
|
bsd-3-clause
| 707
|
{-# language CPP #-}
{-# language QuasiQuotes #-}
{-# language TemplateHaskell #-}
#ifndef ENABLE_INTERNAL_DOCUMENTATION
{-# OPTIONS_HADDOCK hide #-}
#endif
module OpenCV.Internal.Core.Types.Point.TH
( mkPointType
) where
import "base" Data.List ( intercalate )
import "base" Data.Monoid ( (<>) )
import "base" Foreign.Marshal.Alloc ( alloca )
import "base" Foreign.Storable ( peek )
import "base" System.IO.Unsafe ( unsafePerformIO )
import qualified "inline-c" Language.C.Inline.Unsafe as CU
import "linear" Linear ( V2(..), V3(..) )
import "template-haskell" Language.Haskell.TH
import "template-haskell" Language.Haskell.TH.Quote ( quoteExp )
import "this" OpenCV.Internal.C.PlacementNew.TH ( mkPlacementNewInstance )
import "this" OpenCV.Internal.C.Types
import "this" OpenCV.Internal.Core.Types.Point
import "this" OpenCV.Internal
mkPointType
:: String -- ^ Point type name, for both Haskell and C
-> Integer -- ^ Point dimension
-> String -- ^ Point template name in C
-> Name -- ^ Depth type name in Haskell
-> String -- ^ Depth type name in C
-> Q [Dec]
mkPointType pTypeNameStr dim cTemplateStr depthTypeName cDepthTypeStr
| dim < 2 || dim > 3 = fail $ "mkPointType: Unsupported dimension: " <> show dim
| otherwise =
fmap concat . sequence $
[ pure <$> pointTySynD
, fromPtrDs
, isPointOpenCVInstanceDs
, isPointHaskellInstanceDs
, mkPlacementNewInstance pTypeName
]
where
pTypeName :: Name
pTypeName = mkName pTypeNameStr
cPointTypeStr :: String
cPointTypeStr = pTypeNameStr
pTypeQ :: Q Type
pTypeQ = conT pTypeName
depthTypeQ :: Q Type
depthTypeQ = conT depthTypeName
dimTypeQ :: Q Type
dimTypeQ = litT (numTyLit dim)
pointTySynD :: Q Dec
pointTySynD =
tySynD pTypeName
[]
([t|Point|] `appT` dimTypeQ `appT` depthTypeQ)
fromPtrDs :: Q [Dec]
fromPtrDs =
[d|
instance FromPtr $(pTypeQ) where
fromPtr = objFromPtr Point $ $(finalizerExpQ)
|]
where
finalizerExpQ :: Q Exp
finalizerExpQ = do
ptr <- newName "ptr"
lamE [varP ptr] $
quoteExp CU.exp $
"void { delete $(" <> cPointTypeStr <> " * " <> nameBase ptr <> ") }"
isPointOpenCVInstanceDs :: Q [Dec]
isPointOpenCVInstanceDs =
[d|
instance IsPoint (Point $(dimTypeQ)) $(depthTypeQ) where
toPoint = id
toPointIO = pure
fromPoint = id
|]
isPointHaskellInstanceDs :: Q [Dec]
isPointHaskellInstanceDs =
let ix = fromInteger dim - 2
in withLinear (linearTypeQs !! ix)
(linearConNames !! ix)
where
linearTypeQs :: [Q Type]
linearTypeQs = map conT [''V2, ''V3]
linearConNames :: [Name]
linearConNames = ['V2, 'V3]
withLinear :: Q Type -> Name -> Q [Dec]
withLinear lpTypeQ lvConName =
[d|
instance IsPoint $(lpTypeQ) $(depthTypeQ) where
toPoint = unsafePerformIO . toPointIO
toPointIO = $(toPointIOExpQ)
fromPoint = $(fromPointExpQ)
|]
where
toPointIOExpQ :: Q Exp
toPointIOExpQ = do
ns <- mapM newName elemNames
lamE [conP lvConName $ map varP ns]
$ appE [e|fromPtr|]
$ quoteExp CU.exp
$ inlineCStr ns
where
inlineCStr :: [Name] -> String
inlineCStr ns = concat
[ cPointTypeStr
, " * { new cv::" <> cTemplateStr
, "<" <> cDepthTypeStr <> ">"
, "(" <> intercalate ", " (map elemQuote ns) <> ")"
, " }"
]
where
elemQuote :: Name -> String
elemQuote n = "$(" <> cDepthTypeStr <> " " <> nameBase n <> ")"
fromPointExpQ :: Q Exp
fromPointExpQ = do
point <- newName "point"
pointPtr <- newName "pointPtr"
ptrNames <- mapM (newName . (<> "Ptr")) elemNames
withPtrNames point pointPtr ptrNames
where
withPtrNames :: Name -> Name -> [Name] -> Q Exp
withPtrNames point pointPtr ptrNames =
lamE [varP point]
$ appE [e|unsafePerformIO|]
$ withPtrVarsExpQ ptrNames
where
withPtrVarsExpQ :: [Name] -> Q Exp
withPtrVarsExpQ = foldr (\p -> appE [e|alloca|] . lamE [varP p]) withAllocatedVars
withAllocatedVars :: Q Exp
withAllocatedVars =
appE ([e|withPtr|] `appE` varE point)
$ lamE [varP pointPtr]
$ doE
[ noBindS $ quoteExp CU.block inlineCStr
, noBindS extractExpQ
]
inlineCStr :: String
inlineCStr = unlines $
concat
[ "void {"
, "const cv::" <> cTemplateStr
, "<" <> cDepthTypeStr <> ">"
, " & p = *$("
, cPointTypeStr
, " * "
, nameBase pointPtr
, ");"
]
: map ptrLine (zip [0..] ptrNames)
<> ["}"]
where
ptrLine :: (Int, Name) -> String
ptrLine (ix, ptrName) =
"*$(" <> cDepthTypeStr <> " * " <> nameBase ptrName <> ") = p." <> elemNames !! ix <> ";"
-- Applies the constructor to the values that are
-- read from the pointers.
extractExpQ :: Q Exp
extractExpQ = foldl (\acc peekExp -> [e|(<*>)|] `appE` acc `appE` peekExp)
([e|pure|] `appE` conE lvConName)
peekExpQs
where
peekExpQs :: [Q Exp]
peekExpQs = map (\p -> [e|peek|] `appE` varE p) ptrNames
elemNames :: [String]
elemNames = take (fromInteger dim)
["x", "y", "z"]
|
lukexi/haskell-opencv
|
src/OpenCV/Internal/Core/Types/Point/TH.hs
|
Haskell
|
bsd-3-clause
| 6,656
|
{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveGeneric #-}
module ZM.Type.Float64(IEEE_754_binary64(..)) where
import Data.Model
import ZM.Type.Bits11
import ZM.Type.Bits52
import ZM.Type.Words
-- |An IEEE-754 Big Endian 64 bits Float
data IEEE_754_binary64 =
IEEE_754_binary64
{ sign :: Sign
, exponent :: MostSignificantFirst Bits11
, fraction :: MostSignificantFirst Bits52
}
deriving (Eq, Ord, Show, Generic, Model)
|
tittoassini/typed
|
src/ZM/Type/Float64.hs
|
Haskell
|
bsd-3-clause
| 513
|
{-# LANGUAGE OverloadedStrings #-}
import qualified Graphics.UI.Threepenny as UI
import Graphics.UI.Threepenny.Core
import Foundation.Common
import Examples.Blog
import Control.Applicative
import Control.Monad
import Data.List (intersperse)
main :: IO ()
main = do
startGUI Config
{ tpPort = 10000
, tpCustomHTML = Nothing
, tpStatic = "static/"
} setup
setup :: Window -> IO ()
setup w = void $ do
UI.addStyleSheet w "foundation.css"
UI.addStyleSheet w "normalize.css"
getBody w #+ mainPage
mainPage :: [IO Element]
mainPage =
[ navBar
, rowClass #+
[ articles
, blogSideBar
]
, blogFooter
]
articles :: IO Element
articles = UI.div # set UI.class_ "large-9 columns" # set role "content" #+
intersperse UI.hr
[ baconArticle
, baconArticle
, baconArticle
, baconArticle
, baconArticle
]
blogSideBar :: IO Element
blogSideBar = sideBar $ unwords
[ "Pork drumstick turkey fugiat."
, "Tri-tip elit turducken pork chop in."
, "Swine short ribs meatball irure bacon nulla pork belly cupidatat meatloaf cow."
]
baconArticle :: IO Element
baconArticle = articleEntry "Article Test" "Kyle Carter" "Aug 12, 2003"
[ unwords
[ "Bacon ipsum dolor sit amet nulla ham qui sint exercitation eiusmod commodo, chuck duis velit."
, "Aute in reprehenderit, dolore aliqua non est magna in labore pig pork biltong."
, "Eiusmod swine spare ribs reprehenderit culpa."
]
, unwords
[ "Boudin aliqua adipisicing rump corned beef."
, "Nulla corned beef sunt ball tip, qui bresaola enim jowl."
, "Capicola short ribs minim salami nulla nostrud pastrami."
]
]
[ unwords
[ "Pork drumstick turkey fugiat."
, "Tri-tip elit turducken pork chop in."
, "Swine short ribs meatball irure bacon nulla pork belly cupidatat meatloaf cow."
, "Nulla corned beef sunt ball tip, qui bresaola enim jowl."
, "Capicola short ribs minim salami nulla nostrud pastrami."
, "Nulla corned beef sunt ball tip, qui bresaola enim jowl."
, "Capicola short ribs minim salami nulla nostrud pastrami."
]
, unwords
[ "Pork drumstick turkey fugiat."
, "Tri-tip elit turducken pork chop in."
, "Swine short ribs meatball irure bacon nulla pork belly cupidatat meatloaf cow."
, "Nulla corned beef sunt ball tip, qui bresaola enim jowl."
, "Capicola short ribs minim salami nulla nostrud pastrami."
, "Nulla corned beef sunt ball tip, qui bresaola enim jowl."
, "Capicola short ribs minim salami nulla nostrud pastrami."
]
]
|
kylcarte/threepenny-extras
|
src/Examples/BlogTest.hs
|
Haskell
|
bsd-3-clause
| 2,566
|
{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE PatternGuards #-}
-----------------------------------------------------------------------------
-- |
-- Module : Text.CSL.Eval.Date
-- Copyright : (c) Andrea Rossato
-- License : BSD-style (see LICENSE)
--
-- Maintainer : Andrea Rossato <andrea.rossato@unitn.it>
-- Stability : unstable
-- Portability : unportable
--
-- The CSL implementation
--
-----------------------------------------------------------------------------
module Text.CSL.Eval.Date where
import Prelude
import qualified Control.Exception as E
import Control.Monad.State
import Data.List.Split
import Data.Maybe (fromMaybe, isNothing)
import Data.Text (Text)
import qualified Data.Text as T
import Text.CSL.Exception
import Text.CSL.Eval.Common
import Text.CSL.Eval.Output
import Text.CSL.Style
import Text.CSL.Reference
import Text.CSL.Util ( toRead, last' )
import Text.Pandoc.Definition ( Inline (Str) )
import Text.Printf (printf)
evalDate :: Element -> State EvalState [Output]
evalDate (Date s f fm dl dp dp') = do
tm <- gets $ terms . env
k <- getStringVar "ref-id"
em <- gets mode
let updateFM (Formatting aa ab ac ad ae af ag ah ai aj ak al am an ahl)
(Formatting _ _ bc bd be bf bg bh _ bj bk _ _ _ _) =
Formatting aa ab (updateS ac bc)
(updateS ad bd)
(updateS ae be)
(updateS af bf)
(updateS ag bg)
(updateS ah bh)
ai
(updateS aj bj)
(if bk /= ak then bk else ak)
al am an ahl
updateS a b = if b /= a && b /= "" then b else a
case f of
NoFormDate -> outputList fm dl .
concatMap (formatDate em k tm dp) <$> mapM getDateVar s
_ -> do res <- getDate f
case res of
Date _ _ lfm ldl ldp _ -> do
let go dps = return . outputList (updateFM fm lfm) (if ldl /= "" then ldl else dl) .
concatMap (formatDate em k tm dps)
update l x@(DatePart a b c d) =
case filter ((==) a . dpName) l of
(DatePart _ b' c' d':_) -> DatePart a (updateS b b')
(updateS c c')
(updateFM d d')
_ -> x
updateDP = map (update dp) ldp
date = mapM getDateVar s
case dp' of
"year-month" -> go (filter ((/=) "day" . dpName) updateDP) =<< date
"year" -> go (filter ((==) "year" . dpName) updateDP) =<< date
_ -> go updateDP =<< date
_ -> return []
evalDate _ = return []
getDate :: DateForm -> State EvalState Element
getDate f = do
x <- filter (\(Date _ df _ _ _ _) -> df == f) <$> gets (dates . env)
case x of
[x'] -> return x'
_ -> return $ Date [] NoFormDate emptyFormatting "" [] ""
formatDate :: EvalMode -> Text -> [CslTerm] -> [DatePart] -> [RefDate] -> [Output]
formatDate em k tm dp date
| [d] <- date = concatMap (formatDatePart d) dp
| (a:b:_) <- date = addODate . concat $ doRange a b
| otherwise = []
where
addODate [] = []
addODate xs = [ODate xs]
splitDate a b = case split (onSublist $ diff a b dp) dp of
[x,y,z] -> (x,y,z)
_ -> E.throw ErrorSplittingDate
doRange a b = let (x,y,z) = splitDate a b in
map (formatDatePart a) x ++
withDelim y
(map (formatDatePart a) (rmSuffix y))
(map (formatDatePart b) (rmPrefix y))
++
map (formatDatePart b) z
-- the point of rmPrefix is to remove the blank space that otherwise
-- gets added after the delimiter in a range: 24- 26.
rmPrefix (dp':rest) = dp'{ dpFormatting =
(dpFormatting dp') { prefix = "" } } : rest
rmPrefix [] = []
rmSuffix (dp':rest)
| null rest = [dp'{ dpFormatting =
(dpFormatting dp') { suffix = "" } }]
| otherwise = dp':rmSuffix rest
rmSuffix [] = []
diff (RefDate ya ma sa da _ _)
(RefDate yb mb sb db _ _)
= filter (\x -> dpName x `elem` ns)
where ns =
case () of
_ | ya /= yb -> ["year","month","day"]
| ma /= mb || sa /= sb ->
if isNothing da && isNothing db
then ["month"]
else ["month","day"]
| da /= db -> ["day"]
| otherwise -> ["year","month","day"]
term f t = let f' = if f `elem` ["verb", "short", "verb-short", "symbol"]
then read . T.unpack $ toRead f
else Long
in maybe "" termPlural $ findTerm t f' tm
formatDatePart (RefDate y m e d o _) (DatePart n f _ fm)
| "year" <- n, Just y' <- y = return $ OYear (formatYear f y') k fm
| "month" <- n, Just m' <- m = output fm (formatMonth f fm m')
| "month" <- n, Just e' <- e =
case e' of
RawSeason s -> [OStr s fm]
_ -> output fm . term f . T.pack $
(printf "season-%02d" $ fromMaybe 0 $ seasonToInt e')
| "day" <- n, Just d' <- d = output fm (formatDay f m d')
| "year" <- n, o /= mempty = output fm (unLiteral o)
| otherwise = []
withDelim xs o1 o2
| null (concat o1 ++ concat o2) = []
| otherwise = o1 ++ (case dpRangeDelim <$> last' xs of
["-"] -> [[OPan [Str "\x2013"]]]
[s] -> [[OPan [Str s]]]
_ -> []) ++ o2
formatYear f y
| "short" <- f = T.pack $ printf "%02d" y
| isSorting em
, y < 0 = T.pack $ printf "-%04d" (abs y)
| isSorting em = T.pack $ printf "%04d" y
| y < 0 = (T.pack $ printf "%d" (abs y)) <> term "" "bc"
| y < 1000
, y > 0 = (T.pack $ printf "%d" y) <> term "" "ad"
| y == 0 = ""
| otherwise = T.pack $ printf "%d" y
formatMonth f fm m
| "short" <- f = getMonth $ period . termPlural
| "long" <- f = getMonth termPlural
| "numeric" <- f = T.pack $ printf "%d" m
| otherwise = T.pack $ printf "%02d" m
where
period = if stripPeriods fm then T.filter (/= '.') else id
getMonth g = case findTerm ("month-" <> T.pack (printf "%02d" m))
(read . T.unpack $ toRead f) tm of
Nothing -> T.pack (show m)
Just x -> g x
formatDay f m d
| "numeric-leading-zeros" <- f = T.pack $ printf "%02d" d
| "ordinal" <- f = ordinal tm ("month-" <> maybe "0" (T.pack . printf "%02d") m) d
| otherwise = T.pack $ printf "%d" d
ordinal :: [CslTerm] -> Text -> Int -> Text
ordinal ts v s
| s < 10 = let a = termPlural (getWith1 (show s)) in
if T.null a
then setOrd (term "")
else T.pack (show s) <> a
| s < 100 = let a = termPlural (getWith2 (show s))
b = getWith1 [last (show s)] in
if not (T.null a)
then T.pack (show s) <> a
else if T.null (termPlural b) ||
(not (T.null (termMatch b)) &&
termMatch b /= "last-digit")
then setOrd (term "")
else setOrd b
| otherwise = let a = getWith2 last2
b = getWith1 [last (show s)] in
if not (T.null (termPlural a)) &&
termMatch a /= "whole-number"
then setOrd a
else if T.null (termPlural b) ||
(not (T.null (termMatch b)) &&
termMatch b /= "last-digit")
then setOrd (term "")
else setOrd b
where
setOrd = T.append (T.pack $ show s) . termPlural
getWith1 = term . T.append "-0" . T.pack
getWith2 = term . T.append "-" . T.pack
last2 = reverse . take 2 . reverse $ show s
term t = getOrdinal v ("ordinal" <> t) ts
longOrdinal :: [CslTerm] -> Text -> Int -> Text
longOrdinal ts v s
| s > 10 ||
s == 0 = ordinal ts v s
| otherwise = case s `mod` 10 of
1 -> term "01"
2 -> term "02"
3 -> term "03"
4 -> term "04"
5 -> term "05"
6 -> term "06"
7 -> term "07"
8 -> term "08"
9 -> term "09"
_ -> term "10"
where
term t = termPlural $ getOrdinal v ("long-ordinal-" <> t) ts
getOrdinal :: Text -> Text -> [CslTerm] -> CslTerm
getOrdinal v s ts
= fromMaybe newTerm $ findTerm' s Long gender ts `mplus`
findTerm' s Long Neuter ts
where
gender = if v `elem` numericVars || "month" `T.isPrefixOf` v
then maybe Neuter termGender $ findTerm v Long ts
else Neuter
|
jgm/pandoc-citeproc
|
src/Text/CSL/Eval/Date.hs
|
Haskell
|
bsd-3-clause
| 10,495
|
{-| The API part of @feed-gipeda@. The console client is just a thin wrapper
around this.
-}
module FeedGipeda
( Endpoint (..)
, feedGipeda
, module FeedGipeda.Types
) where
import Control.Arrow (second)
import Control.Concurrent (forkIO)
import Control.Concurrent.Chan (Chan, newChan, readChan,
writeChan)
import qualified Control.Distributed.Backend.P2P as P2P
import Control.Distributed.Process (Process, RemoteTable,
getSelfNode, liftIO, say,
spawnLocal)
import Control.Distributed.Process.Node (initRemoteTable, runProcess)
import Control.Logging as Logging
import Control.Monad (forever, void, when)
import Data.List (elemIndex)
import Data.Maybe (fromMaybe, isJust)
import Data.Set (Set)
import Data.Time (NominalDiffTime)
import qualified FeedGipeda.Config as Config
import qualified FeedGipeda.Gipeda as Gipeda
import FeedGipeda.GitShell (SHA)
import qualified FeedGipeda.Master as Master
import qualified FeedGipeda.Master.CommitQueue as CommitQueue
import qualified FeedGipeda.Master.File as Master.File
import FeedGipeda.Prelude
import FeedGipeda.Repo (Repo)
import qualified FeedGipeda.TaskScheduler as TaskScheduler
import qualified FeedGipeda.THGenerated as THGenerated
import FeedGipeda.Types
import Network.URI (parseURI)
import System.Directory (getAppUserDataDirectory)
import System.Exit (exitSuccess)
import System.FilePath ((</>))
remoteTable :: RemoteTable
remoteTable =
THGenerated.__remoteTable initRemoteTable
{-| The parameters correspond exactly to the command line parameters, to
you should read the @--help@ message for more thorough documentation.
@feedGipeda@ determines the appropriate mode of operation (e.g. watching or one-shot).
It also works as master or slave node, depending on which endpoints are given.
Lastly, @verbose@ will lead to more debug output.
-}
feedGipeda
:: Paths
-> Command
-> Deployment
-> ProcessRole
-> Verbosity
-> IO ()
feedGipeda paths cmd deployment role_ verbosity = do
case verbosity of
Verbose -> Logging.setLogLevel Logging.LevelDebug
NotVerbose -> Logging.setLogLevel Logging.LevelWarn
case cmd of
Check ->
-- Just perform a syntax check on the given configFile
Config.checkFile (configFile paths) >>= maybe exitSuccess error
Build mode timeout -> do
case slaveEndpoint role_ of
Just (Endpoint shost sport) -> do
let
run = if isBoth role_ then void . forkIO else id
Endpoint mhost mport = masterEndpoint role_
master = P2P.makeNodeId (mhost ++ ":" ++ show mport)
run (TaskScheduler.work shost (show sport) master remoteTable)
_ -> return ()
case (role_, masterEndpoint role_) of
(Slave _ _, _) -> return ()
(_, Endpoint host port) -> do
queue <- CommitQueue.new
P2P.bootstrap host (show port) [] remoteTable $ do
-- We supply no seeds, so the node won't have been created yet.
-- I think this is a bug.
_ <- getSelfNode
let
toTask :: (Repo, SHA) -> IO (TaskScheduler.Task String)
toTask (repo, commit) = do
script <- Gipeda.determineBenchmarkScript repo
let closure = THGenerated.benchmarkClosure script repo commit timeout
let finalize = Master.File.writeBenchmarkCSV repo commit . fromMaybe ""
return (THGenerated.stringDict, closure, finalize)
TaskScheduler.start (CommitQueue.dequeue queue >>= toTask)
liftIO (Master.checkForNewCommits paths deployment mode queue)
|
sgraf812/feed-gipeda
|
src/FeedGipeda.hs
|
Haskell
|
bsd-3-clause
| 4,308
|
module Main where
import System.Environment
import Language.Sheo.Parser
import Language.Sheo.Printer
compile :: String -> IO ()
compile fileName = do prgm <- parse fileName
case prgm of
Just p' -> print $ prettyPrint p'
Nothing -> return ()
usage :: IO ()
usage = print "pass a filename ya dingus"
main :: IO ()
main = do args <- getArgs
case args of
[fileName] -> compile fileName;
_ -> usage
|
forestbelton/sheo
|
app/Main.hs
|
Haskell
|
bsd-3-clause
| 519
|
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE QuasiQuotes #-}
{-# LANGUAGE DataKinds #-}
module Main where
import Data.Default
import Text.Haiji
import qualified Data.Text as T
import qualified Data.Text.Lazy as LT
import qualified Data.Text.Lazy.IO as LT
main :: IO ()
main = LT.putStr
$ render $(haijiFile def "example.tmpl")
$ [key|a_variable|] ("Hello,World!" :: T.Text) `merge`
[key|navigation|] [ [key|caption|] cap `merge` [key|href|] href
| (cap, href) <- [ ("A", "content/a.html")
, ("B", "content/b.html")
] :: [ (T.Text, T.Text) ]
] `merge`
[key|foo|] (1 :: Int) `merge`
[key|bar|] ("" :: String)
|
notogawa/haiji
|
example.hs
|
Haskell
|
bsd-3-clause
| 828
|
-- | UI of inventory management.
module Game.LambdaHack.Client.UI.InventoryM
( Suitability(..), ResultItemDialogMode(..)
, getFull, getGroupItem, getStoreItem
, skillCloseUp, placeCloseUp, factionCloseUp
#ifdef EXPOSE_INTERNAL
-- * Internal operations
, ItemDialogState(..), accessModeBag, storeItemPrompt, getItem
, DefItemKey(..), transition
, runDefMessage, runDefAction, runDefSkills, skillsInRightPane
, runDefPlaces, placesInRightPane
, runDefFactions, factionsInRightPane
, runDefModes, runDefInventory
#endif
) where
import Prelude ()
import Game.LambdaHack.Core.Prelude
import Data.Either
import qualified Data.EnumMap.Strict as EM
import qualified Data.EnumSet as ES
import Data.Function
import qualified Data.Text as T
import qualified NLP.Miniutter.English as MU
import Game.LambdaHack.Client.MonadClient
import Game.LambdaHack.Client.State
import Game.LambdaHack.Client.UI.ActorUI
import Game.LambdaHack.Client.UI.Content.Screen
import Game.LambdaHack.Client.UI.ContentClientUI
import Game.LambdaHack.Client.UI.EffectDescription
import Game.LambdaHack.Client.UI.HandleHelperM
import Game.LambdaHack.Client.UI.HumanCmd
import qualified Game.LambdaHack.Client.UI.Key as K
import Game.LambdaHack.Client.UI.MonadClientUI
import Game.LambdaHack.Client.UI.Msg
import Game.LambdaHack.Client.UI.MsgM
import Game.LambdaHack.Client.UI.Overlay
import Game.LambdaHack.Client.UI.SessionUI
import Game.LambdaHack.Client.UI.Slideshow
import Game.LambdaHack.Client.UI.SlideshowM
import Game.LambdaHack.Common.Actor
import Game.LambdaHack.Common.ActorState
import Game.LambdaHack.Common.ClientOptions
import Game.LambdaHack.Common.Faction
import qualified Game.LambdaHack.Common.Faction as Faction
import Game.LambdaHack.Common.Item
import Game.LambdaHack.Common.Kind
import Game.LambdaHack.Common.Misc
import Game.LambdaHack.Common.MonadStateRead
import Game.LambdaHack.Common.State
import Game.LambdaHack.Common.Types
import qualified Game.LambdaHack.Content.FactionKind as FK
import qualified Game.LambdaHack.Content.ItemKind as IK
import qualified Game.LambdaHack.Content.PlaceKind as PK
import qualified Game.LambdaHack.Definition.Ability as Ability
import qualified Game.LambdaHack.Definition.Color as Color
import Game.LambdaHack.Definition.Defs
data ItemDialogState = ISuitable | IAll
deriving (Show, Eq)
data ResultItemDialogMode =
RStore CStore [ItemId]
| ROwned ItemId
| RLore SLore MenuSlot [(ItemId, ItemQuant)]
| RSkills MenuSlot
| RPlaces MenuSlot
| RFactions MenuSlot
| RModes MenuSlot
deriving Show
accessModeBag :: ActorId -> State -> ItemDialogMode -> ItemBag
accessModeBag leader s (MStore cstore) = let b = getActorBody leader s
in getBodyStoreBag b cstore s
accessModeBag leader s MOwned = let fid = bfid $ getActorBody leader s
in combinedItems fid s
accessModeBag _ _ MSkills = EM.empty
accessModeBag leader s (MLore SBody) = let b = getActorBody leader s
in getBodyStoreBag b COrgan s
accessModeBag _ s MLore{} = EM.map (const quantSingle) $ sitemD s
accessModeBag _ _ MPlaces = EM.empty
accessModeBag _ _ MFactions = EM.empty
accessModeBag _ _ MModes = EM.empty
-- | Let a human player choose any item from a given group.
-- Note that this does not guarantee the chosen item belongs to the group,
-- as the player can override the choice.
-- Used e.g., for applying and projecting.
getGroupItem :: MonadClientUI m
=> ActorId
-> m Suitability
-- ^ which items to consider suitable
-> Text -- ^ specific prompt for only suitable items
-> Text -- ^ generic prompt
-> Text -- ^ the verb to use
-> Text -- ^ the generic verb to use
-> [CStore] -- ^ stores to cycle through
-> m (Either Text (CStore, ItemId))
getGroupItem leader psuit prompt promptGeneric verb verbGeneric stores = do
side <- getsClient sside
mstash <- getsState $ \s -> gstash $ sfactionD s EM.! side
let ppItemDialogBody v body actorSk cCur = case cCur of
MStore CEqp | not $ calmEnough body actorSk ->
"distractedly attempt to" <+> v <+> ppItemDialogModeIn cCur
MStore CGround | mstash == Just (blid body, bpos body) ->
"greedily attempt to" <+> v <+> ppItemDialogModeIn cCur
_ -> v <+> ppItemDialogModeFrom cCur
soc <- getFull leader psuit
(\body _ actorSk cCur _ ->
prompt <+> ppItemDialogBody verb body actorSk cCur)
(\body _ actorSk cCur _ ->
promptGeneric
<+> ppItemDialogBody verbGeneric body actorSk cCur)
stores True False
case soc of
Left err -> return $ Left err
Right (rstore, [(iid, _)]) -> return $ Right (rstore, iid)
Right _ -> error $ "" `showFailure` soc
-- | Display all items from a store and let the human player choose any
-- or switch to any other store.
-- Used, e.g., for viewing inventory and item descriptions.
getStoreItem :: MonadClientUI m
=> ActorId -- ^ the pointman
-> ItemDialogMode -- ^ initial mode
-> m (Either Text ResultItemDialogMode)
getStoreItem leader cInitial = do
side <- getsClient sside
let -- No @COrgan@, because triggerable organs are rare and,
-- if really needed, accessible directly from the trigger menu.
itemCs = map MStore [CStash, CEqp, CGround]
-- This should match, including order, the items in standardKeysAndMouse
-- marked with CmdDashboard up to @MSkills@.
leaderCs = itemCs ++ [MOwned, MLore SBody, MSkills]
-- No @SBody@, because repeated in other lores and included elsewhere.
itemLoreCs = map MLore [minBound..SEmbed]
-- This should match, including order, the items in standardKeysAndMouse
-- marked with CmdDashboard past @MSkills@ and up to @MModes@.
loreCs = itemLoreCs ++ [MPlaces, MFactions, MModes]
let !_A1 = assert (null (leaderCs `intersect` loreCs)) ()
!_A2 = assert (sort (leaderCs ++ loreCs ++ [MStore COrgan])
== map MStore [minBound..maxBound]
++ [MOwned, MSkills]
++ map MLore [minBound..maxBound]
++ [MPlaces, MFactions, MModes]) ()
allCs | cInitial `elem` leaderCs = leaderCs
| cInitial `elem` loreCs = loreCs
| otherwise = assert (cInitial == MStore COrgan) leaderCs
-- werrd content, but let it be
(pre, rest) = break (== cInitial) allCs
post = dropWhile (== cInitial) rest
remCs = post ++ pre
prompt = storeItemPrompt side
getItem leader (return SuitsEverything) prompt prompt cInitial remCs
True False
storeItemPrompt :: FactionId
-> Actor -> ActorUI -> Ability.Skills -> ItemDialogMode -> State
-> Text
storeItemPrompt side body bodyUI actorCurAndMaxSk c2 s =
let COps{coitem} = scops s
fact = sfactionD s EM.! side
(tIn, t) = ppItemDialogMode c2
subject = partActor bodyUI
f (k, _) acc = k + acc
countItems store = EM.foldr' f 0 $ getBodyStoreBag body store s
in case c2 of
MStore CGround ->
let n = countItems CGround
nItems = MU.CarAWs n "item"
verbGround = if gstash fact == Just (blid body, bpos body)
then "fondle greedily"
else "notice"
in makePhrase
[ MU.Capitalize $ MU.SubjectVerbSg subject verbGround
, nItems, "at"
, MU.WownW (MU.Text $ bpronoun bodyUI) $ MU.Text "feet" ]
MStore CEqp ->
let n = countItems CEqp
(verbEqp, nItems) =
if | n == 0 -> ("find nothing", "")
| calmEnough body actorCurAndMaxSk ->
("find", MU.CarAWs n "item")
| otherwise -> ("paw distractedly at", MU.CarAWs n "item")
in makePhrase
[ MU.Capitalize $ MU.SubjectVerbSg subject verbEqp
, nItems, MU.Text tIn
, MU.WownW (MU.Text $ bpronoun bodyUI) $ MU.Text t ]
MStore cstore ->
let n = countItems cstore
nItems = MU.CarAWs n "item"
(verb, onLevel) = case cstore of
COrgan -> ("feel", [])
CStash ->
( "notice"
, case gstash fact of
Just (lid, _) ->
map MU.Text ["on level", tshow $ abs $ fromEnum lid]
Nothing -> [] )
ownObject = case cstore of
CStash -> ["our", MU.Text t]
_ -> [MU.WownW (MU.Text $ bpronoun bodyUI) $ MU.Text t]
in makePhrase $
[ MU.Capitalize $ MU.SubjectVerbSg subject verb
, nItems, MU.Text tIn ] ++ ownObject ++ onLevel
MOwned ->
-- We assume "gold grain", not "grain" with label "of gold":
let currencyName = IK.iname $ okind coitem
$ ouniqGroup coitem IK.S_CURRENCY
dungeonTotal = sgold s
(_, total) = calculateTotal side s
in T.init $ spoilsBlurb currencyName total dungeonTotal
-- no space for more, e.g., the pointman, but it can't be changed anyway
MSkills ->
makePhrase
[ MU.Capitalize $ MU.SubjectVerbSg subject "estimate"
, MU.WownW (MU.Text $ bpronoun bodyUI) $ MU.Text t ]
MLore SBody ->
makePhrase
[ MU.Capitalize $ MU.SubjectVerbSg subject "feel"
, MU.Text tIn
, MU.WownW (MU.Text $ bpronoun bodyUI) $ MU.Text t ]
MLore slore ->
makePhrase
[ MU.Capitalize $ MU.Text $
if slore == SEmbed
then "terrain (including crafting recipes)"
else t ]
MPlaces ->
makePhrase
[ MU.Capitalize $ MU.Text t ]
MFactions ->
makePhrase
[ MU.Capitalize $ MU.Text t ]
MModes ->
makePhrase
[ MU.Capitalize $ MU.Text t ]
-- | Let the human player choose a single, preferably suitable,
-- item from a list of items. Don't display stores empty for all actors.
-- Start with a non-empty store.
getFull :: MonadClientUI m
=> ActorId
-> m Suitability -- ^ which items to consider suitable
-> (Actor -> ActorUI -> Ability.Skills -> ItemDialogMode -> State
-> Text) -- ^ specific prompt for only suitable items
-> (Actor -> ActorUI -> Ability.Skills -> ItemDialogMode -> State
-> Text) -- ^ generic prompt
-> [CStore] -- ^ stores to cycle through
-> Bool -- ^ whether to ask, when the only item
-- in the starting mode is suitable
-> Bool -- ^ whether to permit multiple items as a result
-> m (Either Text (CStore, [(ItemId, ItemQuant)]))
getFull leader psuit prompt promptGeneric stores askWhenLone permitMulitple = do
mpsuit <- psuit
let psuitFun = case mpsuit of
SuitsEverything -> \_ _ _ -> True
SuitsSomething f -> f
-- Move the first store that is non-empty for suitable items for this actor
-- to the front, if any.
b <- getsState $ getActorBody leader
getCStoreBag <- getsState $ \s cstore -> getBodyStoreBag b cstore s
let hasThisActor = not . EM.null . getCStoreBag
case filter hasThisActor stores of
[] -> do
let dialogModes = map MStore stores
ts = map (MU.Text . ppItemDialogModeIn) dialogModes
return $ Left $ "no items" <+> makePhrase [MU.WWxW "nor" ts]
haveThis@(headThisActor : _) -> do
itemToF <- getsState $ flip itemToFull
let suitsThisActor store =
let bag = getCStoreBag store
in any (\(iid, kit) -> psuitFun (Just store) (itemToF iid) kit)
(EM.assocs bag)
firstStore = fromMaybe headThisActor $ find suitsThisActor haveThis
-- Don't display stores totally empty for all actors.
breakStores cInit =
let (pre, rest) = break (== cInit) stores
post = dropWhile (== cInit) rest
in (MStore cInit, map MStore $ post ++ pre)
(modeFirst, modeRest) = breakStores firstStore
res <- getItem leader psuit prompt promptGeneric modeFirst modeRest
askWhenLone permitMulitple
case res of
Left t -> return $ Left t
Right (RStore fromCStore iids) -> do
let bagAll = getCStoreBag fromCStore
f iid = (iid, bagAll EM.! iid)
return $ Right (fromCStore, map f iids)
Right _ -> error $ "" `showFailure` res
-- | Let the human player choose a single, preferably suitable,
-- item from a list of items.
getItem :: MonadClientUI m
=> ActorId
-> m Suitability -- ^ which items to consider suitable
-> (Actor -> ActorUI -> Ability.Skills -> ItemDialogMode -> State
-> Text) -- ^ specific prompt for only suitable items
-> (Actor -> ActorUI -> Ability.Skills -> ItemDialogMode -> State
-> Text) -- ^ generic prompt
-> ItemDialogMode -- ^ first mode to display
-> [ItemDialogMode] -- ^ the (rest of) modes
-> Bool -- ^ whether to ask, when the only item
-- in the starting mode is suitable
-> Bool -- ^ whether to permit multiple items as a result
-> m (Either Text ResultItemDialogMode)
getItem leader psuit prompt promptGeneric cCur cRest askWhenLone
permitMulitple = do
accessCBag <- getsState $ accessModeBag leader
let storeAssocs = EM.assocs . accessCBag
allAssocs = concatMap storeAssocs (cCur : cRest)
case (allAssocs, cCur) of
([(iid, _)], MStore rstore) | null cRest && not askWhenLone ->
return $ Right $ RStore rstore [iid]
_ -> transition leader psuit prompt promptGeneric permitMulitple
cCur cRest ISuitable
data DefItemKey m = DefItemKey
{ defLabel :: Either Text K.KM
, defCond :: Bool
, defAction :: ~(m (Either Text ResultItemDialogMode))
-- this field may be expensive or undefined when @defCond@ is false
}
data Suitability =
SuitsEverything
| SuitsSomething (Maybe CStore -> ItemFull -> ItemQuant -> Bool)
transition :: forall m. MonadClientUI m
=> ActorId
-> m Suitability
-> (Actor -> ActorUI -> Ability.Skills -> ItemDialogMode -> State
-> Text)
-> (Actor -> ActorUI -> Ability.Skills -> ItemDialogMode -> State
-> Text)
-> Bool
-> ItemDialogMode
-> [ItemDialogMode]
-> ItemDialogState
-> m (Either Text ResultItemDialogMode)
transition leader psuit prompt promptGeneric permitMulitple
cCur cRest itemDialogState = do
let recCall cCur2 cRest2 itemDialogState2 = do
-- Pointman could have been changed by keypresses near the end of
-- the current recursive call, so refresh it for the next call.
mleader <- getsClient sleader
-- When run inside a test, without mleader, assume leader not changed.
let leader2 = fromMaybe leader mleader
transition leader2 psuit prompt promptGeneric permitMulitple
cCur2 cRest2 itemDialogState2
actorCurAndMaxSk <- getsState $ getActorMaxSkills leader
body <- getsState $ getActorBody leader
bodyUI <- getsSession $ getActorUI leader
fact <- getsState $ (EM.! bfid body) . sfactionD
hs <- partyAfterLeader leader
revCmd <- revCmdMap
promptChosen <- getsState $ \s -> case itemDialogState of
ISuitable -> prompt body bodyUI actorCurAndMaxSk cCur s <> ":"
IAll -> promptGeneric body bodyUI actorCurAndMaxSk cCur s <> ":"
let keyDefsCommon :: [(K.KM, DefItemKey m)]
keyDefsCommon = filter (defCond . snd)
[ let km = K.mkChar '<'
in (km, changeContainerDef Backward $ Right km)
, let km = K.mkChar '>'
in (km, changeContainerDef Forward $ Right km)
, cycleKeyDef Forward
, cycleKeyDef Backward
, cycleLevelKeyDef Forward
, cycleLevelKeyDef Backward
, (K.KM K.NoModifier K.LeftButtonRelease, DefItemKey
{ defLabel = Left ""
, defCond = maySwitchLeader cCur && not (null hs)
, defAction = do
-- This is verbose even in aiming mode, displaying
-- terrain description, but it's fine, mouse may do that.
merror <- pickLeaderWithPointer leader
case merror of
Nothing -> recCall cCur cRest itemDialogState
Just{} -> return $ Left "not a menu item nor teammate position"
-- don't inspect the error, it's expected
})
, (K.escKM, DefItemKey
{ defLabel = Right K.escKM
, defCond = True
, defAction = return $ Left "never mind"
})
]
cycleLevelKeyDef direction =
let km = revCmd $ PointmanCycleLevel direction
in (km, DefItemKey
{ defLabel = Left ""
, defCond = maySwitchLeader cCur
&& any (\(_, b, _) -> blid b == blid body) hs
, defAction = do
err <- pointmanCycleLevel leader False direction
let !_A = assert (isNothing err `blame` err) ()
recCall cCur cRest itemDialogState
})
changeContainerDef direction defLabel =
let (cCurAfterCalm, cRestAfterCalm) = nextContainers direction
in DefItemKey
{ defLabel
, defCond = cCurAfterCalm /= cCur
, defAction = recCall cCurAfterCalm cRestAfterCalm itemDialogState
}
nextContainers direction = case direction of
Forward -> case cRest ++ [cCur] of
c1 : rest -> (c1, rest)
[] -> error $ "" `showFailure` cRest
Backward -> case reverse $ cCur : cRest of
c1 : rest -> (c1, reverse rest)
[] -> error $ "" `showFailure` cRest
banned = bannedPointmanSwitchBetweenLevels fact
maySwitchLeader MStore{} = True
maySwitchLeader MOwned = False
maySwitchLeader MSkills = True
maySwitchLeader (MLore SBody) = True
maySwitchLeader MLore{} = False
maySwitchLeader MPlaces = False
maySwitchLeader MFactions = False
maySwitchLeader MModes = False
cycleKeyDef direction =
let km = revCmd $ PointmanCycle direction
in (km, DefItemKey
{ defLabel = if direction == Forward then Right km else Left ""
, defCond = maySwitchLeader cCur && not (banned || null hs)
, defAction = do
err <- pointmanCycle leader False direction
let !_A = assert (isNothing err `blame` err) ()
recCall cCur cRest itemDialogState
})
case cCur of
MSkills -> runDefSkills keyDefsCommon promptChosen leader
MPlaces -> runDefPlaces keyDefsCommon promptChosen
MFactions -> runDefFactions keyDefsCommon promptChosen
MModes -> runDefModes keyDefsCommon promptChosen
_ -> do
bagHuge <- getsState $ \s -> accessModeBag leader s cCur
itemToF <- getsState $ flip itemToFull
mpsuit <- psuit -- when throwing, this sets eps and checks xhair validity
psuitFun <- case mpsuit of
SuitsEverything -> return $ \_ _ _ -> True
SuitsSomething f -> return f -- When throwing, this function takes
-- missile range into accout.
ItemRoles itemRoles <- getsSession sroles
let slore = loreFromMode cCur
itemRole = itemRoles EM.! slore
bagAll = EM.filterWithKey (\iid _ -> iid `ES.member` itemRole) bagHuge
mstore = case cCur of
MStore store -> Just store
_ -> Nothing
filterP = psuitFun mstore . itemToF
bagSuit = EM.filterWithKey filterP bagAll
bagFiltered = case itemDialogState of
ISuitable -> bagSuit
IAll -> bagAll
iids = sortIids itemToF $ EM.assocs bagFiltered
keyDefsExtra =
[ let km = K.mkChar '+'
in (km, DefItemKey
{ defLabel = Right km
, defCond = bagAll /= bagSuit
, defAction = recCall cCur cRest $ case itemDialogState of
ISuitable -> IAll
IAll -> ISuitable
})
, let km = K.mkChar '*'
in (km, useMultipleDef $ Right km)
, let km = K.mkChar '!'
in (km, useMultipleDef $ Left "") -- alias close to 'g'
]
useMultipleDef defLabel = DefItemKey
{ defLabel
, defCond = permitMulitple && not (null iids)
, defAction = case cCur of
MStore rstore -> return $! Right $ RStore rstore $ map fst iids
_ -> error "transition: multiple items not for MStore"
}
keyDefs = keyDefsCommon ++ filter (defCond . snd) keyDefsExtra
runDefInventory keyDefs promptChosen leader cCur iids
runDefMessage :: MonadClientUI m
=> [(K.KM, DefItemKey m)]
-> Text
-> m ()
runDefMessage keyDefs prompt = do
let wrapB s = "[" <> s <> "]"
keyLabelsRaw = lefts $ map (defLabel . snd) keyDefs
keyLabels = filter (not . T.null) keyLabelsRaw
choice = T.intercalate " " $ map wrapB $ nub keyLabels
-- switch to Data.Containers.ListUtils.nubOrd when we drop GHC 8.4.4
msgAdd MsgPromptGeneric $ prompt <+> choice
runDefAction :: MonadClientUI m
=> [(K.KM, DefItemKey m)]
-> (MenuSlot -> Either Text ResultItemDialogMode)
-> KeyOrSlot
-> m (Either Text ResultItemDialogMode)
runDefAction keyDefs slotDef ekm = case ekm of
Left km -> case km `lookup` keyDefs of
Just keyDef -> defAction keyDef
Nothing -> error $ "unexpected key:" `showFailure` K.showKM km
Right slot -> return $! slotDef slot
runDefSkills :: MonadClientUI m
=> [(K.KM, DefItemKey m)] -> Text -> ActorId
-> m (Either Text ResultItemDialogMode)
runDefSkills keyDefsCommon promptChosen leader = do
CCUI{coscreen=ScreenContent{rheight}} <- getsSession sccui
runDefMessage keyDefsCommon promptChosen
let itemKeys = map fst keyDefsCommon
keys = rights $ map (defLabel . snd) keyDefsCommon
okx <- skillsOverlay leader
sli <- overlayToSlideshow (rheight - 2) keys okx
ekm <- displayChoiceScreenWithDefItemKey
(skillsInRightPane leader) sli itemKeys (show MSkills)
runDefAction keyDefsCommon (Right . RSkills) ekm
skillsInRightPane :: MonadClientUI m => ActorId -> Int -> MenuSlot -> m OKX
skillsInRightPane leader width slot = do
FontSetup{propFont} <- getFontSetup
(prompt, attrString) <- skillCloseUp leader slot
let promptAS | T.null prompt = []
| otherwise = textFgToAS Color.Brown $ prompt <> "\n\n"
ov = EM.singleton propFont $ offsetOverlay
$ splitAttrString width width
$ promptAS ++ attrString
return (ov, [])
runDefPlaces :: MonadClientUI m
=> [(K.KM, DefItemKey m)] -> Text
-> m (Either Text ResultItemDialogMode)
runDefPlaces keyDefsCommon promptChosen = do
COps{coplace} <- getsState scops
CCUI{coscreen=ScreenContent{rheight}} <- getsSession sccui
soptions <- getsClient soptions
places <- getsState $ EM.assocs
. placesFromState coplace (sexposePlaces soptions)
runDefMessage keyDefsCommon promptChosen
let itemKeys = map fst keyDefsCommon
keys = rights $ map (defLabel . snd) keyDefsCommon
okx <- placesOverlay
sli <- overlayToSlideshow (rheight - 2) keys okx
ekm <- displayChoiceScreenWithDefItemKey
(placesInRightPane places) sli itemKeys (show MPlaces)
runDefAction keyDefsCommon (Right . RPlaces) ekm
placesInRightPane :: MonadClientUI m
=> [( ContentId PK.PlaceKind
, (ES.EnumSet LevelId, Int, Int, Int) )]
-> Int -> MenuSlot
-> m OKX
placesInRightPane places width slot = do
FontSetup{propFont} <- getFontSetup
soptions <- getsClient soptions
(prompt, blurbs) <- placeCloseUp places (sexposePlaces soptions) slot
let promptAS | T.null prompt = []
| otherwise = textFgToAS Color.Brown $ prompt <> "\n\n"
splitText = splitAttrString width width
ov = attrLinesToFontMap
$ map (second $ concatMap splitText)
$ (propFont, [promptAS]) : blurbs
return (ov, [])
runDefFactions :: MonadClientUI m
=> [(K.KM, DefItemKey m)] -> Text
-> m (Either Text ResultItemDialogMode)
runDefFactions keyDefsCommon promptChosen = do
CCUI{coscreen=ScreenContent{rheight}} <- getsSession sccui
sroles <- getsSession sroles
factions <- getsState $ factionsFromState sroles
runDefMessage keyDefsCommon promptChosen
let itemKeys = map fst keyDefsCommon
keys = rights $ map (defLabel . snd) keyDefsCommon
okx <- factionsOverlay
sli <- overlayToSlideshow (rheight - 2) keys okx
ekm <- displayChoiceScreenWithDefItemKey
(factionsInRightPane factions)
sli itemKeys (show MFactions)
runDefAction keyDefsCommon (Right . RFactions) ekm
factionsInRightPane :: MonadClientUI m
=> [(FactionId, Faction)]
-> Int -> MenuSlot
-> m OKX
factionsInRightPane factions width slot = do
FontSetup{propFont} <- getFontSetup
(prompt, blurbs) <- factionCloseUp factions slot
let promptAS | T.null prompt = []
| otherwise = textFgToAS Color.Brown $ prompt <> "\n\n"
splitText = splitAttrString width width
ov = attrLinesToFontMap
$ map (second $ concatMap splitText)
$ (propFont, [promptAS]) : blurbs
return (ov, [])
runDefModes :: MonadClientUI m
=> [(K.KM, DefItemKey m)] -> Text
-> m (Either Text ResultItemDialogMode)
runDefModes keyDefsCommon promptChosen = do
CCUI{coscreen=ScreenContent{rheight}} <- getsSession sccui
runDefMessage keyDefsCommon promptChosen
let itemKeys = map fst keyDefsCommon
keys = rights $ map (defLabel . snd) keyDefsCommon
okx <- modesOverlay
sli <- overlayToSlideshow (rheight - 2) keys okx
-- Modes would cover the whole screen, so we don't display in right pane.
-- But we display and highlight menu bullets.
ekm <- displayChoiceScreenWithDefItemKey
(\_ _ -> return emptyOKX) sli itemKeys (show MModes)
runDefAction keyDefsCommon (Right . RModes) ekm
runDefInventory :: MonadClientUI m
=> [(K.KM, DefItemKey m)]
-> Text
-> ActorId
-> ItemDialogMode
-> [(ItemId, ItemQuant)]
-> m (Either Text ResultItemDialogMode)
runDefInventory keyDefs promptChosen leader dmode iids = do
CCUI{coscreen=ScreenContent{rheight}} <- getsSession sccui
actorCurAndMaxSk <- getsState $ getActorMaxSkills leader
let meleeSkill = Ability.getSk Ability.SkHurtMelee actorCurAndMaxSk
slotDef :: MenuSlot -> Either Text ResultItemDialogMode
slotDef slot =
let iid = fst $ iids !! fromEnum slot
in Right $ case dmode of
MStore rstore -> RStore rstore [iid]
MOwned -> ROwned iid
MLore rlore -> RLore rlore slot iids
_ -> error $ "" `showFailure` dmode
promptFun _iid _itemFull _k = ""
-- TODO, e.g., if the party still owns any copies, if the actor
-- was ever killed by us or killed ours, etc.
-- This can be the same prompt or longer than what entering
-- the item screen shows.
runDefMessage keyDefs promptChosen
let itemKeys = map fst keyDefs
keys = rights $ map (defLabel . snd) keyDefs
okx <- itemOverlay iids dmode
sli <- overlayToSlideshow (rheight - 2) keys okx
ekm <- displayChoiceScreenWithDefItemKey
(okxItemLoreInline promptFun meleeSkill dmode iids)
sli itemKeys (show dmode)
runDefAction keyDefs slotDef ekm
skillCloseUp :: MonadClientUI m => ActorId -> MenuSlot -> m (Text, AttrString)
skillCloseUp leader slot = do
b <- getsState $ getActorBody leader
bUI <- getsSession $ getActorUI leader
actorCurAndMaxSk <- getsState $ getActorMaxSkills leader
let skill = skillsInDisplayOrder !! fromEnum slot
valueText = skillToDecorator skill b
$ Ability.getSk skill actorCurAndMaxSk
prompt = makeSentence
[ MU.WownW (partActor bUI) (MU.Text $ skillName skill)
, "is", MU.Text valueText ]
attrString = textToAS $ skillDesc skill
return (prompt, attrString)
placeCloseUp :: MonadClientUI m
=> [(ContentId PK.PlaceKind, (ES.EnumSet LevelId, Int, Int, Int))]
-> Bool
-> MenuSlot
-> m (Text, [(DisplayFont, [AttrString])])
placeCloseUp places sexposePlaces slot = do
COps{coplace} <- getsState scops
FontSetup{..} <- getFontSetup
let (pk, (es, ne, na, _)) = places !! fromEnum slot
pkind = okind coplace pk
prompt = makeSentence ["you remember", MU.Text $ PK.pname pkind]
freqsText = "Frequencies:" <+> T.intercalate " "
(map (\(grp, n) -> "(" <> displayGroupName grp
<> ", " <> tshow n <> ")")
$ PK.pfreq pkind)
onLevels | ES.null es = []
| otherwise = [makeSentence
[ "Appears on"
, MU.CarWs (ES.size es) "level" <> ":"
, MU.WWandW $ map MU.Car $ sort
$ map (abs . fromEnum) $ ES.elems es ]]
placeParts = ["it has" | ne > 0 || na > 0]
++ [MU.CarWs ne "entrance" | ne > 0]
++ ["and" | ne > 0 && na > 0]
++ [MU.CarWs na "surrounding" | na > 0]
partsSentence | null placeParts = []
| otherwise = [makeSentence placeParts, "\n"]
blurbs = [(propFont, partsSentence)]
++ [(monoFont, [freqsText, "\n"]) | sexposePlaces]
++ [(squareFont, PK.ptopLeft pkind ++ ["\n"]) | sexposePlaces]
++ [(propFont, onLevels)]
return (prompt, map (second $ map textToAS) blurbs)
factionCloseUp :: MonadClientUI m
=> [(FactionId, Faction)]
-> MenuSlot
-> m (Text, [(DisplayFont, [AttrString])])
factionCloseUp factions slot = do
side <- getsClient sside
FontSetup{propFont} <- getFontSetup
factionD <- getsState sfactionD
let (fid, fact@Faction{gkind=FK.FactionKind{..}, ..}) =
factions !! fromEnum slot
(name, person) = if fhasGender -- but we ignore "Controlled", etc.
then (makePhrase [MU.Ws $ MU.Text fname], MU.PlEtc)
else (fname, MU.Sg3rd)
(youThey, prompt) =
if fid == side
then ("You", makeSentence ["you are the", MU.Text name])
else ("They", makeSentence ["you are wary of the", MU.Text name])
-- wary even if the faction is allied
ts1 =
-- Display only the main groups, not to spam.
case map fst $ filter ((>= 100) . snd) fgroups of
[] -> [] -- only initial actors in the faction?
[fgroup] ->
[makeSentence [ "the faction consists of"
, MU.Ws $ MU.Text $ displayGroupName fgroup ]]
grps -> [makeSentence
[ "the faction attracts members such as:"
, MU.WWandW $ map (MU.Text . displayGroupName) grps ]]
++ [if fskillsOther == Ability.zeroSkills -- simplified
then youThey <+> "don't care about each other and crowd and stampede all at once, sometimes brutally colliding by accident."
else youThey <+> "pay attention to each other and take care to move one at a time."]
++ [ if fcanEscape
then "The faction is able to take part in races to an area exit."
else "The faction doesn't escape areas of conflict and attempts to block exits instead."]
++ [ "When all members are incapacitated, the faction dissolves."
| fneverEmpty ]
++ [if fhasGender
then "Its members are known to have sexual dimorphism and use gender pronouns."
else "Its members seem to prefer naked ground for sleeping."]
++ [ "Its ranks swell with time."
| fspawnsFast ]
++ [ "The faction is able to maintain activity on a level on its own, with a pointman coordinating each tactical maneuver."
| fhasPointman ]
-- Changes to all of these have visibility @PosAll@, so the player
-- knows them fully, except for @gvictims@, which is coupled to tracking
-- other factions' actors and so only incremented when we've seen
-- their actor killed (mostly likely killed by us).
ts2 = -- reporting regardless of whether any of the factions are dead
let renderDiplGroup [] = error "renderDiplGroup: null"
renderDiplGroup ((fid2, diplomacy) : rest) = MU.Phrase
[ MU.Text $ tshowDiplomacy diplomacy
, "with"
, MU.WWandW $ map renderFact2 $ fid2 : map fst rest ]
renderFact2 fid2 = MU.Text $ Faction.gname (factionD EM.! fid2)
valid (fid2, diplomacy) = isJust (lookup fid2 factions)
&& diplomacy /= Unknown
knownAssocsGroups = groupBy ((==) `on` snd) $ sortOn snd
$ filter valid $ EM.assocs gdipl
in [ makeSentence [ MU.SubjectVerb person MU.Yes (MU.Text name) "be"
, MU.WWandW $ map renderDiplGroup knownAssocsGroups ]
| not (null knownAssocsGroups) ]
ts3 =
case gquit of
Just Status{..} | not $ isHorrorFact fact ->
["The faction has already" <+> FK.nameOutcomePast stOutcome
<+> "around level" <+> tshow (abs stDepth) <> "."]
_ -> []
++ let nkilled = sum $ EM.elems gvictims
personKilled = if nkilled == 1 then MU.Sg3rd else MU.PlEtc
in [ makeSentence $
[ "so far," | isNothing gquit ]
++ [ "at least"
, MU.CardinalWs nkilled "member"
, MU.SubjectVerb personKilled
MU.Yes
"of this faction"
"have been incapacitated" ]
| nkilled > 0 ]
++ let adjective = if isNothing gquit then "current" else "last"
verb = if isNothing gquit then "is" else "was"
in ["Its" <+> adjective <+> "doctrine" <+> verb
<+> "'" <> Ability.nameDoctrine gdoctrine
<> "' (" <> Ability.describeDoctrine gdoctrine <> ")."]
-- Description of the score polynomial would go into a separate section,
-- but it's hard to make it sound non-technical enough.
blurbs = intersperse ["\n"] $ filter (not . null) [ts1, ts2, ts3]
return (prompt, map (\t -> (propFont, map textToAS t)) blurbs)
|
LambdaHack/LambdaHack
|
engine-src/Game/LambdaHack/Client/UI/InventoryM.hs
|
Haskell
|
bsd-3-clause
| 35,792
|
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE TypeSynonymInstances #-}
module CommonResources where
import Data.Aeson
import Data.Aeson.TH
import Data.Bits
import Data.Bson.Generic
import Data.Char
import Data.Time
import GHC.Generics
import Servant
authserverport :: String
authserverport = "8083"
authserverhost :: String
authserverhost = "localhost"
dirserverport :: String
dirserverport = "8080"
dirserverhost :: String
dirserverhost = "localhost"
fsserverport :: String
fsserverport = "7007"
fsserverhost :: String
fsserverhost = "localhost"
lockserverport :: String
lockserverport = "8084"
lockserverhost :: String
lockserverhost = "localhost"
transserverhost :: String
transserverhost = "localhost"
transserverport :: String
transserverport = "8085"
type DirectoryApi =
"join" :> ReqBody '[JSON] FileServer :> Post '[JSON] Response :<|>
"open" :> ReqBody '[JSON] FileName :> Post '[JSON] File :<|>
"close" :> ReqBody '[JSON] FileUpload :> Post '[JSON] Response :<|>
"allfiles" :> ReqBody '[JSON] Ticket :> Post '[JSON] [String] :<|>
"remove" :> ReqBody '[JSON] FileName :> Post '[JSON] Response
type AuthApi =
"signin" :> ReqBody '[JSON] Signin :> Post '[JSON] Session :<|>
"register" :> ReqBody '[JSON] Signin :> Post '[JSON] Response
{-} "isvalid" :> ReqBody '[JSON] User :> Post '[JSON] Response :<|>
"extend" :> ReqBody '[JSON] User :> Post '[JSON] Response-}
type FileApi =
"files" :> Get '[JSON] [FilePath] :<|>
"download" :> ReqBody '[JSON] FileName :> Post '[JSON] File :<|>
"upload" :> ReqBody '[JSON] FileUpload :> Post '[JSON] Response :<|>
"delete" :> ReqBody '[JSON] FileName :> Post '[JSON] Response
type LockingApi =
"lock" :> ReqBody '[JSON] FileName :> Post '[JSON] Response :<|>
"unlock" :> ReqBody '[JSON] FileName :> Post '[JSON] Response :<|>
"islocked" :> ReqBody '[JSON] FileName :> Post '[JSON] Response
type TransactionApi =
"begin" :> ReqBody '[JSON] Ticket :> Post '[JSON] Response :<|>
"transDownload" :> ReqBody '[JSON] FileName :> Post '[JSON] File :<|>
"transUpload" :> ReqBody '[JSON] FileUpload :> Post '[JSON] Response :<|>
"transcommit" :> ReqBody '[JSON] Ticket :> Post '[JSON] Response
data File = File {
fileName :: FilePath,
fileContent :: String
} deriving (Eq, Show, Generic, ToJSON, FromJSON)
data FileUpload = FileUpload {
futicket :: String,
encTimeout :: String,
encryptedFile :: File
} deriving (Show, Generic, FromJSON, ToJSON)
data FileName = FileName {
fnticket :: String,
fnencryptedTimeout :: String,
encryptedFN :: String
} deriving (Show, Generic, FromJSON, ToJSON)
data Response = Response{
response :: String
} deriving (Eq, Show, Generic, ToJSON, FromJSON)
data FileServer = FileServer{
id :: String,
fsaddress :: String,
fsport :: String
} deriving (Eq, Show, Generic, ToJSON, FromJSON)
data FileMapping = FileMapping{
fmfileName :: String,
fmaddress :: String,
fmport :: String
} deriving (Eq, Show, Generic,ToJSON, FromJSON, ToBSON, FromBSON)
data Lock = Lock{
lockfileName :: String,
locked :: Bool
} deriving(Eq, Show, Generic, ToBSON, FromBSON)
data Account = Account{
username :: String,
password :: String
} deriving (Show, Generic, FromJSON, ToJSON, FromBSON, ToBSON)
data Session = Session{
encryptedTicket :: String,
encryptedSessionKey :: String,
encryptedTokenTimeout :: String
} deriving (Eq, Show, Generic, ToJSON, FromJSON, ToBSON, FromBSON)
data Signin = Signin{
susername :: String,
sencryptedMsg :: String
} deriving (Eq, Show, Generic, ToJSON, FromJSON, ToBSON, FromBSON)
data Ticket = Ticket{
ticket :: String,
encryptedTimeout :: String
} deriving (Eq, Show, Generic, ToJSON, FromJSON, ToBSON, FromBSON)
data TransactionFile = TransactionFile{
transFileName :: String,
userID :: String
} deriving (Eq, Show, Generic, ToJSON, FromJSON, ToBSON, FromBSON)
deriving instance FromBSON String -- we need these as BSON does not provide
deriving instance ToBSON String
deriving instance FromBSON Bool -- we need these as BSON does not provide
deriving instance ToBSON Bool
encryptDecrypt :: String -> String -> String
encryptDecrypt key text = zipWith (\a b -> chr $ xor (ord a) (ord b)) (cycle key) text
-- XOR each element of the text with a corresponding element of the key
encryptTime :: String -> UTCTime -> String
encryptTime key time = encryptDecrypt key (show(time) :: String)
decryptTime :: String -> String -> UTCTime
decryptTime key text = (read $ encryptDecrypt key text) :: UTCTime
encryptPort :: String -> Int -> String
encryptPort key port = encryptDecrypt key (show(port) :: String)
decryptPort :: String -> String -> Int
decryptPort key text = (read $ encryptDecrypt key text) :: Int
encryptDecryptArray :: String -> [String] -> [String]
encryptDecryptArray key array = do
encryptedArray <- map (encryptDecrypt key) array
return encryptedArray
logMessage :: Bool -> String -> IO()
logMessage logBool message = do
if(logBool) then putStrLn message
else return ()
sharedSecret :: String
sharedSecret = "Maybe I'll complete this project one day"
|
Garygunn94/DFS
|
CommonResources/src/CommonResources.hs
|
Haskell
|
bsd-3-clause
| 5,480
|
module Main where
import Data.Maybe (isNothing, isJust)
import System.IO
import Network.Socket
import qualified System.Process as SysProc
import qualified System.Process.Internals as SysProcInt (withProcessHandle, ProcessHandle__(..))
import Control.Concurrent.MVar
import qualified System.Posix.Signals as Sig
main :: IO ()
main = do
putStrLn "Starting"
srvSock <- socket AF_INET Stream 0
setSocketOption srvSock ReuseAddr 1
bind srvSock (SockAddrInet 6699 iNADDR_ANY)
listen srvSock 1
runningProcesses <- newMVar []
Sig.installHandler Sig.sigCHLD (Sig.Catch (sigCHLDreaper runningProcesses)) Nothing
sockLoop srvSock runningProcesses
sockLoop :: Socket -> MVar [SysProc.ProcessHandle] -> IO ()
sockLoop srvSock runningProcesses = do
(remoteSock, remoteAddr) <- accept srvSock
putStrLn $ "client connected: " ++ show remoteAddr
hdl <- socketToHandle remoteSock ReadWriteMode
ph <- handleClient hdl
modifyMVar_ runningProcesses (\rp -> return (ph:rp))
modifyMVar_ runningProcesses reapAndPrint
sockLoop srvSock runningProcesses
sigCHLDreaper :: MVar [SysProc.ProcessHandle] -> IO ()
sigCHLDreaper runningProcesses = do
rp <- takeMVar runningProcesses
putStrLn "SIGCHLD"
rp <- reapAndPrint rp
putMVar runningProcesses rp
--Helper, TODO move to lib
reapAndPrint :: [SysProc.ProcessHandle] -> IO [SysProc.ProcessHandle]
reapAndPrint [] = return []
reapAndPrint phs = do
exs <- (mapM SysProc.getProcessExitCode phs)
let handlesAndExitCodes = zip phs exs
putStrLn "Child status:"
mapM_ printExitCode handlesAndExitCodes
--only keep those which have not yet exited
return [ph | (ph, exitcode) <- handlesAndExitCodes, isNothing exitcode]
where printExitCode (ph, Nothing) = getPid ph >>= \s -> putStrLn $ " "++ s ++ " running"
printExitCode (ph, (Just exitcode)) = getPid ph >>= \s -> putStrLn $ " " ++ s ++ " exited: " ++ show exitcode
getPid ph = SysProcInt.withProcessHandle ph (\phint -> case phint of
SysProcInt.OpenHandle h -> return ("[" ++ show h ++ "]")
SysProcInt.ClosedHandle _ -> return "")
handleClient :: Handle -> IO SysProc.ProcessHandle
handleClient hdl = do
putStrLn $ "handle client"
let shProcess = (SysProc.proc "/bin/sh" []){ SysProc.std_in = SysProc.UseHandle hdl,
SysProc.std_out = SysProc.UseHandle hdl,
SysProc.std_err = SysProc.UseHandle hdl,
SysProc.close_fds = True }
(Nothing, Nothing, Nothing, ph) <- SysProc.createProcess shProcess
putStrLn $ "created Process"
return ph
|
diekmann/tinyrsh
|
rsh-impls/hs-idiomatic/tinyrsh/app/Main.hs
|
Haskell
|
bsd-3-clause
| 2,836
|
{-# LANGUAGE RecursiveDo #-}
-- Example: Analysis of a PERT-type Network
--
-- It is described in different sources [1, 2]. So, this is chapter 14 of [2] and section 7.11 of [1].
--
-- PERT is a technique for evaluating and reviewing a project consisting of
-- interdependent activities. A number of books have been written that describe
-- PERT modeling and analysis procedures. A PERT network activity descriptions
-- are given in a table stated below. All activity times will be assumed to be
-- triangularly distributed. For ease of description, activities have been
-- aggregated. The activities relate to power units, instrumentation, and
-- a new assembly and involve standard types of operations.
--
-- In the following description of the project, activity numbers are given
-- in parentheses. At the beginning of the project, three parallel activities
-- can be performed that involve: the disassembly of power units and
-- instrumentation (1); the installation of a new assembly (2); and
-- the preparation for a retrofit check (3). Cleaning, inspecting, and
-- repairing the power units (4) and calibrating the instrumentation (5)
-- can be done only after the power units and instrumentation have been
-- disassembled. Thus, activities 4 and 5 must follow activity 1 in the network.
-- Following the installation of the new assembly (2) and after the instrumentation
-- have been calibrated (5), a check of interfaces (6) and a check of
-- the new assembly (7) can be made. The retrofit check (9) can be made
-- after the assembly is checked (7) and the preparation for the retrofit
-- check (3) has been completed. The assembly and test of power units (8)
-- can be performed following the cleaning and maintenance of power units (4).
-- The project is considered completed when all nine activities are completed.
-- Since activities 6, 8, and 9 require the other activities to precede them,
-- their completion signifies the end of the project. This is indicated on
-- the network by having activities 6, 8, and 9 incident to node 6, the sink
-- node for the project. The objective of this example is to illustrate
-- the procedures for using Aivika to model and simulate project planning network.
--
-- Activity Description Mode Minimum Maximum Average
--
-- 1 Disassemble power units and instrumentation 3 1 5 3
-- 2 Install new assembly 6 3 9 6
-- 3 Prepare for retrofit check 13 10 19 14
-- 4 Clean, inspect, and repair power units 9 3 12 8
-- 5 Calibrate instrumentation 3 1 8 4
-- 6 Check interfaces 9 8 16 11
-- 7 Check assembly 7 4 13 8
-- 8 Assemble and test power units 6 3 9 6
-- 9 Retrofit check 3 1 8 4
--
-- Node Depends of Activities
--
-- 1 -
-- 2 1
-- 3 2, 5
-- 4 3, 7
-- 5 4
-- 6 6, 8, 9
--
-- Activity Depends on Node
--
-- 1 1
-- 2 1
-- 3 1
-- 4 2
-- 5 2
-- 6 3
-- 7 3
-- 8 5
-- 9 4
--
-- [1] A. Alan B. Pritsker, Simulation with Visual SLAM and AweSim, 2nd ed.
-- [2] Труб И.И., Объектно-ориентированное моделирование на C++: Учебный курс. - СПб.: Питер, 2006
module Model (model) where
import Control.Monad
import Control.Monad.Trans
import Control.Arrow
import Data.Array
import Data.Maybe
import Data.Monoid
import Simulation.Aivika
model :: Simulation Results
model = mdo
timers' <- forM [2..5] $ \i -> newArrivalTimer
projCompletionTimer <- newArrivalTimer
let timers = array (2, 5) $ zip [2..] timers'
p1 = randomTriangularProcessor 1 3 5
p2 = randomTriangularProcessor 3 6 9
p3 = randomTriangularProcessor 10 13 19
p4 = randomTriangularProcessor 3 9 12
p5 = randomTriangularProcessor 1 3 8
p6 = randomTriangularProcessor 8 9 16
p7 = randomTriangularProcessor 4 7 13
p8 = randomTriangularProcessor 3 6 9
p9 = randomTriangularProcessor 1 3 8
let c2 = arrivalTimerProcessor (timers ! 2)
c3 = arrivalTimerProcessor (timers ! 3)
c4 = arrivalTimerProcessor (timers ! 4)
c5 = arrivalTimerProcessor (timers ! 5)
c6 = arrivalTimerProcessor projCompletionTimer
[i1, i2, i3] <- cloneStream 3 n1
[i4, i5] <- cloneStream 2 n2
[i6, i7] <- cloneStream 2 n3
let i9 = n4
i8 = n5
let s1 = runProcessor p1 i1
s2 = runProcessor p2 i2
s3 = runProcessor p3 i3
s4 = runProcessor p4 i4
s5 = runProcessor p5 i5
s6 = runProcessor p6 i6
s7 = runProcessor p7 i7
s8 = runProcessor p8 i8
s9 = runProcessor p9 i9
let n1 = takeStream 1 $ randomStream $ return (0, 0)
n2 = runProcessor c2 s1
n3 = runProcessor c3 $ firstArrivalStream 2 (s2 <> s5)
n4 = runProcessor c4 $ firstArrivalStream 2 (s3 <> s7)
n5 = runProcessor c5 s4
n6 = runProcessor c6 $ firstArrivalStream 3 (s6 <> s8 <> s9)
runProcessInStartTime $ sinkStream n6
return $
results
[resultSource
"timers" "Timers"
timers,
--
resultSource
"projCompletion" "Project Completion Timer"
projCompletionTimer]
modelSummary :: Simulation Results
modelSummary =
fmap resultSummary model
|
dsorokin/aivika-experiment-chart
|
examples/PERT/Model.hs
|
Haskell
|
bsd-3-clause
| 5,728
|
{-# LANGUAGE OverloadedStrings #-}
module KAT_PubKey.DSA (dsaTests) where
import qualified Crypto.PubKey.DSA as DSA
import Crypto.Hash
import Imports
data VectorDSA = VectorDSA
{ pgq :: DSA.Params
, msg :: ByteString
, x :: Integer
, y :: Integer
, k :: Integer
, r :: Integer
, s :: Integer
}
vectorsSHA1 =
[ VectorDSA
{ msg = "\x3b\x46\x73\x6d\x55\x9b\xd4\xe0\xc2\xc1\xb2\x55\x3a\x33\xad\x3c\x6c\xf2\x3c\xac\x99\x8d\x3d\x0c\x0e\x8f\xa4\xb1\x9b\xca\x06\xf2\xf3\x86\xdb\x2d\xcf\xf9\xdc\xa4\xf4\x0a\xd8\xf5\x61\xff\xc3\x08\xb4\x6c\x5f\x31\xa7\x73\x5b\x5f\xa7\xe0\xf9\xe6\xcb\x51\x2e\x63\xd7\xee\xa0\x55\x38\xd6\x6a\x75\xcd\x0d\x42\x34\xb5\xcc\xf6\xc1\x71\x5c\xca\xaf\x9c\xdc\x0a\x22\x28\x13\x5f\x71\x6e\xe9\xbd\xee\x7f\xc1\x3e\xc2\x7a\x03\xa6\xd1\x1c\x5c\x5b\x36\x85\xf5\x19\x00\xb1\x33\x71\x53\xbc\x6c\x4e\x8f\x52\x92\x0c\x33\xfa\x37\xf4\xe7"
, x = 0xc53eae6d45323164c7d07af5715703744a63fc3a
, y = 0x313fd9ebca91574e1c2eebe1517c57e0c21b0209872140c5328761bbb2450b33f1b18b409ce9ab7c4cd8fda3391e8e34868357c199e16a6b2eba06d6749def791d79e95d3a4d09b24c392ad89dbf100995ae19c01062056bb14bce005e8731efde175f95b975089bdcdaea562b32786d96f5a31aedf75364008ad4fffebb970b
, k = 0x98cbcc4969d845e2461b5f66383dd503712bbcfa
, r = 0x50ed0e810e3f1c7cb6ac62332058448bd8b284c0
, s = 0xc6aded17216b46b7e4b6f2a97c1ad7cc3da83fde
, pgq = dsaParams
}
, VectorDSA
{ msg = "\xd2\xbc\xb5\x3b\x04\x4b\x3e\x2e\x4b\x61\xba\x2f\x91\xc0\x99\x5f\xb8\x3a\x6a\x97\x52\x5e\x66\x44\x1a\x3b\x48\x9d\x95\x94\x23\x8b\xc7\x40\xbd\xee\xa0\xf7\x18\xa7\x69\xc9\x77\xe2\xde\x00\x38\x77\xb5\xd7\xdc\x25\xb1\x82\xae\x53\x3d\xb3\x3e\x78\xf2\xc3\xff\x06\x45\xf2\x13\x7a\xbc\x13\x7d\x4e\x7d\x93\xcc\xf2\x4f\x60\xb1\x8a\x82\x0b\xc0\x7c\x7b\x4b\x5f\xe0\x8b\x4f\x9e\x7d\x21\xb2\x56\xc1\x8f\x3b\x9d\x49\xac\xc4\xf9\x3e\x2c\xe6\xf3\x75\x4c\x78\x07\x75\x7d\x2e\x11\x76\x04\x26\x12\xcb\x32\xfc\x3f\x4f\x70\x70\x0e\x25"
, x = 0xe65131d73470f6ad2e5878bdc9bef536faf78831
, y = 0x29bdd759aaa62d4bf16b4861c81cf42eac2e1637b9ecba512bdbc13ac12a80ae8de2526b899ae5e4a231aef884197c944c732693a634d7659abc6975a773f8d3cd5a361fe2492386a3c09aaef12e4a7e73ad7dfc3637f7b093f2c40d6223a195c136adf2ea3fbf8704a675aa7817aa7ec7f9adfb2854d4e05c3ce7f76560313b
, k = 0x87256a64e98cf5be1034ecfa766f9d25d1ac7ceb
, r = 0xa26c00b5750a2d27fe7435b93476b35438b4d8ab
, s = 0x61c9bfcb2938755afa7dad1d1e07c6288617bf70
, pgq = dsaParams
}
, VectorDSA
{ msg = "\xd5\x43\x1e\x6b\x16\xfd\xae\x31\x48\x17\x42\xbd\x39\x47\x58\xbe\xb8\xe2\x4f\x31\x94\x7e\x19\xb7\xea\x7b\x45\x85\x21\x88\x22\x70\xc1\xf4\x31\x92\xaa\x05\x0f\x44\x85\x14\x5a\xf8\xf3\xf9\xc5\x14\x2d\x68\xb8\x50\x18\xd2\xec\x9c\xb7\xa3\x7b\xa1\x2e\xd2\x3e\x73\xb9\x5f\xd6\x80\xfb\xa3\xc6\x12\x65\xe9\xf5\xa0\xa0\x27\xd7\x0f\xad\x0c\x8a\xa0\x8a\x3c\xbf\xbe\x99\x01\x8d\x00\x45\x38\x61\x73\xe5\xfa\xe2\x25\xfa\xeb\xe0\xce\xf5\xdd\x45\x91\x0f\x40\x0a\x86\xc2\xbe\x4e\x15\x25\x2a\x16\xde\x41\x20\xa2\x67\xbe\x2b\x59\x4d"
, x = 0x20bcabc6d9347a6e79b8e498c60c44a19c73258c
, y = 0x23b4f404aa3c575e550bb320fdb1a085cd396a10e5ebc6771da62f037cab19eacd67d8222b6344038c4f7af45f5e62b55480cbe2111154ca9697ca76d87b56944138084e74c6f90a05cf43660dff8b8b3fabfcab3f0e4416775fdf40055864be102b4587392e77752ed2aeb182ee4f70be4a291dbe77b84a44ee34007957b1e0
, k = 0x7d9bcfc9225432de9860f605a38d389e291ca750
, r = 0x3f0a4ad32f0816821b8affb518e9b599f35d57c2
, s = 0xea06638f2b2fc9d1dfe99c2a492806b497e2b0ea
, pgq = dsaParams
}
, VectorDSA
{ msg = "\x85\x66\x2b\x69\x75\x50\xe4\x91\x5c\x29\xe3\x38\xb6\x24\xb9\x12\x84\x5d\x6d\x1a\x92\x0d\x9e\x4c\x16\x04\xdd\x47\xd6\x92\xbc\x7c\x0f\xfb\x95\xae\x61\x4e\x85\x2b\xeb\xaf\x15\x73\x75\x8a\xd0\x1c\x71\x3c\xac\x0b\x47\x6e\x2f\x12\x17\x45\xa3\xcf\xee\xff\xb2\x44\x1f\xf6\xab\xfb\x9b\xbe\xb9\x8a\xa6\x34\xca\x6f\xf5\x41\x94\x7d\xcc\x99\x27\x65\x9d\x44\xf9\x5c\x5f\xf9\x17\x0f\xdc\x3c\x86\x47\x3c\xb6\x01\xba\x31\xb4\x87\xfe\x59\x36\xba\xc5\xd9\xc6\x32\xcb\xcc\x3d\xb0\x62\x46\xba\x01\xc5\x5a\x03\x8d\x79\x7f\xe3\xf6\xc3"
, x = 0x52d1fbe687aa0702a51a5bf9566bd51bd569424c
, y = 0x6bc36cb3fa61cecc157be08639a7ca9e3de073b8a0ff23574ce5ab0a867dfd60669a56e60d1c989b3af8c8a43f5695d503e3098963990e12b63566784171058eace85c728cd4c08224c7a6efea75dca20df461013c75f40acbc23799ebee7f3361336dadc4a56f305708667bfe602b8ea75a491a5cf0c06ebd6fdc7161e10497
, k = 0x960c211891c090d05454646ebac1bfe1f381e82b
, r = 0x3bc29dee96957050ba438d1b3e17b02c1725d229
, s = 0x0af879cf846c434e08fb6c63782f4d03e0d88865
, pgq = dsaParams
}
, VectorDSA
{ msg = "\x87\xb6\xe7\x5b\x9f\x8e\x99\xc4\xdd\x62\xad\xb6\x93\xdd\x58\x90\xed\xff\x1b\xd0\x02\x8f\x4e\xf8\x49\xdf\x0f\x1d\x2c\xe6\xb1\x81\xfc\x3a\x55\xae\xa6\xd0\xa1\xf0\xae\xca\xb8\xed\x9e\x24\x8a\x00\xe9\x6b\xe7\x94\xa7\xcf\xba\x12\x46\xef\xb7\x10\xef\x4b\x37\x47\x1c\xef\x0a\x1b\xcf\x55\xce\xbc\x8d\x5a\xd0\x71\x61\x2b\xd2\x37\xef\xed\xd5\x10\x23\x62\xdb\x07\xa1\xe2\xc7\xa6\xf1\x5e\x09\xfe\x64\xba\x42\xb6\x0a\x26\x28\xd8\x69\xae\x05\xef\x61\x1f\xe3\x8d\x9c\xe1\x5e\xee\xc9\xbb\x3d\xec\xc8\xdc\x17\x80\x9f\x3b\x6e\x95"
, x = 0xc86a54ec5c4ec63d7332cf43ddb082a34ed6d5f5
, y = 0x014ac746d3605efcb8a2c7dae1f54682a262e27662b252c09478ce87d0aaa522d7c200043406016c0c42896d21750b15dbd57f9707ec37dcea5651781b67ad8d01f5099fe7584b353b641bb159cc717d8ceb18b66705e656f336f1214b34f0357e577ab83641969e311bf40bdcb3ffd5e0bb59419f229508d2f432cc2859ff75
, k = 0x6c445cee68042553fbe63be61be4ddb99d8134af
, r = 0x637e07a5770f3dc65e4506c68c770e5ef6b8ced3
, s = 0x7dfc6f83e24f09745e01d3f7ae0ed1474e811d47
, pgq = dsaParams
}
, VectorDSA
{ msg = "\x22\x59\xee\xad\x2d\x6b\xbc\x76\xd4\x92\x13\xea\x0d\xc8\xb7\x35\x0a\x97\x69\x9f\x22\x34\x10\x44\xc3\x94\x07\x82\x36\x4a\xc9\xea\x68\x31\x79\xa4\x38\xa5\xea\x45\x99\x8d\xf9\x7c\x29\x72\xda\xe0\x38\x51\xf5\xbe\x23\xfa\x9f\x04\x18\x2e\x79\xdd\xb2\xb5\x6d\xc8\x65\x23\x93\xec\xb2\x7f\x3f\x3b\x7c\x8a\x8d\x76\x1a\x86\xb3\xb8\xf4\xd4\x1a\x07\xb4\xbe\x7d\x02\xfd\xde\xfc\x42\xb9\x28\x12\x4a\x5a\x45\xb9\xf4\x60\x90\x42\x20\x9b\x3a\x7f\x58\x5b\xd5\x14\xcc\x39\xc0\x0e\xff\xcc\x42\xc7\xfe\x70\xfa\x83\xed\xf8\xa3\x2b\xf4"
, x = 0xaee6f213b9903c8069387e64729a08999e5baf65
, y = 0x0fe74045d7b0d472411202831d4932396f242a9765e92be387fd81bbe38d845054528b348c03984179b8e505674cb79d88cc0d8d3e8d7392f9aa773b29c29e54a9e326406075d755c291fcedbcc577934c824af988250f64ed5685fce726cff65e92d708ae11cbfaa958ab8d8b15340a29a137b5b4357f7ed1c7a5190cbf98a4
, k = 0xe1704bae025942e2e63c6d76bab88da79640073a
, r = 0x83366ba3fed93dfb38d541203ecbf81c363998e2
, s = 0x1fe299c36a1332f23bf2e10a6c6a4e0d3cdd2bf4
, pgq = dsaParams
}
, VectorDSA
{ msg = "\x21\x9e\x8d\xf5\xbf\x88\x15\x90\x43\x0e\xce\x60\x82\x50\xf7\x67\x0d\xc5\x65\x37\x24\x93\x02\x42\x9e\x28\xec\xfe\xb9\xce\xaa\xa5\x49\x10\xa6\x94\x90\xf7\x65\xf3\xdf\x82\xe8\xb0\x1c\xd7\xd7\x6e\x56\x1d\x0f\x6c\xe2\x26\xef\x3c\xf7\x52\xca\xda\x6f\xeb\xdc\x5b\xf0\x0d\x67\x94\x7f\x92\xd4\x20\x51\x6b\x9e\x37\xc9\x6c\x8f\x1f\x2d\xa0\xb0\x75\x09\x7c\x3b\xda\x75\x8a\x8d\x91\xbd\x2e\xbe\x9c\x75\xcf\x14\x7f\x25\x4c\x25\x69\x63\xb3\x3b\x67\xd0\x2b\x6a\xa0\x9e\x7d\x74\x65\xd0\x38\xe5\x01\x95\xec\xe4\x18\x9b\x41\xe7\x68"
, x = 0x699f1c07aa458c6786e770b40197235fe49cf21a
, y = 0x3a41b0678ff3c4dde20fa39772bac31a2f18bae4bedec9e12ee8e02e30e556b1a136013bef96b0d30b568233dcecc71e485ed75c922afb4d0654e709bee84993792130220e3005fdb06ebdfc0e2df163b5ec424e836465acd6d92e243c86f2b94b26b8d73bd9cf722c757e0b80b0af16f185de70e8ca850b1402d126ea60f309
, k = 0x5bbb795bfa5fa72191fed3434a08741410367491
, r = 0x579761039ae0ddb81106bf4968e320083bbcb947
, s = 0x503ea15dbac9dedeba917fa8e9f386b93aa30353
, pgq = dsaParams
}
, VectorDSA
{ msg = "\x2d\xa7\x9d\x06\x78\x85\xeb\x3c\xcf\x5e\x29\x3a\xe3\xb1\xd8\x22\x53\x22\x20\x3a\xbb\x5a\xdf\xde\x3b\x0f\x53\xbb\xe2\x4c\x4f\xe0\x01\x54\x1e\x11\x83\xd8\x70\xa9\x97\xf1\xf9\x46\x01\x00\xb5\xd7\x11\x92\x31\x80\x15\x43\x45\x28\x7a\x02\x14\xcf\x1c\xac\x37\xb7\xa4\x7d\xfb\xb2\xa0\xe8\xce\x49\x16\xf9\x4e\xbd\x6f\xa5\x4e\x31\x5b\x7a\x8e\xb5\xb6\x3c\xd9\x54\xc5\xba\x05\xc1\xbf\x7e\x33\xa4\xe8\xa1\x51\xf3\x2d\x28\x77\xb0\x17\x29\xc1\xad\x0e\x7c\x01\xbb\x8a\xe7\x23\xc9\x95\x18\x38\x03\xe4\x56\x36\x52\x0e\xa3\x8c\xa1"
, x = 0xd6e08c20c82949ddba93ea81eb2fea8c595894dc
, y = 0x56f7272210f316c51af8bfc45a421fd4e9b1043853271b7e79f40936f0adcf262a86097aa86e19e6cb5307685d863dba761342db6c973b3849b1e060aca926f41fe07323601062515ae85f3172b8f34899c621d59fa21f73d5ae97a3deb5e840b25a18fd580862fd7b1cf416c7ae9fc5842a0197fdb0c5173ff4a4f102a8cf89
, k = 0x6d72c30d4430959800740f2770651095d0c181c2
, r = 0x5dd90d69add67a5fae138eec1aaff0229aa4afc4
, s = 0x47f39c4db2387f10762f45b80dfd027906d7ef04
, pgq = dsaParams
}
, VectorDSA
{ msg = "\xba\x30\xd8\x5b\xe3\x57\xe7\xfb\x29\xf8\xa0\x7e\x1f\x12\x7b\xaa\xa2\x4b\x2e\xe0\x27\xf6\x4c\xb5\xef\xee\xc6\xaa\xea\xbc\xc7\x34\x5c\x5d\x55\x6e\xbf\x4b\xdc\x7a\x61\xc7\x7c\x7b\x7e\xa4\x3c\x73\xba\xbc\x18\xf7\xb4\x80\x77\x22\xda\x23\x9e\x45\xdd\xf2\x49\x84\x9c\xbb\xfe\x35\x07\x11\x2e\xbf\x87\xd7\xef\x56\x0c\x2e\x7d\x39\x1e\xd8\x42\x4f\x87\x10\xce\xa4\x16\x85\x14\x3e\x30\x06\xf8\x1b\x68\xfb\xb4\xd5\xf9\x64\x4c\x7c\xd1\x0f\x70\x92\xef\x24\x39\xb8\xd1\x8c\x0d\xf6\x55\xe0\x02\x89\x37\x2a\x41\x66\x38\x5d\x64\x0c"
, x = 0x50018482864c1864e9db1f04bde8dbfd3875c76d
, y = 0x0942a5b7a72ab116ead29308cf658dfe3d55d5d61afed9e3836e64237f9d6884fdd827d2d5890c9a41ae88e7a69fc9f345ade9c480c6f08cff067c183214c227236cedb6dd1283ca2a602574e8327510221d4c27b162143b7002d8c726916826265937b87be9d5ec6d7bd28fb015f84e0ab730da7a4eaf4ef3174bf0a22a6392
, k = 0xdf3a9348f37b5d2d4c9176db266ae388f1fa7e0f
, r = 0x448434b214eee38bde080f8ec433e8d19b3ddf0d
, s = 0x0c02e881b777923fe0ea674f2621298e00199d5f
, pgq = dsaParams
}
, VectorDSA
{ msg = "\x83\x49\x9e\xfb\x06\xbb\x7f\xf0\x2f\xfb\x46\xc2\x78\xa5\xe9\x26\x30\xac\x5b\xc3\xf9\xe5\x3d\xd2\xe7\x8f\xf1\x5e\x36\x8c\x7e\x31\xaa\xd7\x7c\xf7\x71\xf3\x5f\xa0\x2d\x0b\x5f\x13\x52\x08\xa4\xaf\xdd\x86\x7b\xb2\xec\x26\xea\x2e\x7d\xd6\x4c\xde\xf2\x37\x50\x8a\x38\xb2\x7f\x39\xd8\xb2\x2d\x45\xca\xc5\xa6\x8a\x90\xb6\xea\x76\x05\x86\x45\xf6\x35\x6a\x93\x44\xd3\x6f\x00\xec\x66\x52\xea\xa4\xe9\xba\xe7\xb6\x94\xf9\xf1\xfc\x8c\x6c\x5e\x86\xfa\xdc\x7b\x27\xa2\x19\xb5\xc1\xb2\xae\x80\xa7\x25\xe5\xf6\x11\x65\xfe\x2e\xdc"
, x = 0xae56f66b0a9405b9cca54c60ec4a3bb5f8be7c3f
, y = 0xa01542c3da410dd57930ca724f0f507c4df43d553c7f69459939685941ceb95c7dcc3f175a403b359621c0d4328e98f15f330a63865baf3e7eb1604a0715e16eed64fd14b35d3a534259a6a7ddf888c4dbb5f51bbc6ed339e5bb2a239d5cfe2100ac8e2f9c16e536f25119ab435843af27dc33414a9e4602f96d7c94d6021cec
, k = 0x8857ff301ad0169d164fa269977a116e070bac17
, r = 0x8c2fab489c34672140415d41a65cef1e70192e23
, s = 0x3df86a9e2efe944a1c7ea9c30cac331d00599a0e
, pgq = dsaParams
}
, VectorDSA -- 1024-bit example from RFC 6979 with SHA-1
{ msg = "sample"
, x = 0x411602CB19A6CCC34494D79D98EF1E7ED5AF25F7
, y = 0x5DF5E01DED31D0297E274E1691C192FE5868FEF9E19A84776454B100CF16F65392195A38B90523E2542EE61871C0440CB87C322FC4B4D2EC5E1E7EC766E1BE8D4CE935437DC11C3C8FD426338933EBFE739CB3465F4D3668C5E473508253B1E682F65CBDC4FAE93C2EA212390E54905A86E2223170B44EAA7DA5DD9FFCFB7F3B
, k = 0x7BDB6B0FF756E1BB5D53583EF979082F9AD5BD5B
, r = 0x2E1A0C2562B2912CAAF89186FB0F42001585DA55
, s = 0x29EFB6B0AFF2D7A68EB70CA313022253B9A88DF5
, pgq = rfc6979Params1024
}
, VectorDSA -- 1024-bit example from RFC 6979 with SHA-1
{ msg = "test"
, x = 0x411602CB19A6CCC34494D79D98EF1E7ED5AF25F7
, y = 0x5DF5E01DED31D0297E274E1691C192FE5868FEF9E19A84776454B100CF16F65392195A38B90523E2542EE61871C0440CB87C322FC4B4D2EC5E1E7EC766E1BE8D4CE935437DC11C3C8FD426338933EBFE739CB3465F4D3668C5E473508253B1E682F65CBDC4FAE93C2EA212390E54905A86E2223170B44EAA7DA5DD9FFCFB7F3B
, k = 0x5C842DF4F9E344EE09F056838B42C7A17F4A6433
, r = 0x42AB2052FD43E123F0607F115052A67DCD9C5C77
, s = 0x183916B0230D45B9931491D4C6B0BD2FB4AAF088
, pgq = rfc6979Params1024
}
, VectorDSA -- 2048-bit example from RFC 6979 with SHA-1
{ msg = "sample"
, x = 0x69C7548C21D0DFEA6B9A51C9EAD4E27C33D3B3F180316E5BCAB92C933F0E4DBC
, y = 0x667098C654426C78D7F8201EAC6C203EF030D43605032C2F1FA937E5237DBD949F34A0A2564FE126DC8B715C5141802CE0979C8246463C40E6B6BDAA2513FA611728716C2E4FD53BC95B89E69949D96512E873B9C8F8DFD499CC312882561ADECB31F658E934C0C197F2C4D96B05CBAD67381E7B768891E4DA3843D24D94CDFB5126E9B8BF21E8358EE0E0A30EF13FD6A664C0DCE3731F7FB49A4845A4FD8254687972A2D382599C9BAC4E0ED7998193078913032558134976410B89D2C171D123AC35FD977219597AA7D15C1A9A428E59194F75C721EBCBCFAE44696A499AFA74E04299F132026601638CB87AB79190D4A0986315DA8EEC6561C938996BEADF
, k = 0x888FA6F7738A41BDC9846466ABDB8174C0338250AE50CE955CA16230F9CBD53E
, r = 0x3A1B2DBD7489D6ED7E608FD036C83AF396E290DBD602408E8677DAABD6E7445A
, s = 0xD26FCBA19FA3E3058FFC02CA1596CDBB6E0D20CB37B06054F7E36DED0CDBBCCF
, pgq = rfc6979Params2048
}
, VectorDSA -- 2048-bit example from RFC 6979 with SHA-1
{ msg = "test"
, x = 0x69C7548C21D0DFEA6B9A51C9EAD4E27C33D3B3F180316E5BCAB92C933F0E4DBC
, y = 0x667098C654426C78D7F8201EAC6C203EF030D43605032C2F1FA937E5237DBD949F34A0A2564FE126DC8B715C5141802CE0979C8246463C40E6B6BDAA2513FA611728716C2E4FD53BC95B89E69949D96512E873B9C8F8DFD499CC312882561ADECB31F658E934C0C197F2C4D96B05CBAD67381E7B768891E4DA3843D24D94CDFB5126E9B8BF21E8358EE0E0A30EF13FD6A664C0DCE3731F7FB49A4845A4FD8254687972A2D382599C9BAC4E0ED7998193078913032558134976410B89D2C171D123AC35FD977219597AA7D15C1A9A428E59194F75C721EBCBCFAE44696A499AFA74E04299F132026601638CB87AB79190D4A0986315DA8EEC6561C938996BEADF
, k = 0x6EEA486F9D41A037B2C640BC5645694FF8FF4B98D066A25F76BE641CCB24BA4F
, r = 0xC18270A93CFC6063F57A4DFA86024F700D980E4CF4E2CB65A504397273D98EA0
, s = 0x414F22E5F31A8B6D33295C7539C1C1BA3A6160D7D68D50AC0D3A5BEAC2884FAA
, pgq = rfc6979Params2048
}
]
where -- (p,g,q)
dsaParams = DSA.Params
{ DSA.params_p = 0xa8f9cd201e5e35d892f85f80e4db2599a5676a3b1d4f190330ed3256b26d0e80a0e49a8fffaaad2a24f472d2573241d4d6d6c7480c80b4c67bb4479c15ada7ea8424d2502fa01472e760241713dab025ae1b02e1703a1435f62ddf4ee4c1b664066eb22f2e3bf28bb70a2a76e4fd5ebe2d1229681b5b06439ac9c7e9d8bde283
, DSA.params_g = 0x2b3152ff6c62f14622b8f48e59f8af46883b38e79b8c74deeae9df131f8b856e3ad6c8455dab87cc0da8ac973417ce4f7878557d6cdf40b35b4a0ca3eb310c6a95d68ce284ad4e25ea28591611ee08b8444bd64b25f3f7c572410ddfb39cc728b9c936f85f419129869929cdb909a6a3a99bbe089216368171bd0ba81de4fe33
, DSA.params_q = 0xf85f0f83ac4df7ea0cdf8f469bfeeaea14156495
}
vectorsSHA224 =
[ VectorDSA
{ msg = "sample"
, x = 0x411602CB19A6CCC34494D79D98EF1E7ED5AF25F7
, y = 0x5DF5E01DED31D0297E274E1691C192FE5868FEF9E19A84776454B100CF16F65392195A38B90523E2542EE61871C0440CB87C322FC4B4D2EC5E1E7EC766E1BE8D4CE935437DC11C3C8FD426338933EBFE739CB3465F4D3668C5E473508253B1E682F65CBDC4FAE93C2EA212390E54905A86E2223170B44EAA7DA5DD9FFCFB7F3B
, k = 0x562097C06782D60C3037BA7BE104774344687649
, r = 0x4BC3B686AEA70145856814A6F1BB53346F02101E
, s = 0x410697B92295D994D21EDD2F4ADA85566F6F94C1
, pgq = rfc6979Params1024
}
, VectorDSA
{ msg = "test"
, x = 0x411602CB19A6CCC34494D79D98EF1E7ED5AF25F7
, y = 0x5DF5E01DED31D0297E274E1691C192FE5868FEF9E19A84776454B100CF16F65392195A38B90523E2542EE61871C0440CB87C322FC4B4D2EC5E1E7EC766E1BE8D4CE935437DC11C3C8FD426338933EBFE739CB3465F4D3668C5E473508253B1E682F65CBDC4FAE93C2EA212390E54905A86E2223170B44EAA7DA5DD9FFCFB7F3B
, k = 0x4598B8EFC1A53BC8AECD58D1ABBB0C0C71E67297
, r = 0x6868E9964E36C1689F6037F91F28D5F2C30610F2
, s = 0x49CEC3ACDC83018C5BD2674ECAAD35B8CD22940F
, pgq = rfc6979Params1024
}
, VectorDSA
{ msg = "sample"
, x = 0x69C7548C21D0DFEA6B9A51C9EAD4E27C33D3B3F180316E5BCAB92C933F0E4DBC
, y = 0x667098C654426C78D7F8201EAC6C203EF030D43605032C2F1FA937E5237DBD949F34A0A2564FE126DC8B715C5141802CE0979C8246463C40E6B6BDAA2513FA611728716C2E4FD53BC95B89E69949D96512E873B9C8F8DFD499CC312882561ADECB31F658E934C0C197F2C4D96B05CBAD67381E7B768891E4DA3843D24D94CDFB5126E9B8BF21E8358EE0E0A30EF13FD6A664C0DCE3731F7FB49A4845A4FD8254687972A2D382599C9BAC4E0ED7998193078913032558134976410B89D2C171D123AC35FD977219597AA7D15C1A9A428E59194F75C721EBCBCFAE44696A499AFA74E04299F132026601638CB87AB79190D4A0986315DA8EEC6561C938996BEADF
, k = 0xBC372967702082E1AA4FCE892209F71AE4AD25A6DFD869334E6F153BD0C4D806
, r = 0xDC9F4DEADA8D8FF588E98FED0AB690FFCE858DC8C79376450EB6B76C24537E2C
, s = 0xA65A9C3BC7BABE286B195D5DA68616DA8D47FA0097F36DD19F517327DC848CEC
, pgq = rfc6979Params2048
}
, VectorDSA
{ msg = "test"
, x = 0x69C7548C21D0DFEA6B9A51C9EAD4E27C33D3B3F180316E5BCAB92C933F0E4DBC
, y = 0x667098C654426C78D7F8201EAC6C203EF030D43605032C2F1FA937E5237DBD949F34A0A2564FE126DC8B715C5141802CE0979C8246463C40E6B6BDAA2513FA611728716C2E4FD53BC95B89E69949D96512E873B9C8F8DFD499CC312882561ADECB31F658E934C0C197F2C4D96B05CBAD67381E7B768891E4DA3843D24D94CDFB5126E9B8BF21E8358EE0E0A30EF13FD6A664C0DCE3731F7FB49A4845A4FD8254687972A2D382599C9BAC4E0ED7998193078913032558134976410B89D2C171D123AC35FD977219597AA7D15C1A9A428E59194F75C721EBCBCFAE44696A499AFA74E04299F132026601638CB87AB79190D4A0986315DA8EEC6561C938996BEADF
, k = 0x06BD4C05ED74719106223BE33F2D95DA6B3B541DAD7BFBD7AC508213B6DA6670
, r = 0x272ABA31572F6CC55E30BF616B7A265312018DD325BE031BE0CC82AA17870EA3
, s = 0xE9CC286A52CCE201586722D36D1E917EB96A4EBDB47932F9576AC645B3A60806
, pgq = rfc6979Params2048
}
]
vectorsSHA256 =
[ VectorDSA
{ msg = "sample"
, x = 0x411602CB19A6CCC34494D79D98EF1E7ED5AF25F7
, y = 0x5DF5E01DED31D0297E274E1691C192FE5868FEF9E19A84776454B100CF16F65392195A38B90523E2542EE61871C0440CB87C322FC4B4D2EC5E1E7EC766E1BE8D4CE935437DC11C3C8FD426338933EBFE739CB3465F4D3668C5E473508253B1E682F65CBDC4FAE93C2EA212390E54905A86E2223170B44EAA7DA5DD9FFCFB7F3B
, k = 0x519BA0546D0C39202A7D34D7DFA5E760B318BCFB
, r = 0x81F2F5850BE5BC123C43F71A3033E9384611C545
, s = 0x4CDD914B65EB6C66A8AAAD27299BEE6B035F5E89
, pgq = rfc6979Params1024
}
, VectorDSA
{ msg = "test"
, x = 0x411602CB19A6CCC34494D79D98EF1E7ED5AF25F7
, y = 0x5DF5E01DED31D0297E274E1691C192FE5868FEF9E19A84776454B100CF16F65392195A38B90523E2542EE61871C0440CB87C322FC4B4D2EC5E1E7EC766E1BE8D4CE935437DC11C3C8FD426338933EBFE739CB3465F4D3668C5E473508253B1E682F65CBDC4FAE93C2EA212390E54905A86E2223170B44EAA7DA5DD9FFCFB7F3B
, k = 0x5A67592E8128E03A417B0484410FB72C0B630E1A
, r = 0x22518C127299B0F6FDC9872B282B9E70D0790812
, s = 0x6837EC18F150D55DE95B5E29BE7AF5D01E4FE160
, pgq = rfc6979Params1024
}
, VectorDSA
{ msg = "sample"
, x = 0x69C7548C21D0DFEA6B9A51C9EAD4E27C33D3B3F180316E5BCAB92C933F0E4DBC
, y = 0x667098C654426C78D7F8201EAC6C203EF030D43605032C2F1FA937E5237DBD949F34A0A2564FE126DC8B715C5141802CE0979C8246463C40E6B6BDAA2513FA611728716C2E4FD53BC95B89E69949D96512E873B9C8F8DFD499CC312882561ADECB31F658E934C0C197F2C4D96B05CBAD67381E7B768891E4DA3843D24D94CDFB5126E9B8BF21E8358EE0E0A30EF13FD6A664C0DCE3731F7FB49A4845A4FD8254687972A2D382599C9BAC4E0ED7998193078913032558134976410B89D2C171D123AC35FD977219597AA7D15C1A9A428E59194F75C721EBCBCFAE44696A499AFA74E04299F132026601638CB87AB79190D4A0986315DA8EEC6561C938996BEADF
, k = 0x8926A27C40484216F052F4427CFD5647338B7B3939BC6573AF4333569D597C52
, r = 0xEACE8BDBBE353C432A795D9EC556C6D021F7A03F42C36E9BC87E4AC7932CC809
, s = 0x7081E175455F9247B812B74583E9E94F9EA79BD640DC962533B0680793A38D53
, pgq = rfc6979Params2048
}
, VectorDSA
{ msg = "test"
, x = 0x69C7548C21D0DFEA6B9A51C9EAD4E27C33D3B3F180316E5BCAB92C933F0E4DBC
, y = 0x667098C654426C78D7F8201EAC6C203EF030D43605032C2F1FA937E5237DBD949F34A0A2564FE126DC8B715C5141802CE0979C8246463C40E6B6BDAA2513FA611728716C2E4FD53BC95B89E69949D96512E873B9C8F8DFD499CC312882561ADECB31F658E934C0C197F2C4D96B05CBAD67381E7B768891E4DA3843D24D94CDFB5126E9B8BF21E8358EE0E0A30EF13FD6A664C0DCE3731F7FB49A4845A4FD8254687972A2D382599C9BAC4E0ED7998193078913032558134976410B89D2C171D123AC35FD977219597AA7D15C1A9A428E59194F75C721EBCBCFAE44696A499AFA74E04299F132026601638CB87AB79190D4A0986315DA8EEC6561C938996BEADF
, k = 0x1D6CE6DDA1C5D37307839CD03AB0A5CBB18E60D800937D67DFB4479AAC8DEAD7
, r = 0x8190012A1969F9957D56FCCAAD223186F423398D58EF5B3CEFD5A4146A4476F0
, s = 0x7452A53F7075D417B4B013B278D1BB8BBD21863F5E7B1CEE679CF2188E1AB19E
, pgq = rfc6979Params2048
}
]
vectorsSHA384 =
[ VectorDSA
{ msg = "sample"
, x = 0x411602CB19A6CCC34494D79D98EF1E7ED5AF25F7
, y = 0x5DF5E01DED31D0297E274E1691C192FE5868FEF9E19A84776454B100CF16F65392195A38B90523E2542EE61871C0440CB87C322FC4B4D2EC5E1E7EC766E1BE8D4CE935437DC11C3C8FD426338933EBFE739CB3465F4D3668C5E473508253B1E682F65CBDC4FAE93C2EA212390E54905A86E2223170B44EAA7DA5DD9FFCFB7F3B
, k = 0x95897CD7BBB944AA932DBC579C1C09EB6FCFC595
, r = 0x07F2108557EE0E3921BC1774F1CA9B410B4CE65A
, s = 0x54DF70456C86FAC10FAB47C1949AB83F2C6F7595
, pgq = rfc6979Params1024
}
, VectorDSA
{ msg = "test"
, x = 0x411602CB19A6CCC34494D79D98EF1E7ED5AF25F7
, y = 0x5DF5E01DED31D0297E274E1691C192FE5868FEF9E19A84776454B100CF16F65392195A38B90523E2542EE61871C0440CB87C322FC4B4D2EC5E1E7EC766E1BE8D4CE935437DC11C3C8FD426338933EBFE739CB3465F4D3668C5E473508253B1E682F65CBDC4FAE93C2EA212390E54905A86E2223170B44EAA7DA5DD9FFCFB7F3B
, k = 0x220156B761F6CA5E6C9F1B9CF9C24BE25F98CD89
, r = 0x854CF929B58D73C3CBFDC421E8D5430CD6DB5E66
, s = 0x91D0E0F53E22F898D158380676A871A157CDA622
, pgq = rfc6979Params1024
}
, VectorDSA
{ msg = "sample"
, x = 0x69C7548C21D0DFEA6B9A51C9EAD4E27C33D3B3F180316E5BCAB92C933F0E4DBC
, y = 0x667098C654426C78D7F8201EAC6C203EF030D43605032C2F1FA937E5237DBD949F34A0A2564FE126DC8B715C5141802CE0979C8246463C40E6B6BDAA2513FA611728716C2E4FD53BC95B89E69949D96512E873B9C8F8DFD499CC312882561ADECB31F658E934C0C197F2C4D96B05CBAD67381E7B768891E4DA3843D24D94CDFB5126E9B8BF21E8358EE0E0A30EF13FD6A664C0DCE3731F7FB49A4845A4FD8254687972A2D382599C9BAC4E0ED7998193078913032558134976410B89D2C171D123AC35FD977219597AA7D15C1A9A428E59194F75C721EBCBCFAE44696A499AFA74E04299F132026601638CB87AB79190D4A0986315DA8EEC6561C938996BEADF
, k = 0xC345D5AB3DA0A5BCB7EC8F8FB7A7E96069E03B206371EF7D83E39068EC564920
, r = 0xB2DA945E91858834FD9BF616EBAC151EDBC4B45D27D0DD4A7F6A22739F45C00B
, s = 0x19048B63D9FD6BCA1D9BAE3664E1BCB97F7276C306130969F63F38FA8319021B
, pgq = rfc6979Params2048
}
, VectorDSA
{ msg = "test"
, x = 0x69C7548C21D0DFEA6B9A51C9EAD4E27C33D3B3F180316E5BCAB92C933F0E4DBC
, y = 0x667098C654426C78D7F8201EAC6C203EF030D43605032C2F1FA937E5237DBD949F34A0A2564FE126DC8B715C5141802CE0979C8246463C40E6B6BDAA2513FA611728716C2E4FD53BC95B89E69949D96512E873B9C8F8DFD499CC312882561ADECB31F658E934C0C197F2C4D96B05CBAD67381E7B768891E4DA3843D24D94CDFB5126E9B8BF21E8358EE0E0A30EF13FD6A664C0DCE3731F7FB49A4845A4FD8254687972A2D382599C9BAC4E0ED7998193078913032558134976410B89D2C171D123AC35FD977219597AA7D15C1A9A428E59194F75C721EBCBCFAE44696A499AFA74E04299F132026601638CB87AB79190D4A0986315DA8EEC6561C938996BEADF
, k = 0x206E61F73DBE1B2DC8BE736B22B079E9DACD974DB00EEBBC5B64CAD39CF9F91C
, r = 0x239E66DDBE8F8C230A3D071D601B6FFBDFB5901F94D444C6AF56F732BEB954BE
, s = 0x6BD737513D5E72FE85D1C750E0F73921FE299B945AAD1C802F15C26A43D34961
, pgq = rfc6979Params2048
}
]
vectorsSHA512 =
[ VectorDSA
{ msg = "sample"
, x = 0x411602CB19A6CCC34494D79D98EF1E7ED5AF25F7
, y = 0x5DF5E01DED31D0297E274E1691C192FE5868FEF9E19A84776454B100CF16F65392195A38B90523E2542EE61871C0440CB87C322FC4B4D2EC5E1E7EC766E1BE8D4CE935437DC11C3C8FD426338933EBFE739CB3465F4D3668C5E473508253B1E682F65CBDC4FAE93C2EA212390E54905A86E2223170B44EAA7DA5DD9FFCFB7F3B
, k = 0x09ECE7CA27D0F5A4DD4E556C9DF1D21D28104F8B
, r = 0x16C3491F9B8C3FBBDD5E7A7B667057F0D8EE8E1B
, s = 0x02C36A127A7B89EDBB72E4FFBC71DABC7D4FC69C
, pgq = rfc6979Params1024
}
, VectorDSA
{ msg = "test"
, x = 0x411602CB19A6CCC34494D79D98EF1E7ED5AF25F7
, y = 0x5DF5E01DED31D0297E274E1691C192FE5868FEF9E19A84776454B100CF16F65392195A38B90523E2542EE61871C0440CB87C322FC4B4D2EC5E1E7EC766E1BE8D4CE935437DC11C3C8FD426338933EBFE739CB3465F4D3668C5E473508253B1E682F65CBDC4FAE93C2EA212390E54905A86E2223170B44EAA7DA5DD9FFCFB7F3B
, k = 0x65D2C2EEB175E370F28C75BFCDC028D22C7DBE9C
, r = 0x8EA47E475BA8AC6F2D821DA3BD212D11A3DEB9A0
, s = 0x7C670C7AD72B6C050C109E1790008097125433E8
, pgq = rfc6979Params1024
}
, VectorDSA
{ msg = "sample"
, x = 0x69C7548C21D0DFEA6B9A51C9EAD4E27C33D3B3F180316E5BCAB92C933F0E4DBC
, y = 0x667098C654426C78D7F8201EAC6C203EF030D43605032C2F1FA937E5237DBD949F34A0A2564FE126DC8B715C5141802CE0979C8246463C40E6B6BDAA2513FA611728716C2E4FD53BC95B89E69949D96512E873B9C8F8DFD499CC312882561ADECB31F658E934C0C197F2C4D96B05CBAD67381E7B768891E4DA3843D24D94CDFB5126E9B8BF21E8358EE0E0A30EF13FD6A664C0DCE3731F7FB49A4845A4FD8254687972A2D382599C9BAC4E0ED7998193078913032558134976410B89D2C171D123AC35FD977219597AA7D15C1A9A428E59194F75C721EBCBCFAE44696A499AFA74E04299F132026601638CB87AB79190D4A0986315DA8EEC6561C938996BEADF
, k = 0x5A12994431785485B3F5F067221517791B85A597B7A9436995C89ED0374668FC
, r = 0x2016ED092DC5FB669B8EFB3D1F31A91EECB199879BE0CF78F02BA062CB4C942E
, s = 0xD0C76F84B5F091E141572A639A4FB8C230807EEA7D55C8A154A224400AFF2351
, pgq = rfc6979Params2048
}
, VectorDSA
{ msg = "test"
, x = 0x69C7548C21D0DFEA6B9A51C9EAD4E27C33D3B3F180316E5BCAB92C933F0E4DBC
, y = 0x667098C654426C78D7F8201EAC6C203EF030D43605032C2F1FA937E5237DBD949F34A0A2564FE126DC8B715C5141802CE0979C8246463C40E6B6BDAA2513FA611728716C2E4FD53BC95B89E69949D96512E873B9C8F8DFD499CC312882561ADECB31F658E934C0C197F2C4D96B05CBAD67381E7B768891E4DA3843D24D94CDFB5126E9B8BF21E8358EE0E0A30EF13FD6A664C0DCE3731F7FB49A4845A4FD8254687972A2D382599C9BAC4E0ED7998193078913032558134976410B89D2C171D123AC35FD977219597AA7D15C1A9A428E59194F75C721EBCBCFAE44696A499AFA74E04299F132026601638CB87AB79190D4A0986315DA8EEC6561C938996BEADF
, k = 0xAFF1651E4CD6036D57AA8B2A05CCF1A9D5A40166340ECBBDC55BE10B568AA0AA
, r = 0x89EC4BB1400ECCFF8E7D9AA515CD1DE7803F2DAFF09693EE7FD1353E90A68307
, s = 0xC9F0BDABCC0D880BB137A994CC7F3980CE91CC10FAF529FC46565B15CEA854E1
, pgq = rfc6979Params2048
}
]
rfc6979Params1024 = DSA.Params
{ DSA.params_p = 0x86F5CA03DCFEB225063FF830A0C769B9DD9D6153AD91D7CE27F787C43278B447E6533B86B18BED6E8A48B784A14C252C5BE0DBF60B86D6385BD2F12FB763ED8873ABFD3F5BA2E0A8C0A59082EAC056935E529DAF7C610467899C77ADEDFC846C881870B7B19B2B58F9BE0521A17002E3BDD6B86685EE90B3D9A1B02B782B1779
, DSA.params_g = 0x07B0F92546150B62514BB771E2A0C0CE387F03BDA6C56B505209FF25FD3C133D89BBCD97E904E09114D9A7DEFDEADFC9078EA544D2E401AEECC40BB9FBBF78FD87995A10A1C27CB7789B594BA7EFB5C4326A9FE59A070E136DB77175464ADCA417BE5DCE2F40D10A46A3A3943F26AB7FD9C0398FF8C76EE0A56826A8A88F1DBD
, DSA.params_q = 0x996F967F6C8E388D9E28D01E205FBA957A5698B1
}
rfc6979Params2048 = DSA.Params
{ DSA.params_p = 0x9DB6FB5951B66BB6FE1E140F1D2CE5502374161FD6538DF1648218642F0B5C48C8F7A41AADFA187324B87674FA1822B00F1ECF8136943D7C55757264E5A1A44FFE012E9936E00C1D3E9310B01C7D179805D3058B2A9F4BB6F9716BFE6117C6B5B3CC4D9BE341104AD4A80AD6C94E005F4B993E14F091EB51743BF33050C38DE235567E1B34C3D6A5C0CEAA1A0F368213C3D19843D0B4B09DCB9FC72D39C8DE41F1BF14D4BB4563CA28371621CAD3324B6A2D392145BEBFAC748805236F5CA2FE92B871CD8F9C36D3292B5509CA8CAA77A2ADFC7BFD77DDA6F71125A7456FEA153E433256A2261C6A06ED3693797E7995FAD5AABBCFBE3EDA2741E375404AE25B
, DSA.params_g = 0x5C7FF6B06F8F143FE8288433493E4769C4D988ACE5BE25A0E24809670716C613D7B0CEE6932F8FAA7C44D2CB24523DA53FBE4F6EC3595892D1AA58C4328A06C46A15662E7EAA703A1DECF8BBB2D05DBE2EB956C142A338661D10461C0D135472085057F3494309FFA73C611F78B32ADBB5740C361C9F35BE90997DB2014E2EF5AA61782F52ABEB8BD6432C4DD097BC5423B285DAFB60DC364E8161F4A2A35ACA3A10B1C4D203CC76A470A33AFDCBDD92959859ABD8B56E1725252D78EAC66E71BA9AE3F1DD2487199874393CD4D832186800654760E1E34C09E4D155179F9EC0DC4473F996BDCE6EED1CABED8B6F116F7AD9CF505DF0F998E34AB27514B0FFE7
, DSA.params_q = 0xF2C3119374CE76C9356990B465374A17F23F9ED35089BD969F61C6DDE9998C1F
}
vectorToPrivate :: VectorDSA -> DSA.PrivateKey
vectorToPrivate vector = DSA.PrivateKey
{ DSA.private_x = x vector
, DSA.private_params = pgq vector
}
vectorToPublic :: VectorDSA -> DSA.PublicKey
vectorToPublic vector = DSA.PublicKey
{ DSA.public_y = y vector
, DSA.public_params = pgq vector
}
doSignatureTest hashAlg i vector = testCase (show i) (expected @=? actual)
where expected = Just $ DSA.Signature (r vector) (s vector)
actual = DSA.signWith (k vector) (vectorToPrivate vector) hashAlg (msg vector)
doVerifyTest hashAlg i vector = testCase (show i) (True @=? actual)
where actual = DSA.verify hashAlg (vectorToPublic vector) (DSA.Signature (r vector) (s vector)) (msg vector)
dsaTests = testGroup "DSA"
[ testGroup "SHA1"
[ testGroup "signature" $ zipWith (doSignatureTest SHA1) [katZero..] vectorsSHA1
, testGroup "verify" $ zipWith (doVerifyTest SHA1) [katZero..] vectorsSHA1
]
, testGroup "SHA224"
[ testGroup "signature" $ zipWith (doSignatureTest SHA224) [katZero..] vectorsSHA224
, testGroup "verify" $ zipWith (doVerifyTest SHA224) [katZero..] vectorsSHA224
]
, testGroup "SHA256"
[ testGroup "signature" $ zipWith (doSignatureTest SHA256) [katZero..] vectorsSHA256
, testGroup "verify" $ zipWith (doVerifyTest SHA256) [katZero..] vectorsSHA256
]
, testGroup "SHA384"
[ testGroup "signature" $ zipWith (doSignatureTest SHA384) [katZero..] vectorsSHA384
, testGroup "verify" $ zipWith (doVerifyTest SHA384) [katZero..] vectorsSHA384
]
, testGroup "SHA512"
[ testGroup "signature" $ zipWith (doSignatureTest SHA512) [katZero..] vectorsSHA512
, testGroup "verify" $ zipWith (doVerifyTest SHA512) [katZero..] vectorsSHA512
]
]
|
vincenthz/cryptonite
|
tests/KAT_PubKey/DSA.hs
|
Haskell
|
bsd-3-clause
| 31,104
|
{-# LANGUAGE Trustworthy #-}
{-# LANGUAGE CPP, NoImplicitPrelude #-}
-----------------------------------------------------------------------------
-- |
-- Module : Foreign.C.String
-- Copyright : (c) The FFI task force 2001
-- License : BSD-style (see the file libraries/base/LICENSE)
--
-- Maintainer : ffi@haskell.org
-- Stability : provisional
-- Portability : portable
--
-- Utilities for primitive marshalling of C strings.
--
-- The marshalling converts each Haskell character, representing a Unicode
-- code point, to one or more bytes in a manner that, by default, is
-- determined by the current locale. As a consequence, no guarantees
-- can be made about the relative length of a Haskell string and its
-- corresponding C string, and therefore all the marshalling routines
-- include memory allocation. The translation between Unicode and the
-- encoding of the current locale may be lossy.
--
-----------------------------------------------------------------------------
module Foreign.C.String ( -- representation of strings in C
-- * C strings
CString,
CStringLen,
-- ** Using a locale-dependent encoding
-- | These functions are different from their @CAString@ counterparts
-- in that they will use an encoding determined by the current locale,
-- rather than always assuming ASCII.
-- conversion of C strings into Haskell strings
--
peekCString,
peekCStringLen,
-- conversion of Haskell strings into C strings
--
newCString,
newCStringLen,
-- conversion of Haskell strings into C strings using temporary storage
--
withCString,
withCStringLen,
charIsRepresentable,
-- ** Using 8-bit characters
-- | These variants of the above functions are for use with C libraries
-- that are ignorant of Unicode. These functions should be used with
-- care, as a loss of information can occur.
castCharToCChar,
castCCharToChar,
castCharToCUChar,
castCUCharToChar,
castCharToCSChar,
castCSCharToChar,
peekCAString,
peekCAStringLen,
newCAString,
newCAStringLen,
withCAString,
withCAStringLen,
-- * C wide strings
-- | These variants of the above functions are for use with C libraries
-- that encode Unicode using the C @wchar_t@ type in a system-dependent
-- way. The only encodings supported are
--
-- * UTF-32 (the C compiler defines @__STDC_ISO_10646__@), or
--
-- * UTF-16 (as used on Windows systems).
CWString,
CWStringLen,
peekCWString,
peekCWStringLen,
newCWString,
newCWStringLen,
withCWString,
withCWStringLen,
) where
import Foreign.Marshal.Array
import Foreign.C.Types
import Foreign.Ptr
import Foreign.Storable
import Data.Word
import GHC.Char
import GHC.List
import GHC.Real
import GHC.Num
import GHC.Base
import {-# SOURCE #-} GHC.IO.Encoding
import qualified GHC.Foreign as GHC
-----------------------------------------------------------------------------
-- Strings
-- representation of strings in C
-- ------------------------------
-- | A C string is a reference to an array of C characters terminated by NUL.
type CString = Ptr CChar
-- | A string with explicit length information in bytes instead of a
-- terminating NUL (allowing NUL characters in the middle of the string).
type CStringLen = (Ptr CChar, Int)
-- exported functions
-- ------------------
--
-- * the following routines apply the default conversion when converting the
-- C-land character encoding into the Haskell-land character encoding
-- | Marshal a NUL terminated C string into a Haskell string.
--
peekCString :: CString -> IO String
peekCString s = getForeignEncoding >>= flip GHC.peekCString s
-- | Marshal a C string with explicit length into a Haskell string.
--
peekCStringLen :: CStringLen -> IO String
peekCStringLen s = getForeignEncoding >>= flip GHC.peekCStringLen s
-- | Marshal a Haskell string into a NUL terminated C string.
--
-- * the Haskell string may /not/ contain any NUL characters
--
-- * new storage is allocated for the C string and must be
-- explicitly freed using 'Foreign.Marshal.Alloc.free' or
-- 'Foreign.Marshal.Alloc.finalizerFree'.
--
newCString :: String -> IO CString
newCString s = getForeignEncoding >>= flip GHC.newCString s
-- | Marshal a Haskell string into a C string (ie, character array) with
-- explicit length information.
--
-- * new storage is allocated for the C string and must be
-- explicitly freed using 'Foreign.Marshal.Alloc.free' or
-- 'Foreign.Marshal.Alloc.finalizerFree'.
--
newCStringLen :: String -> IO CStringLen
newCStringLen s = getForeignEncoding >>= flip GHC.newCStringLen s
-- | Marshal a Haskell string into a NUL terminated C string using temporary
-- storage.
--
-- * the Haskell string may /not/ contain any NUL characters
--
-- * the memory is freed when the subcomputation terminates (either
-- normally or via an exception), so the pointer to the temporary
-- storage must /not/ be used after this.
--
withCString :: String -> (CString -> IO a) -> IO a
withCString s f = getForeignEncoding >>= \enc -> GHC.withCString enc s f
-- | Marshal a Haskell string into a C string (ie, character array)
-- in temporary storage, with explicit length information.
--
-- * the memory is freed when the subcomputation terminates (either
-- normally or via an exception), so the pointer to the temporary
-- storage must /not/ be used after this.
--
withCStringLen :: String -> (CStringLen -> IO a) -> IO a
withCStringLen s f = getForeignEncoding >>= \enc -> GHC.withCStringLen enc s f
-- -- | Determines whether a character can be accurately encoded in a 'CString'.
-- -- Unrepresentable characters are converted to '?' or their nearest visual equivalent.
charIsRepresentable :: Char -> IO Bool
charIsRepresentable c = getForeignEncoding >>= flip GHC.charIsRepresentable c
-- single byte characters
-- ----------------------
--
-- ** NOTE: These routines don't handle conversions! **
-- | Convert a C byte, representing a Latin-1 character, to the corresponding
-- Haskell character.
castCCharToChar :: CChar -> Char
castCCharToChar ch = unsafeChr (fromIntegral (fromIntegral ch :: Word8))
-- | Convert a Haskell character to a C character.
-- This function is only safe on the first 256 characters.
castCharToCChar :: Char -> CChar
castCharToCChar ch = fromIntegral (ord ch)
-- | Convert a C @unsigned char@, representing a Latin-1 character, to
-- the corresponding Haskell character.
castCUCharToChar :: CUChar -> Char
castCUCharToChar ch = unsafeChr (fromIntegral (fromIntegral ch :: Word8))
-- | Convert a Haskell character to a C @unsigned char@.
-- This function is only safe on the first 256 characters.
castCharToCUChar :: Char -> CUChar
castCharToCUChar ch = fromIntegral (ord ch)
-- | Convert a C @signed char@, representing a Latin-1 character, to the
-- corresponding Haskell character.
castCSCharToChar :: CSChar -> Char
castCSCharToChar ch = unsafeChr (fromIntegral (fromIntegral ch :: Word8))
-- | Convert a Haskell character to a C @signed char@.
-- This function is only safe on the first 256 characters.
castCharToCSChar :: Char -> CSChar
castCharToCSChar ch = fromIntegral (ord ch)
-- | Marshal a NUL terminated C string into a Haskell string.
--
peekCAString :: CString -> IO String
peekCAString cp = do
l <- lengthArray0 nUL cp
if l <= 0 then return "" else loop "" (l-1)
where
loop s i = do
xval <- peekElemOff cp i
let val = castCCharToChar xval
val `seq` if i <= 0 then return (val:s) else loop (val:s) (i-1)
-- | Marshal a C string with explicit length into a Haskell string.
--
peekCAStringLen :: CStringLen -> IO String
peekCAStringLen (cp, len)
| len <= 0 = return "" -- being (too?) nice.
| otherwise = loop [] (len-1)
where
loop acc i = do
xval <- peekElemOff cp i
let val = castCCharToChar xval
-- blow away the coercion ASAP.
if (val `seq` (i == 0))
then return (val:acc)
else loop (val:acc) (i-1)
-- | Marshal a Haskell string into a NUL terminated C string.
--
-- * the Haskell string may /not/ contain any NUL characters
--
-- * new storage is allocated for the C string and must be
-- explicitly freed using 'Foreign.Marshal.Alloc.free' or
-- 'Foreign.Marshal.Alloc.finalizerFree'.
--
newCAString :: String -> IO CString
newCAString str = do
ptr <- mallocArray0 (length str)
let
go [] n = pokeElemOff ptr n nUL
go (c:cs) n = do pokeElemOff ptr n (castCharToCChar c); go cs (n+1)
go str 0
return ptr
-- | Marshal a Haskell string into a C string (ie, character array) with
-- explicit length information.
--
-- * new storage is allocated for the C string and must be
-- explicitly freed using 'Foreign.Marshal.Alloc.free' or
-- 'Foreign.Marshal.Alloc.finalizerFree'.
--
newCAStringLen :: String -> IO CStringLen
newCAStringLen str = do
ptr <- mallocArray0 len
let
go [] n = n `seq` return () -- make it strict in n
go (c:cs) n = do pokeElemOff ptr n (castCharToCChar c); go cs (n+1)
go str 0
return (ptr, len)
where
len = length str
-- | Marshal a Haskell string into a NUL terminated C string using temporary
-- storage.
--
-- * the Haskell string may /not/ contain any NUL characters
--
-- * the memory is freed when the subcomputation terminates (either
-- normally or via an exception), so the pointer to the temporary
-- storage must /not/ be used after this.
--
withCAString :: String -> (CString -> IO a) -> IO a
withCAString str f =
allocaArray0 (length str) $ \ptr ->
let
go [] n = pokeElemOff ptr n nUL
go (c:cs) n = do pokeElemOff ptr n (castCharToCChar c); go cs (n+1)
in do
go str 0
f ptr
-- | Marshal a Haskell string into a C string (ie, character array)
-- in temporary storage, with explicit length information.
--
-- * the memory is freed when the subcomputation terminates (either
-- normally or via an exception), so the pointer to the temporary
-- storage must /not/ be used after this.
--
withCAStringLen :: String -> (CStringLen -> IO a) -> IO a
withCAStringLen str f =
allocaArray len $ \ptr ->
let
go [] n = n `seq` return () -- make it strict in n
go (c:cs) n = do pokeElemOff ptr n (castCharToCChar c); go cs (n+1)
in do
go str 0
f (ptr,len)
where
len = length str
-- auxiliary definitions
-- ----------------------
-- C's end of string character
--
nUL :: CChar
nUL = 0
-- allocate an array to hold the list and pair it with the number of elements
newArrayLen :: Storable a => [a] -> IO (Ptr a, Int)
newArrayLen xs = do
a <- newArray xs
return (a, length xs)
-----------------------------------------------------------------------------
-- Wide strings
-- representation of wide strings in C
-- -----------------------------------
-- | A C wide string is a reference to an array of C wide characters
-- terminated by NUL.
type CWString = Ptr CWchar
-- | A wide character string with explicit length information in 'CWchar's
-- instead of a terminating NUL (allowing NUL characters in the middle
-- of the string).
type CWStringLen = (Ptr CWchar, Int)
-- | Marshal a NUL terminated C wide string into a Haskell string.
--
peekCWString :: CWString -> IO String
peekCWString cp = do
cs <- peekArray0 wNUL cp
return (cWcharsToChars cs)
-- | Marshal a C wide string with explicit length into a Haskell string.
--
peekCWStringLen :: CWStringLen -> IO String
peekCWStringLen (cp, len) = do
cs <- peekArray len cp
return (cWcharsToChars cs)
-- | Marshal a Haskell string into a NUL terminated C wide string.
--
-- * the Haskell string may /not/ contain any NUL characters
--
-- * new storage is allocated for the C wide string and must
-- be explicitly freed using 'Foreign.Marshal.Alloc.free' or
-- 'Foreign.Marshal.Alloc.finalizerFree'.
--
newCWString :: String -> IO CWString
newCWString = newArray0 wNUL . charsToCWchars
-- | Marshal a Haskell string into a C wide string (ie, wide character array)
-- with explicit length information.
--
-- * new storage is allocated for the C wide string and must
-- be explicitly freed using 'Foreign.Marshal.Alloc.free' or
-- 'Foreign.Marshal.Alloc.finalizerFree'.
--
newCWStringLen :: String -> IO CWStringLen
newCWStringLen str = newArrayLen (charsToCWchars str)
-- | Marshal a Haskell string into a NUL terminated C wide string using
-- temporary storage.
--
-- * the Haskell string may /not/ contain any NUL characters
--
-- * the memory is freed when the subcomputation terminates (either
-- normally or via an exception), so the pointer to the temporary
-- storage must /not/ be used after this.
--
withCWString :: String -> (CWString -> IO a) -> IO a
withCWString = withArray0 wNUL . charsToCWchars
-- | Marshal a Haskell string into a C wide string (i.e. wide
-- character array) in temporary storage, with explicit length
-- information.
--
-- * the memory is freed when the subcomputation terminates (either
-- normally or via an exception), so the pointer to the temporary
-- storage must /not/ be used after this.
--
withCWStringLen :: String -> (CWStringLen -> IO a) -> IO a
withCWStringLen str f =
withArrayLen (charsToCWchars str) $ \ len ptr -> f (ptr, len)
-- auxiliary definitions
-- ----------------------
wNUL :: CWchar
wNUL = 0
cWcharsToChars :: [CWchar] -> [Char]
charsToCWchars :: [Char] -> [CWchar]
#if defined(mingw32_HOST_OS)
-- On Windows, wchar_t is 16 bits wide and CWString uses the UTF-16 encoding.
-- coding errors generate Chars in the surrogate range
cWcharsToChars = map chr . fromUTF16 . map fromIntegral
where
fromUTF16 (c1:c2:wcs)
| 0xd800 <= c1 && c1 <= 0xdbff && 0xdc00 <= c2 && c2 <= 0xdfff =
((c1 - 0xd800)*0x400 + (c2 - 0xdc00) + 0x10000) : fromUTF16 wcs
fromUTF16 (c:wcs) = c : fromUTF16 wcs
fromUTF16 [] = []
charsToCWchars = foldr utf16Char [] . map ord
where
utf16Char c wcs
| c < 0x10000 = fromIntegral c : wcs
| otherwise = let c' = c - 0x10000 in
fromIntegral (c' `div` 0x400 + 0xd800) :
fromIntegral (c' `mod` 0x400 + 0xdc00) : wcs
#else /* !mingw32_HOST_OS */
cWcharsToChars xs = map castCWcharToChar xs
charsToCWchars xs = map castCharToCWchar xs
-- These conversions only make sense if __STDC_ISO_10646__ is defined
-- (meaning that wchar_t is ISO 10646, aka Unicode)
castCWcharToChar :: CWchar -> Char
castCWcharToChar ch = chr (fromIntegral ch )
castCharToCWchar :: Char -> CWchar
castCharToCWchar ch = fromIntegral (ord ch)
#endif /* !mingw32_HOST_OS */
|
rahulmutt/ghcvm
|
libraries/base/Foreign/C/String.hs
|
Haskell
|
bsd-3-clause
| 14,674
|
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TupleSections #-}
module HERMIT.Dictionary.Unfold
( externals
, betaReducePlusR
, unfoldR
, unfoldPredR
, unfoldNameR
, unfoldNamesR
, unfoldSaturatedR
, specializeR
) where
import Control.Arrow
import Control.Monad
import HERMIT.Dictionary.Common
import HERMIT.Dictionary.Inline (inlineR)
import HERMIT.Core
import HERMIT.Context
import HERMIT.External
import HERMIT.GHC
import HERMIT.Kure
import HERMIT.Monad
import HERMIT.Name
import Prelude hiding (exp)
------------------------------------------------------------------------
externals :: [External]
externals =
[ external "beta-reduce-plus" (promoteExprR betaReducePlusR :: RewriteH LCore)
[ "Perform one or more beta-reductions."] .+ Eval .+ Shallow
, external "unfold" (promoteExprR unfoldR :: RewriteH LCore)
[ "In application f x y z, unfold f." ] .+ Deep .+ Context
, external "unfold" (promoteExprR . unfoldNameR . unOccurrenceName :: OccurrenceName -> RewriteH LCore)
[ "Inline a definition, and apply the arguments; traditional unfold." ] .+ Deep .+ Context
, external "unfold" (promoteExprR . unfoldNamesR . map unOccurrenceName:: [OccurrenceName] -> RewriteH LCore)
[ "Unfold a definition if it is named in the list." ] .+ Deep .+ Context
, external "unfold-saturated" (promoteExprR unfoldSaturatedR :: RewriteH LCore)
[ "Unfold a definition only if the function is fully applied." ] .+ Deep .+ Context
, external "specialize" (promoteExprR specializeR :: RewriteH LCore)
[ "Specialize an application to its type and coercion arguments." ] .+ Deep .+ Context
]
------------------------------------------------------------------------
-- | Perform one or more beta reductions.
betaReducePlusR :: MonadCatch m => Rewrite c m CoreExpr
betaReducePlusR = prefixFailMsg "Multi-beta-reduction failed: " $ do
(f,args) <- callT
let (f',args',atLeastOne) = reduceAll f args False
reduceAll (Lam v body) (a:as) _ = reduceAll (substCoreExpr v a body) as True
reduceAll e as b = (e,as,b)
guardMsg atLeastOne "no beta reductions possible."
return $ mkCoreApps f' args'
-- | A more powerful 'inline'. Matches two cases:
-- Var ==> inlines
-- App ==> inlines the head of the function call for the app tree
unfoldR :: forall c m. ( AddBindings c, ExtendPath c Crumb, HasEmptyContext c
, ReadBindings c, ReadPath c Crumb, MonadCatch m )
=> Rewrite c m CoreExpr
unfoldR = prefixFailMsg "unfold failed: " (go >>> tryR betaReducePlusR)
where go :: Rewrite c m CoreExpr
go = appAllR go idR <+ inlineR -- this order gives better error messages
unfoldPredR :: ( AddBindings c, ExtendPath c Crumb, HasEmptyContext c, ReadBindings c, ReadPath c Crumb
, MonadCatch m )
=> (Id -> [CoreExpr] -> Bool) -> Rewrite c m CoreExpr
unfoldPredR p = callPredT p >> unfoldR
unfoldNameR :: ( ExtendPath c Crumb, ReadPath c Crumb, AddBindings c, ReadBindings c, HasEmptyContext c
, MonadCatch m )
=> HermitName -> Rewrite c m CoreExpr
unfoldNameR nm = prefixFailMsg ("unfold '" ++ show nm ++ " failed: ") (callNameT nm >> unfoldR)
unfoldNamesR :: ( ExtendPath c Crumb, ReadPath c Crumb, AddBindings c, ReadBindings c, HasEmptyContext c
, MonadCatch m )
=> [HermitName] -> Rewrite c m CoreExpr
unfoldNamesR [] = fail "unfold-names failed: no names given."
unfoldNamesR nms = setFailMsg "unfold-names failed." $ orR (map unfoldNameR nms)
unfoldSaturatedR :: (ExtendPath c Crumb, ReadPath c Crumb, AddBindings c, ReadBindings c, HasEmptyContext c) => Rewrite c HermitM CoreExpr
unfoldSaturatedR = callSaturatedT >> unfoldR
specializeR :: (ExtendPath c Crumb, ReadPath c Crumb, AddBindings c, ReadBindings c, HasEmptyContext c) => Rewrite c HermitM CoreExpr
specializeR = unfoldPredR (const $ all isTyCoArg)
|
conal/hermit
|
src/HERMIT/Dictionary/Unfold.hs
|
Haskell
|
bsd-2-clause
| 4,084
|
module IOFullyQualifiedUsed where
import qualified System.IO (putStrLn)
main :: IO ()
main = System.IO.putStrLn "test"
|
serokell/importify
|
test/test-data/base@basic/24-IOFullyQualifiedUsed.hs
|
Haskell
|
mit
| 121
|
{-|
Module : Idris.Completion
Description : Support for command-line completion at the REPL and in the prover.
Copyright :
License : BSD3
Maintainer : The Idris Community.
-}
module Idris.Completion (replCompletion, proverCompletion) where
import Idris.AbsSyntax (runIO)
import Idris.AbsSyntaxTree
import Idris.Colours
import Idris.Core.Evaluate (ctxtAlist, definitions)
import Idris.Core.TT
import Idris.Help
import Idris.Imports (installedPackages)
import Idris.Parser.Expr (TacticArg(..))
import qualified Idris.Parser.Expr (constants, tactics)
import Idris.Parser.Helpers (opChars)
import Idris.REPL.Parser (allHelp, setOptions)
import Control.Monad.State.Strict
import Data.Char (toLower)
import Data.List
import qualified Data.Map.Strict as Map
import Data.Maybe
import qualified Data.Text as T
import System.Console.ANSI (Color)
import System.Console.Haskeline
commands = [ n | (names, _, _) <- allHelp ++ extraHelp, n <- names ]
tacticArgs :: [(String, Maybe TacticArg)]
tacticArgs = [ (name, args) | (names, args, _) <- Idris.Parser.Expr.tactics
, name <- names ]
tactics = map fst tacticArgs
-- | Get the user-visible names from the current interpreter state.
names :: Idris [String]
names = do i <- get
let ctxt = tt_ctxt i
return $
mapMaybe nameString (allNames $ definitions ctxt) ++
"Type" : map fst Idris.Parser.Expr.constants
where
-- We need both fully qualified names and identifiers that map to them
allNames :: Ctxt a -> [Name]
allNames ctxt =
let mappings = Map.toList ctxt
in concatMap (\(name, mapping) -> name : Map.keys mapping) mappings
-- Convert a name into a string usable for completion. Filters out names
-- that users probably don't want to see.
nameString :: Name -> Maybe String
nameString (UN n) = Just (str n)
nameString (NS n ns) =
let path = intercalate "." . map T.unpack . reverse $ ns
in fmap ((path ++ ".") ++) $ nameString n
nameString _ = Nothing
metavars :: Idris [String]
metavars = do i <- get
return . map (show . nsroot) $ map fst (filter (\(_, (_,_,_,t,_)) -> not t) (idris_metavars i)) \\ primDefs
modules :: Idris [String]
modules = do i <- get
return $ map show $ imported i
namespaces :: Idris [String]
namespaces = do
ctxt <- fmap tt_ctxt get
let names = map fst $ ctxtAlist ctxt
return $ nub $ catMaybes $ map extractNS names
where
extractNS :: Name -> Maybe String
extractNS (NS n ns) = Just $ intercalate "." . map T.unpack . reverse $ ns
extractNS _ = Nothing
-- UpTo means if user enters full name then no other completions are shown
-- Full always show other (longer) completions if there are any
data CompletionMode = UpTo | Full deriving Eq
completeWithMode :: CompletionMode -> [String] -> String -> [Completion]
completeWithMode mode ns n =
if uniqueExists || (fullWord && mode == UpTo)
then [simpleCompletion n]
else map simpleCompletion prefixMatches
where prefixMatches = filter (isPrefixOf n) ns
uniqueExists = [n] == prefixMatches
fullWord = n `elem` ns
completeWith = completeWithMode Full
completeName :: CompletionMode -> [String] -> CompletionFunc Idris
completeName mode extra = completeWord Nothing (" \t(){}:" ++ completionWhitespace) completeName
where
completeName n = do
ns <- names
return $ completeWithMode mode (extra ++ ns) n
-- The '.' needs not to be taken into consideration because it serves as namespace separator
completionWhitespace = opChars \\ "."
completeMetaVar :: CompletionFunc Idris
completeMetaVar = completeWord Nothing (" \t(){}:" ++ opChars) completeM
where completeM m = do mvs <- metavars
return $ completeWithMode UpTo mvs m
completeNamespace :: CompletionFunc Idris
completeNamespace = completeWord Nothing " \t" completeN
where completeN n = do ns <- namespaces
return $ completeWithMode UpTo ns n
completeOption :: CompletionFunc Idris
completeOption = completeWord Nothing " \t" completeOpt
where completeOpt = return . completeWith (map fst setOptions)
completeConsoleWidth :: CompletionFunc Idris
completeConsoleWidth = completeWord Nothing " \t" completeW
where completeW = return . completeWith ["auto", "infinite", "80", "120"]
isWhitespace :: Char -> Bool
isWhitespace = (flip elem) " \t\n"
lookupInHelp :: String -> Maybe CmdArg
lookupInHelp cmd = lookupInHelp' cmd allHelp
where lookupInHelp' cmd ((cmds, arg, _):xs) | elem cmd cmds = Just arg
| otherwise = lookupInHelp' cmd xs
lookupInHelp' cmd [] = Nothing
completeColour :: CompletionFunc Idris
completeColour (prev, next) = case words (reverse prev) of
[c] | isCmd c -> do cmpls <- completeColourOpt next
return (reverse $ c ++ " ", cmpls)
[c, o] | o `elem` opts -> let correct = (c ++ " " ++ o) in
return (reverse correct, [simpleCompletion ""])
| o `elem` colourTypes -> completeColourFormat (prev, next)
| otherwise -> let cmpls = completeWith (opts ++ colourTypes) o in
let sofar = (c ++ " ") in
return (reverse sofar, cmpls)
cmd@(c:o:_) | isCmd c && o `elem` colourTypes ->
completeColourFormat (prev, next)
_ -> noCompletion (prev, next)
where completeColourOpt :: String -> Idris [Completion]
completeColourOpt = return . completeWith (opts ++ colourTypes)
opts = ["on", "off"]
colourTypes = map (map toLower . reverse . drop 6 . reverse . show) $
enumFromTo (minBound::ColourType) maxBound
isCmd ":colour" = True
isCmd ":color" = True
isCmd _ = False
colours = map (map toLower . show) $ enumFromTo (minBound::Color) maxBound
formats = ["vivid", "dull", "underline", "nounderline", "bold", "nobold", "italic", "noitalic"]
completeColourFormat = let getCmpl = completeWith (colours ++ formats) in
completeWord Nothing " \t" (return . getCmpl)
-- The FIXMEs are Issue #1768 on the issue tracker.
-- https://github.com/idris-lang/Idris-dev/issues/1768
-- | Get the completion function for a particular command
completeCmd :: String -> CompletionFunc Idris
completeCmd cmd (prev, next) = fromMaybe completeCmdName $ fmap completeArg $ lookupInHelp cmd
where completeArg FileArg = completeFilename (prev, next)
completeArg ShellCommandArg = completeFilename (prev, next)
completeArg NameArg = completeName UpTo [] (prev, next)
completeArg OptionArg = completeOption (prev, next)
completeArg ModuleArg = noCompletion (prev, next)
completeArg NamespaceArg = completeNamespace (prev, next)
completeArg ExprArg = completeName Full [] (prev, next)
completeArg MetaVarArg = completeMetaVar (prev, next)
completeArg ColourArg = completeColour (prev, next)
completeArg NoArg = noCompletion (prev, next)
completeArg ConsoleWidthArg = completeConsoleWidth (prev, next)
completeArg DeclArg = completeName Full [] (prev, next)
completeArg PkgArgs = completePkg (prev, next)
completeArg (ManyArgs a) = completeArg a
completeArg (OptionalArg a) = completeArg a
completeArg (SeqArgs a b) = completeArg a
completeArg _ = noCompletion (prev, next)
completeCmdName = return ("", completeWith commands cmd)
-- | Complete REPL commands and defined identifiers
replCompletion :: CompletionFunc Idris
replCompletion (prev, next) = case firstWord of
':':cmdName -> completeCmd (':':cmdName) (prev, next)
_ -> completeName UpTo [] (prev, next)
where firstWord = fst $ break isWhitespace $ dropWhile isWhitespace $ reverse prev
completePkg :: CompletionFunc Idris
completePkg = completeWord Nothing " \t()" completeP
where completeP p = do pkgs <- runIO installedPackages
return $ completeWith pkgs p
-- The TODOs are Issue #1769 on the issue tracker.
-- https://github.com/idris-lang/Idris-dev/issues/1769
completeTactic :: [String] -> String -> CompletionFunc Idris
completeTactic as tac (prev, next) = fromMaybe completeTacName . fmap completeArg $
lookup tac tacticArgs
where completeTacName = return ("", completeWith tactics tac)
completeArg Nothing = noCompletion (prev, next)
completeArg (Just NameTArg) = noCompletion (prev, next) -- this is for binding new names!
completeArg (Just ExprTArg) = completeName Full as (prev, next)
completeArg (Just StringLitTArg) = noCompletion (prev, next)
completeArg (Just AltsTArg) = noCompletion (prev, next) -- TODO
-- | Complete tactics and their arguments
proverCompletion :: [String] -- ^ The names of current local assumptions
-> CompletionFunc Idris
proverCompletion assumptions (prev, next) = completeTactic assumptions firstWord (prev, next)
where firstWord = fst $ break isWhitespace $ dropWhile isWhitespace $ reverse prev
|
markuspf/Idris-dev
|
src/Idris/Completion.hs
|
Haskell
|
bsd-3-clause
| 9,713
|
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleInstances #-}
module TcCustomSolverSuper where
import GHC.TypeLits
import Data.Typeable
{-
When solving super-class instances, GHC solves the evidence without
using the solver (see `tcSuperClasses` in `TcInstDecls`).
However, some classes need to be excepted from this behavior,
as they have custom solving rules, and this test checks that
we got this right.
PS: this test used to have Typeable in the context too, but
that's a redundant constraint, so I removed it
PPS: the whole structure of tcSuperClasses has changed,
so I'm no longer sure what is being tested here
-}
class (KnownNat x) => C x
class (KnownSymbol x) => D x
instance C 2
instance D "2"
|
sdiehl/ghc
|
testsuite/tests/typecheck/should_compile/TcCustomSolverSuper.hs
|
Haskell
|
bsd-3-clause
| 726
|
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE helpset PUBLIC "-//Sun Microsystems Inc.//DTD JavaHelp HelpSet Version 2.0//EN" "http://java.sun.com/products/javahelp/helpset_2_0.dtd">
<helpset version="2.0" xml:lang="sr-SP">
<title>AJAX Spider | ZAP Extensions</title>
<maps>
<homeID>top</homeID>
<mapref location="map.jhm"/>
</maps>
<view>
<name>TOC</name>
<label>Contents</label>
<type>org.zaproxy.zap.extension.help.ZapTocView</type>
<data>toc.xml</data>
</view>
<view>
<name>Index</name>
<label>Index</label>
<type>javax.help.IndexView</type>
<data>index.xml</data>
</view>
<view>
<name>Search</name>
<label>Search</label>
<type>javax.help.SearchView</type>
<data engine="com.sun.java.help.search.DefaultSearchEngine">
JavaHelpSearch
</data>
</view>
<view>
<name>Favorites</name>
<label>Favorites</label>
<type>javax.help.FavoritesView</type>
</view>
</helpset>
|
kingthorin/zap-extensions
|
addOns/spiderAjax/src/main/javahelp/org/zaproxy/zap/extension/spiderAjax/resources/help_sr_SP/helpset_sr_SP.hs
|
Haskell
|
apache-2.0
| 973
|
{-# LANGUAGE CPP #-}
module Distribution.Simple.GHCJS (
configure, getInstalledPackages, getPackageDBContents,
buildLib, buildExe,
replLib, replExe,
startInterpreter,
installLib, installExe,
libAbiHash,
hcPkgInfo,
registerPackage,
componentGhcOptions,
getLibDir,
isDynamic,
getGlobalPackageDB,
runCmd
) where
import Distribution.Simple.GHC.ImplInfo ( getImplInfo, ghcjsVersionImplInfo )
import qualified Distribution.Simple.GHC.Internal as Internal
import Distribution.PackageDescription as PD
( PackageDescription(..), BuildInfo(..), Executable(..)
, Library(..), libModules, exeModules
, hcOptions, hcProfOptions, hcSharedOptions
, allExtensions )
import Distribution.InstalledPackageInfo
( InstalledPackageInfo )
import qualified Distribution.InstalledPackageInfo as InstalledPackageInfo
( InstalledPackageInfo_(..) )
import Distribution.Simple.PackageIndex ( InstalledPackageIndex )
import qualified Distribution.Simple.PackageIndex as PackageIndex
import Distribution.Simple.LocalBuildInfo
( LocalBuildInfo(..), ComponentLocalBuildInfo(..)
, LibraryName(..) )
import qualified Distribution.Simple.Hpc as Hpc
import Distribution.Simple.InstallDirs hiding ( absoluteInstallDirs )
import Distribution.Simple.BuildPaths
import Distribution.Simple.Utils
import Distribution.Simple.Program
( Program(..), ConfiguredProgram(..), ProgramConfiguration
, ProgramSearchPath
, rawSystemProgramConf
, rawSystemProgramStdout, rawSystemProgramStdoutConf
, getProgramInvocationOutput
, requireProgramVersion, requireProgram
, userMaybeSpecifyPath, programPath
, lookupProgram, addKnownPrograms
, ghcjsProgram, ghcjsPkgProgram, c2hsProgram, hsc2hsProgram
, ldProgram, haddockProgram, stripProgram )
import qualified Distribution.Simple.Program.HcPkg as HcPkg
import qualified Distribution.Simple.Program.Ar as Ar
import qualified Distribution.Simple.Program.Ld as Ld
import qualified Distribution.Simple.Program.Strip as Strip
import Distribution.Simple.Program.GHC
import Distribution.Simple.Setup
( toFlag, fromFlag, configCoverage, configDistPref )
import qualified Distribution.Simple.Setup as Cabal
( Flag(..) )
import Distribution.Simple.Compiler
( CompilerFlavor(..), CompilerId(..), Compiler(..)
, PackageDB(..), PackageDBStack, AbiTag(..) )
import Distribution.Version
( Version(..), anyVersion, orLaterVersion )
import Distribution.System
( Platform(..) )
import Distribution.Verbosity
import Distribution.Utils.NubList
( overNubListR, toNubListR )
import Distribution.Text ( display )
import Language.Haskell.Extension ( Extension(..)
, KnownExtension(..))
import Control.Monad ( unless, when )
import Data.Char ( isSpace )
import qualified Data.Map as M ( fromList )
#if __GLASGOW_HASKELL__ < 710
import Data.Monoid ( Monoid(..) )
#endif
import System.Directory ( doesFileExist )
import System.FilePath ( (</>), (<.>), takeExtension,
takeDirectory, replaceExtension,
splitExtension )
configure :: Verbosity -> Maybe FilePath -> Maybe FilePath
-> ProgramConfiguration
-> IO (Compiler, Maybe Platform, ProgramConfiguration)
configure verbosity hcPath hcPkgPath conf0 = do
(ghcjsProg, ghcjsVersion, conf1) <-
requireProgramVersion verbosity ghcjsProgram
(orLaterVersion (Version [0,1] []))
(userMaybeSpecifyPath "ghcjs" hcPath conf0)
Just ghcjsGhcVersion <- findGhcjsGhcVersion verbosity (programPath ghcjsProg)
let implInfo = ghcjsVersionImplInfo ghcjsVersion ghcjsGhcVersion
-- This is slightly tricky, we have to configure ghcjs first, then we use the
-- location of ghcjs to help find ghcjs-pkg in the case that the user did not
-- specify the location of ghc-pkg directly:
(ghcjsPkgProg, ghcjsPkgVersion, conf2) <-
requireProgramVersion verbosity ghcjsPkgProgram {
programFindLocation = guessGhcjsPkgFromGhcjsPath ghcjsProg
}
anyVersion (userMaybeSpecifyPath "ghcjs-pkg" hcPkgPath conf1)
Just ghcjsPkgGhcjsVersion <- findGhcjsPkgGhcjsVersion
verbosity (programPath ghcjsPkgProg)
when (ghcjsVersion /= ghcjsPkgGhcjsVersion) $ die $
"Version mismatch between ghcjs and ghcjs-pkg: "
++ programPath ghcjsProg ++ " is version " ++ display ghcjsVersion ++ " "
++ programPath ghcjsPkgProg ++ " is version " ++ display ghcjsPkgGhcjsVersion
when (ghcjsGhcVersion /= ghcjsPkgVersion) $ die $
"Version mismatch between ghcjs and ghcjs-pkg: "
++ programPath ghcjsProg
++ " was built with GHC version " ++ display ghcjsGhcVersion ++ " "
++ programPath ghcjsPkgProg
++ " was built with GHC version " ++ display ghcjsPkgVersion
-- be sure to use our versions of hsc2hs, c2hs, haddock and ghc
let hsc2hsProgram' =
hsc2hsProgram { programFindLocation =
guessHsc2hsFromGhcjsPath ghcjsProg }
c2hsProgram' =
c2hsProgram { programFindLocation =
guessC2hsFromGhcjsPath ghcjsProg }
haddockProgram' =
haddockProgram { programFindLocation =
guessHaddockFromGhcjsPath ghcjsProg }
conf3 = addKnownPrograms [ hsc2hsProgram', c2hsProgram', haddockProgram' ] conf2
languages <- Internal.getLanguages verbosity implInfo ghcjsProg
extensions <- Internal.getExtensions verbosity implInfo ghcjsProg
ghcInfo <- Internal.getGhcInfo verbosity implInfo ghcjsProg
let ghcInfoMap = M.fromList ghcInfo
let comp = Compiler {
compilerId = CompilerId GHCJS ghcjsVersion,
compilerAbiTag = AbiTag $
"ghc" ++ intercalate "_" (map show . versionBranch $ ghcjsGhcVersion),
compilerCompat = [CompilerId GHC ghcjsGhcVersion],
compilerLanguages = languages,
compilerExtensions = extensions,
compilerProperties = ghcInfoMap
}
compPlatform = Internal.targetPlatform ghcInfo
-- configure gcc and ld
let conf4 = if ghcjsNativeToo comp
then Internal.configureToolchain implInfo
ghcjsProg ghcInfoMap conf3
else conf3
return (comp, compPlatform, conf4)
ghcjsNativeToo :: Compiler -> Bool
ghcjsNativeToo = Internal.ghcLookupProperty "Native Too"
guessGhcjsPkgFromGhcjsPath :: ConfiguredProgram -> Verbosity
-> ProgramSearchPath -> IO (Maybe FilePath)
guessGhcjsPkgFromGhcjsPath = guessToolFromGhcjsPath ghcjsPkgProgram
guessHsc2hsFromGhcjsPath :: ConfiguredProgram -> Verbosity
-> ProgramSearchPath -> IO (Maybe FilePath)
guessHsc2hsFromGhcjsPath = guessToolFromGhcjsPath hsc2hsProgram
guessC2hsFromGhcjsPath :: ConfiguredProgram -> Verbosity
-> ProgramSearchPath -> IO (Maybe FilePath)
guessC2hsFromGhcjsPath = guessToolFromGhcjsPath c2hsProgram
guessHaddockFromGhcjsPath :: ConfiguredProgram -> Verbosity
-> ProgramSearchPath -> IO (Maybe FilePath)
guessHaddockFromGhcjsPath = guessToolFromGhcjsPath haddockProgram
guessToolFromGhcjsPath :: Program -> ConfiguredProgram
-> Verbosity -> ProgramSearchPath
-> IO (Maybe FilePath)
guessToolFromGhcjsPath tool ghcjsProg verbosity searchpath
= do let toolname = programName tool
path = programPath ghcjsProg
dir = takeDirectory path
versionSuffix = takeVersionSuffix (dropExeExtension path)
guessNormal = dir </> toolname <.> exeExtension
guessGhcjsVersioned = dir </> (toolname ++ "-ghcjs" ++ versionSuffix)
<.> exeExtension
guessGhcjs = dir </> (toolname ++ "-ghcjs")
<.> exeExtension
guessVersioned = dir </> (toolname ++ versionSuffix) <.> exeExtension
guesses | null versionSuffix = [guessGhcjs, guessNormal]
| otherwise = [guessGhcjsVersioned,
guessGhcjs,
guessVersioned,
guessNormal]
info verbosity $ "looking for tool " ++ toolname
++ " near compiler in " ++ dir
exists <- mapM doesFileExist guesses
case [ file | (file, True) <- zip guesses exists ] of
-- If we can't find it near ghc, fall back to the usual
-- method.
[] -> programFindLocation tool verbosity searchpath
(fp:_) -> do info verbosity $ "found " ++ toolname ++ " in " ++ fp
return (Just fp)
where takeVersionSuffix :: FilePath -> String
takeVersionSuffix = reverse . takeWhile (`elem ` "0123456789.-") .
reverse
dropExeExtension :: FilePath -> FilePath
dropExeExtension filepath =
case splitExtension filepath of
(filepath', extension) | extension == exeExtension -> filepath'
| otherwise -> filepath
-- | Given a single package DB, return all installed packages.
getPackageDBContents :: Verbosity -> PackageDB -> ProgramConfiguration
-> IO InstalledPackageIndex
getPackageDBContents verbosity packagedb conf = do
pkgss <- getInstalledPackages' verbosity [packagedb] conf
toPackageIndex verbosity pkgss conf
-- | Given a package DB stack, return all installed packages.
getInstalledPackages :: Verbosity -> PackageDBStack -> ProgramConfiguration
-> IO InstalledPackageIndex
getInstalledPackages verbosity packagedbs conf = do
checkPackageDbEnvVar
checkPackageDbStack packagedbs
pkgss <- getInstalledPackages' verbosity packagedbs conf
index <- toPackageIndex verbosity pkgss conf
return $! index
toPackageIndex :: Verbosity
-> [(PackageDB, [InstalledPackageInfo])]
-> ProgramConfiguration
-> IO InstalledPackageIndex
toPackageIndex verbosity pkgss conf = do
-- On Windows, various fields have $topdir/foo rather than full
-- paths. We need to substitute the right value in so that when
-- we, for example, call gcc, we have proper paths to give it.
topDir <- getLibDir' verbosity ghcjsProg
let indices = [ PackageIndex.fromList (map (Internal.substTopDir topDir) pkgs)
| (_, pkgs) <- pkgss ]
return $! (mconcat indices)
where
Just ghcjsProg = lookupProgram ghcjsProgram conf
checkPackageDbEnvVar :: IO ()
checkPackageDbEnvVar =
Internal.checkPackageDbEnvVar "GHCJS" "GHCJS_PACKAGE_PATH"
checkPackageDbStack :: PackageDBStack -> IO ()
checkPackageDbStack (GlobalPackageDB:rest)
| GlobalPackageDB `notElem` rest = return ()
checkPackageDbStack rest
| GlobalPackageDB `notElem` rest =
die $ "With current ghc versions the global package db is always used "
++ "and must be listed first. This ghc limitation may be lifted in "
++ "future, see http://hackage.haskell.org/trac/ghc/ticket/5977"
checkPackageDbStack _ =
die $ "If the global package db is specified, it must be "
++ "specified first and cannot be specified multiple times"
getInstalledPackages' :: Verbosity -> [PackageDB] -> ProgramConfiguration
-> IO [(PackageDB, [InstalledPackageInfo])]
getInstalledPackages' verbosity packagedbs conf =
sequence
[ do pkgs <- HcPkg.dump (hcPkgInfo conf) verbosity packagedb
return (packagedb, pkgs)
| packagedb <- packagedbs ]
getLibDir :: Verbosity -> LocalBuildInfo -> IO FilePath
getLibDir verbosity lbi =
(reverse . dropWhile isSpace . reverse) `fmap`
rawSystemProgramStdoutConf verbosity ghcjsProgram
(withPrograms lbi) ["--print-libdir"]
getLibDir' :: Verbosity -> ConfiguredProgram -> IO FilePath
getLibDir' verbosity ghcjsProg =
(reverse . dropWhile isSpace . reverse) `fmap`
rawSystemProgramStdout verbosity ghcjsProg ["--print-libdir"]
-- | Return the 'FilePath' to the global GHC package database.
getGlobalPackageDB :: Verbosity -> ConfiguredProgram -> IO FilePath
getGlobalPackageDB verbosity ghcjsProg =
(reverse . dropWhile isSpace . reverse) `fmap`
rawSystemProgramStdout verbosity ghcjsProg ["--print-global-package-db"]
toJSLibName :: String -> String
toJSLibName lib
| takeExtension lib `elem` [".dll",".dylib",".so"]
= replaceExtension lib "js_so"
| takeExtension lib == ".a" = replaceExtension lib "js_a"
| otherwise = lib <.> "js_a"
buildLib, replLib :: Verbosity -> Cabal.Flag (Maybe Int) -> PackageDescription
-> LocalBuildInfo -> Library -> ComponentLocalBuildInfo
-> IO ()
buildLib = buildOrReplLib False
replLib = buildOrReplLib True
buildOrReplLib :: Bool -> Verbosity -> Cabal.Flag (Maybe Int)
-> PackageDescription -> LocalBuildInfo
-> Library -> ComponentLocalBuildInfo -> IO ()
buildOrReplLib forRepl verbosity numJobs _pkg_descr lbi lib clbi = do
libName <- case componentLibraries clbi of
[libName] -> return libName
[] -> die "No library name found when building library"
_ -> die "Multiple library names found when building library"
let libTargetDir = buildDir lbi
whenVanillaLib forceVanilla =
when (not forRepl && (forceVanilla || withVanillaLib lbi))
whenProfLib = when (not forRepl && withProfLib lbi)
whenSharedLib forceShared =
when (not forRepl && (forceShared || withSharedLib lbi))
whenGHCiLib = when (not forRepl && withGHCiLib lbi && withVanillaLib lbi)
ifReplLib = when forRepl
comp = compiler lbi
implInfo = getImplInfo comp
hole_insts = map (\(k,(p,n)) -> (k,(InstalledPackageInfo.packageKey p,n)))
(instantiatedWith lbi)
nativeToo = ghcjsNativeToo comp
(ghcjsProg, _) <- requireProgram verbosity ghcjsProgram (withPrograms lbi)
let runGhcjsProg = runGHC verbosity ghcjsProg comp
libBi = libBuildInfo lib
isGhcjsDynamic = isDynamic comp
dynamicTooSupported = supportsDynamicToo comp
doingTH = EnableExtension TemplateHaskell `elem` allExtensions libBi
forceVanillaLib = doingTH && not isGhcjsDynamic
forceSharedLib = doingTH && isGhcjsDynamic
-- TH always needs default libs, even when building for profiling
-- Determine if program coverage should be enabled and if so, what
-- '-hpcdir' should be.
let isCoverageEnabled = fromFlag $ configCoverage $ configFlags lbi
-- Component name. Not 'libName' because that has the "HS" prefix
-- that GHC gives Haskell libraries.
cname = display $ PD.package $ localPkgDescr lbi
distPref = fromFlag $ configDistPref $ configFlags lbi
hpcdir way
| isCoverageEnabled = toFlag $ Hpc.mixDir distPref way cname
| otherwise = mempty
createDirectoryIfMissingVerbose verbosity True libTargetDir
-- TODO: do we need to put hs-boot files into place for mutually recursive
-- modules?
let cObjs = map (`replaceExtension` objExtension) (cSources libBi)
jsSrcs = jsSources libBi
baseOpts = componentGhcOptions verbosity lbi libBi clbi libTargetDir
linkJsLibOpts = mempty {
ghcOptExtra = toNubListR $
[ "-link-js-lib" , (\(LibraryName l) -> l) libName
, "-js-lib-outputdir", libTargetDir ] ++
concatMap (\x -> ["-js-lib-src",x]) jsSrcs
}
vanillaOptsNoJsLib = baseOpts `mappend` mempty {
ghcOptMode = toFlag GhcModeMake,
ghcOptNumJobs = numJobs,
ghcOptPackageKey = toFlag (pkgKey lbi),
ghcOptSigOf = hole_insts,
ghcOptInputModules = toNubListR $ libModules lib,
ghcOptHPCDir = hpcdir Hpc.Vanilla
}
vanillaOpts = vanillaOptsNoJsLib `mappend` linkJsLibOpts
profOpts = adjustExts "p_hi" "p_o" vanillaOpts `mappend` mempty {
ghcOptProfilingMode = toFlag True,
ghcOptExtra = toNubListR $
ghcjsProfOptions libBi,
ghcOptHPCDir = hpcdir Hpc.Prof
}
sharedOpts = adjustExts "dyn_hi" "dyn_o" vanillaOpts `mappend` mempty {
ghcOptDynLinkMode = toFlag GhcDynamicOnly,
ghcOptFPic = toFlag True,
ghcOptExtra = toNubListR $
ghcjsSharedOptions libBi,
ghcOptHPCDir = hpcdir Hpc.Dyn
}
linkerOpts = mempty {
ghcOptLinkOptions = toNubListR $ PD.ldOptions libBi,
ghcOptLinkLibs = toNubListR $ extraLibs libBi,
ghcOptLinkLibPath = toNubListR $ extraLibDirs libBi,
ghcOptLinkFrameworks = toNubListR $ PD.frameworks libBi,
ghcOptInputFiles =
toNubListR $ [libTargetDir </> x | x <- cObjs] ++ jsSrcs
}
replOpts = vanillaOptsNoJsLib {
ghcOptExtra = overNubListR
Internal.filterGhciFlags
(ghcOptExtra vanillaOpts),
ghcOptNumJobs = mempty
}
`mappend` linkerOpts
`mappend` mempty {
ghcOptMode = toFlag GhcModeInteractive,
ghcOptOptimisation = toFlag GhcNoOptimisation
}
vanillaSharedOpts = vanillaOpts `mappend`
mempty {
ghcOptDynLinkMode = toFlag GhcStaticAndDynamic,
ghcOptDynHiSuffix = toFlag "dyn_hi",
ghcOptDynObjSuffix = toFlag "dyn_o",
ghcOptHPCDir = hpcdir Hpc.Dyn
}
unless (forRepl || (null (libModules lib) && null jsSrcs && null cObjs)) $
do let vanilla = whenVanillaLib forceVanillaLib (runGhcjsProg vanillaOpts)
shared = whenSharedLib forceSharedLib (runGhcjsProg sharedOpts)
useDynToo = dynamicTooSupported &&
(forceVanillaLib || withVanillaLib lbi) &&
(forceSharedLib || withSharedLib lbi) &&
null (ghcjsSharedOptions libBi)
if useDynToo
then do
runGhcjsProg vanillaSharedOpts
case (hpcdir Hpc.Dyn, hpcdir Hpc.Vanilla) of
(Cabal.Flag dynDir, Cabal.Flag vanillaDir) -> do
-- When the vanilla and shared library builds are done
-- in one pass, only one set of HPC module interfaces
-- are generated. This set should suffice for both
-- static and dynamically linked executables. We copy
-- the modules interfaces so they are available under
-- both ways.
copyDirectoryRecursive verbosity dynDir vanillaDir
_ -> return ()
else if isGhcjsDynamic
then do shared; vanilla
else do vanilla; shared
whenProfLib (runGhcjsProg profOpts)
-- build any C sources
unless (null (cSources libBi) || not nativeToo) $ do
info verbosity "Building C Sources..."
sequence_
[ do let vanillaCcOpts =
(Internal.componentCcGhcOptions verbosity implInfo
lbi libBi clbi libTargetDir filename)
profCcOpts = vanillaCcOpts `mappend` mempty {
ghcOptProfilingMode = toFlag True,
ghcOptObjSuffix = toFlag "p_o"
}
sharedCcOpts = vanillaCcOpts `mappend` mempty {
ghcOptFPic = toFlag True,
ghcOptDynLinkMode = toFlag GhcDynamicOnly,
ghcOptObjSuffix = toFlag "dyn_o"
}
odir = fromFlag (ghcOptObjDir vanillaCcOpts)
createDirectoryIfMissingVerbose verbosity True odir
runGhcjsProg vanillaCcOpts
whenSharedLib forceSharedLib (runGhcjsProg sharedCcOpts)
whenProfLib (runGhcjsProg profCcOpts)
| filename <- cSources libBi]
-- TODO: problem here is we need the .c files built first, so we can load them
-- with ghci, but .c files can depend on .h files generated by ghc by ffi
-- exports.
unless (null (libModules lib)) $
ifReplLib (runGhcjsProg replOpts)
-- link:
when (nativeToo && not forRepl) $ do
info verbosity "Linking..."
let cProfObjs = map (`replaceExtension` ("p_" ++ objExtension))
(cSources libBi)
cSharedObjs = map (`replaceExtension` ("dyn_" ++ objExtension))
(cSources libBi)
cid = compilerId (compiler lbi)
vanillaLibFilePath = libTargetDir </> mkLibName libName
profileLibFilePath = libTargetDir </> mkProfLibName libName
sharedLibFilePath = libTargetDir </> mkSharedLibName cid libName
ghciLibFilePath = libTargetDir </> Internal.mkGHCiLibName libName
hObjs <- Internal.getHaskellObjects implInfo lib lbi
libTargetDir objExtension True
hProfObjs <-
if (withProfLib lbi)
then Internal.getHaskellObjects implInfo lib lbi
libTargetDir ("p_" ++ objExtension) True
else return []
hSharedObjs <-
if (withSharedLib lbi)
then Internal.getHaskellObjects implInfo lib lbi
libTargetDir ("dyn_" ++ objExtension) False
else return []
unless (null hObjs && null cObjs) $ do
let staticObjectFiles =
hObjs
++ map (libTargetDir </>) cObjs
profObjectFiles =
hProfObjs
++ map (libTargetDir </>) cProfObjs
ghciObjFiles =
hObjs
++ map (libTargetDir </>) cObjs
dynamicObjectFiles =
hSharedObjs
++ map (libTargetDir </>) cSharedObjs
-- After the relocation lib is created we invoke ghc -shared
-- with the dependencies spelled out as -package arguments
-- and ghc invokes the linker with the proper library paths
ghcSharedLinkArgs =
mempty {
ghcOptShared = toFlag True,
ghcOptDynLinkMode = toFlag GhcDynamicOnly,
ghcOptInputFiles = toNubListR dynamicObjectFiles,
ghcOptOutputFile = toFlag sharedLibFilePath,
ghcOptPackageKey = toFlag (pkgKey lbi),
ghcOptNoAutoLinkPackages = toFlag True,
ghcOptPackageDBs = withPackageDB lbi,
ghcOptPackages = toNubListR $
Internal.mkGhcOptPackages clbi,
ghcOptLinkLibs = toNubListR $ extraLibs libBi,
ghcOptLinkLibPath = toNubListR $ extraLibDirs libBi
}
whenVanillaLib False $ do
Ar.createArLibArchive verbosity lbi vanillaLibFilePath staticObjectFiles
whenProfLib $ do
Ar.createArLibArchive verbosity lbi profileLibFilePath profObjectFiles
whenGHCiLib $ do
(ldProg, _) <- requireProgram verbosity ldProgram (withPrograms lbi)
Ld.combineObjectFiles verbosity ldProg
ghciLibFilePath ghciObjFiles
whenSharedLib False $
runGhcjsProg ghcSharedLinkArgs
-- | Start a REPL without loading any source files.
startInterpreter :: Verbosity -> ProgramConfiguration -> Compiler
-> PackageDBStack -> IO ()
startInterpreter verbosity conf comp packageDBs = do
let replOpts = mempty {
ghcOptMode = toFlag GhcModeInteractive,
ghcOptPackageDBs = packageDBs
}
checkPackageDbStack packageDBs
(ghcjsProg, _) <- requireProgram verbosity ghcjsProgram conf
runGHC verbosity ghcjsProg comp replOpts
buildExe, replExe :: Verbosity -> Cabal.Flag (Maybe Int)
-> PackageDescription -> LocalBuildInfo
-> Executable -> ComponentLocalBuildInfo -> IO ()
buildExe = buildOrReplExe False
replExe = buildOrReplExe True
buildOrReplExe :: Bool -> Verbosity -> Cabal.Flag (Maybe Int)
-> PackageDescription -> LocalBuildInfo
-> Executable -> ComponentLocalBuildInfo -> IO ()
buildOrReplExe forRepl verbosity numJobs _pkg_descr lbi
exe@Executable { exeName = exeName', modulePath = modPath } clbi = do
(ghcjsProg, _) <- requireProgram verbosity ghcjsProgram (withPrograms lbi)
let comp = compiler lbi
implInfo = getImplInfo comp
runGhcjsProg = runGHC verbosity ghcjsProg comp
exeBi = buildInfo exe
-- exeNameReal, the name that GHC really uses (with .exe on Windows)
let exeNameReal = exeName' <.>
(if takeExtension exeName' /= ('.':exeExtension)
then exeExtension
else "")
let targetDir = (buildDir lbi) </> exeName'
let exeDir = targetDir </> (exeName' ++ "-tmp")
createDirectoryIfMissingVerbose verbosity True targetDir
createDirectoryIfMissingVerbose verbosity True exeDir
-- TODO: do we need to put hs-boot files into place for mutually recursive
-- modules? FIX: what about exeName.hi-boot?
-- Determine if program coverage should be enabled and if so, what
-- '-hpcdir' should be.
let isCoverageEnabled = fromFlag $ configCoverage $ configFlags lbi
distPref = fromFlag $ configDistPref $ configFlags lbi
hpcdir way
| isCoverageEnabled = toFlag $ Hpc.mixDir distPref way exeName'
| otherwise = mempty
-- build executables
srcMainFile <- findFile (exeDir : hsSourceDirs exeBi) modPath
let isGhcjsDynamic = isDynamic comp
dynamicTooSupported = supportsDynamicToo comp
buildRunner = case clbi of
ExeComponentLocalBuildInfo {} -> False
_ -> True
isHaskellMain = elem (takeExtension srcMainFile) [".hs", ".lhs"]
jsSrcs = jsSources exeBi
cSrcs = cSources exeBi ++ [srcMainFile | not isHaskellMain]
cObjs = map (`replaceExtension` objExtension) cSrcs
nativeToo = ghcjsNativeToo comp
baseOpts = (componentGhcOptions verbosity lbi exeBi clbi exeDir)
`mappend` mempty {
ghcOptMode = toFlag GhcModeMake,
ghcOptInputFiles = toNubListR $
[ srcMainFile | isHaskellMain],
ghcOptInputModules = toNubListR $
[ m | not isHaskellMain, m <- exeModules exe],
ghcOptExtra =
if buildRunner then toNubListR ["-build-runner"]
else mempty
}
staticOpts = baseOpts `mappend` mempty {
ghcOptDynLinkMode = toFlag GhcStaticOnly,
ghcOptHPCDir = hpcdir Hpc.Vanilla
}
profOpts = adjustExts "p_hi" "p_o" baseOpts `mappend` mempty {
ghcOptProfilingMode = toFlag True,
ghcOptExtra = toNubListR $ ghcjsProfOptions exeBi,
ghcOptHPCDir = hpcdir Hpc.Prof
}
dynOpts = adjustExts "dyn_hi" "dyn_o" baseOpts `mappend` mempty {
ghcOptDynLinkMode = toFlag GhcDynamicOnly,
ghcOptExtra = toNubListR $
ghcjsSharedOptions exeBi,
ghcOptHPCDir = hpcdir Hpc.Dyn
}
dynTooOpts = adjustExts "dyn_hi" "dyn_o" staticOpts `mappend` mempty {
ghcOptDynLinkMode = toFlag GhcStaticAndDynamic,
ghcOptHPCDir = hpcdir Hpc.Dyn
}
linkerOpts = mempty {
ghcOptLinkOptions = toNubListR $ PD.ldOptions exeBi,
ghcOptLinkLibs = toNubListR $ extraLibs exeBi,
ghcOptLinkLibPath = toNubListR $ extraLibDirs exeBi,
ghcOptLinkFrameworks = toNubListR $ PD.frameworks exeBi,
ghcOptInputFiles = toNubListR $
[exeDir </> x | x <- cObjs] ++ jsSrcs
}
replOpts = baseOpts {
ghcOptExtra = overNubListR
Internal.filterGhciFlags
(ghcOptExtra baseOpts)
}
-- For a normal compile we do separate invocations of ghc for
-- compiling as for linking. But for repl we have to do just
-- the one invocation, so that one has to include all the
-- linker stuff too, like -l flags and any .o files from C
-- files etc.
`mappend` linkerOpts
`mappend` mempty {
ghcOptMode = toFlag GhcModeInteractive,
ghcOptOptimisation = toFlag GhcNoOptimisation
}
commonOpts | withProfExe lbi = profOpts
| withDynExe lbi = dynOpts
| otherwise = staticOpts
compileOpts | useDynToo = dynTooOpts
| otherwise = commonOpts
withStaticExe = (not $ withProfExe lbi) && (not $ withDynExe lbi)
-- For building exe's that use TH with -prof or -dynamic we actually have
-- to build twice, once without -prof/-dynamic and then again with
-- -prof/-dynamic. This is because the code that TH needs to run at
-- compile time needs to be the vanilla ABI so it can be loaded up and run
-- by the compiler.
-- With dynamic-by-default GHC the TH object files loaded at compile-time
-- need to be .dyn_o instead of .o.
doingTH = EnableExtension TemplateHaskell `elem` allExtensions exeBi
-- Should we use -dynamic-too instead of compiling twice?
useDynToo = dynamicTooSupported && isGhcjsDynamic
&& doingTH && withStaticExe && null (ghcjsSharedOptions exeBi)
compileTHOpts | isGhcjsDynamic = dynOpts
| otherwise = staticOpts
compileForTH
| forRepl = False
| useDynToo = False
| isGhcjsDynamic = doingTH && (withProfExe lbi || withStaticExe)
| otherwise = doingTH && (withProfExe lbi || withDynExe lbi)
linkOpts = commonOpts `mappend`
linkerOpts `mappend` mempty {
ghcOptLinkNoHsMain = toFlag (not isHaskellMain)
}
-- Build static/dynamic object files for TH, if needed.
when compileForTH $
runGhcjsProg compileTHOpts { ghcOptNoLink = toFlag True
, ghcOptNumJobs = numJobs }
unless forRepl $
runGhcjsProg compileOpts { ghcOptNoLink = toFlag True
, ghcOptNumJobs = numJobs }
-- build any C sources
unless (null cSrcs || not nativeToo) $ do
info verbosity "Building C Sources..."
sequence_
[ do let opts = (Internal.componentCcGhcOptions verbosity implInfo lbi exeBi
clbi exeDir filename) `mappend` mempty {
ghcOptDynLinkMode = toFlag (if withDynExe lbi
then GhcDynamicOnly
else GhcStaticOnly),
ghcOptProfilingMode = toFlag (withProfExe lbi)
}
odir = fromFlag (ghcOptObjDir opts)
createDirectoryIfMissingVerbose verbosity True odir
runGhcjsProg opts
| filename <- cSrcs ]
-- TODO: problem here is we need the .c files built first, so we can load them
-- with ghci, but .c files can depend on .h files generated by ghc by ffi
-- exports.
when forRepl $ runGhcjsProg replOpts
-- link:
unless forRepl $ do
info verbosity "Linking..."
runGhcjsProg linkOpts { ghcOptOutputFile = toFlag (targetDir </> exeNameReal) }
-- |Install for ghc, .hi, .a and, if --with-ghci given, .o
installLib :: Verbosity
-> LocalBuildInfo
-> FilePath -- ^install location
-> FilePath -- ^install location for dynamic libraries
-> FilePath -- ^Build location
-> PackageDescription
-> Library
-> ComponentLocalBuildInfo
-> IO ()
installLib verbosity lbi targetDir dynlibTargetDir builtDir _pkg lib clbi = do
whenVanilla $ copyModuleFiles "js_hi"
whenProf $ copyModuleFiles "js_p_hi"
whenShared $ copyModuleFiles "js_dyn_hi"
whenVanilla $ mapM_ (installOrdinary builtDir targetDir . toJSLibName) vanillaLibNames
whenProf $ mapM_ (installOrdinary builtDir targetDir . toJSLibName) profileLibNames
whenShared $ mapM_ (installShared builtDir dynlibTargetDir . toJSLibName) sharedLibNames
when (ghcjsNativeToo $ compiler lbi) $ do
-- copy .hi files over:
whenVanilla $ copyModuleFiles "hi"
whenProf $ copyModuleFiles "p_hi"
whenShared $ copyModuleFiles "dyn_hi"
-- copy the built library files over:
whenVanilla $ mapM_ (installOrdinary builtDir targetDir) vanillaLibNames
whenProf $ mapM_ (installOrdinary builtDir targetDir) profileLibNames
whenGHCi $ mapM_ (installOrdinary builtDir targetDir) ghciLibNames
whenShared $ mapM_ (installShared builtDir dynlibTargetDir) sharedLibNames
where
install isShared srcDir dstDir name = do
let src = srcDir </> name
dst = dstDir </> name
createDirectoryIfMissingVerbose verbosity True dstDir
if isShared
then do when (stripLibs lbi) $ Strip.stripLib verbosity
(hostPlatform lbi) (withPrograms lbi) src
installExecutableFile verbosity src dst
else installOrdinaryFile verbosity src dst
installOrdinary = install False
installShared = install True
copyModuleFiles ext =
findModuleFiles [builtDir] [ext] (libModules lib)
>>= installOrdinaryFiles verbosity targetDir
cid = compilerId (compiler lbi)
libNames = componentLibraries clbi
vanillaLibNames = map mkLibName libNames
profileLibNames = map mkProfLibName libNames
ghciLibNames = map Internal.mkGHCiLibName libNames
sharedLibNames = map (mkSharedLibName cid) libNames
hasLib = not $ null (libModules lib)
&& null (cSources (libBuildInfo lib))
whenVanilla = when (hasLib && withVanillaLib lbi)
whenProf = when (hasLib && withProfLib lbi)
whenGHCi = when (hasLib && withGHCiLib lbi)
whenShared = when (hasLib && withSharedLib lbi)
installExe :: Verbosity
-> LocalBuildInfo
-> InstallDirs FilePath -- ^Where to copy the files to
-> FilePath -- ^Build location
-> (FilePath, FilePath) -- ^Executable (prefix,suffix)
-> PackageDescription
-> Executable
-> IO ()
installExe verbosity lbi installDirs buildPref
(progprefix, progsuffix) _pkg exe = do
let binDir = bindir installDirs
createDirectoryIfMissingVerbose verbosity True binDir
let exeFileName = exeName exe
fixedExeBaseName = progprefix ++ exeName exe ++ progsuffix
installBinary dest = do
rawSystemProgramConf verbosity ghcjsProgram (withPrograms lbi) $
[ "--install-executable"
, buildPref </> exeName exe </> exeFileName
, "-o", dest
] ++
case (stripExes lbi, lookupProgram stripProgram $ withPrograms lbi) of
(True, Just strip) -> ["-strip-program", programPath strip]
_ -> []
installBinary (binDir </> fixedExeBaseName)
libAbiHash :: Verbosity -> PackageDescription -> LocalBuildInfo
-> Library -> ComponentLocalBuildInfo -> IO String
libAbiHash verbosity _pkg_descr lbi lib clbi = do
let
libBi = libBuildInfo lib
comp = compiler lbi
vanillaArgs =
(componentGhcOptions verbosity lbi libBi clbi (buildDir lbi))
`mappend` mempty {
ghcOptMode = toFlag GhcModeAbiHash,
ghcOptPackageKey = toFlag (pkgKey lbi),
ghcOptInputModules = toNubListR $ exposedModules lib
}
profArgs = adjustExts "js_p_hi" "js_p_o" vanillaArgs `mappend` mempty {
ghcOptProfilingMode = toFlag True,
ghcOptExtra = toNubListR (ghcjsProfOptions libBi)
}
ghcArgs = if withVanillaLib lbi then vanillaArgs
else if withProfLib lbi then profArgs
else error "libAbiHash: Can't find an enabled library way"
--
(ghcjsProg, _) <- requireProgram verbosity ghcjsProgram (withPrograms lbi)
getProgramInvocationOutput verbosity (ghcInvocation ghcjsProg comp ghcArgs)
adjustExts :: String -> String -> GhcOptions -> GhcOptions
adjustExts hiSuf objSuf opts =
opts `mappend` mempty {
ghcOptHiSuffix = toFlag hiSuf,
ghcOptObjSuffix = toFlag objSuf
}
registerPackage :: Verbosity
-> InstalledPackageInfo
-> PackageDescription
-> LocalBuildInfo
-> Bool
-> PackageDBStack
-> IO ()
registerPackage verbosity installedPkgInfo _pkg lbi _inplace packageDbs =
HcPkg.reregister (hcPkgInfo $ withPrograms lbi) verbosity packageDbs
(Right installedPkgInfo)
componentGhcOptions :: Verbosity -> LocalBuildInfo
-> BuildInfo -> ComponentLocalBuildInfo -> FilePath
-> GhcOptions
componentGhcOptions verbosity lbi bi clbi odir =
let opts = Internal.componentGhcOptions verbosity lbi bi clbi odir
in opts { ghcOptExtra = ghcOptExtra opts `mappend` toNubListR
(hcOptions GHCJS bi)
}
ghcjsProfOptions :: BuildInfo -> [String]
ghcjsProfOptions bi =
hcProfOptions GHC bi `mappend` hcProfOptions GHCJS bi
ghcjsSharedOptions :: BuildInfo -> [String]
ghcjsSharedOptions bi =
hcSharedOptions GHC bi `mappend` hcSharedOptions GHCJS bi
isDynamic :: Compiler -> Bool
isDynamic = Internal.ghcLookupProperty "GHC Dynamic"
supportsDynamicToo :: Compiler -> Bool
supportsDynamicToo = Internal.ghcLookupProperty "Support dynamic-too"
findGhcjsGhcVersion :: Verbosity -> FilePath -> IO (Maybe Version)
findGhcjsGhcVersion verbosity pgm =
findProgramVersion "--numeric-ghc-version" id verbosity pgm
findGhcjsPkgGhcjsVersion :: Verbosity -> FilePath -> IO (Maybe Version)
findGhcjsPkgGhcjsVersion verbosity pgm =
findProgramVersion "--numeric-ghcjs-version" id verbosity pgm
-- -----------------------------------------------------------------------------
-- Registering
hcPkgInfo :: ProgramConfiguration -> HcPkg.HcPkgInfo
hcPkgInfo conf = HcPkg.HcPkgInfo { HcPkg.hcPkgProgram = ghcjsPkgProg
, HcPkg.noPkgDbStack = False
, HcPkg.noVerboseFlag = False
, HcPkg.flagPackageConf = False
, HcPkg.useSingleFileDb = v < [7,9]
}
where
v = versionBranch ver
Just ghcjsPkgProg = lookupProgram ghcjsPkgProgram conf
Just ver = programVersion ghcjsPkgProg
-- | Get the JavaScript file name and command and arguments to run a
-- program compiled by GHCJS
-- the exe should be the base program name without exe extension
runCmd :: ProgramConfiguration -> FilePath
-> (FilePath, FilePath, [String])
runCmd conf exe =
( script
, programPath ghcjsProg
, programDefaultArgs ghcjsProg ++ programOverrideArgs ghcjsProg ++ ["--run"]
)
where
script = exe <.> "jsexe" </> "all" <.> "js"
Just ghcjsProg = lookupProgram ghcjsProgram conf
|
Helkafen/cabal
|
Cabal/Distribution/Simple/GHCJS.hs
|
Haskell
|
bsd-3-clause
| 41,352
|
{-# LANGUAGE OverloadedStrings #-}
module Clay.Attributes where
import Clay.Selector
-- From: http://www.whatwg.org/specs/web-apps/current-work/multipage/section-index.html#index
accept, acceptCharset, accesskey, action, alt, async, autocomplete, autofocus,
autoplay, challenge, charset, checked, class_, cols, colspan, content,
contenteditable, contextmenu, controls, coords, crossorigin, datetime,
default_, defer, dir, dirname, disabled, download, draggable, dropzone,
enctype, for, formaction, formenctype, formmethod, formnovalidate,
formtarget, headers, height, hidden, high, href, hreflang, httpEquiv, icon,
id, inert, inputmode, ismap, itemid, itemprop, itemref, itemscope, itemtype,
keytype, kind, lang, list, loop, low, manifest, max, maxlength, media,
mediagroup, method, min, multiple, muted, name, novalidate, open, optimum,
pattern, ping, placeholder, poster, preload, radiogroup, readonly, rel,
required, reversed, rows, rowspan, sandbox, scope, scoped, seamless,
selected, shape, size, sizes, spellcheck, src, srcdoc, srclang, srcset,
start, step, tabindex, target, translate, type_, typemustmatch, usemap,
value, width, wrap :: Refinement
accept = "accept"
acceptCharset = "accept-charset"
accesskey = "accesskey"
action = "action"
alt = "alt"
async = "async"
autocomplete = "autocomplete"
autofocus = "autofocus"
autoplay = "autoplay"
challenge = "challenge"
charset = "charset"
checked = "checked"
class_ = "class"
cols = "cols"
colspan = "colspan"
content = "content"
contenteditable = "contenteditable"
contextmenu = "contextmenu"
controls = "controls"
coords = "coords"
crossorigin = "crossorigin"
datetime = "datetime"
default_ = "default"
defer = "defer"
dir = "dir"
dirname = "dirname"
disabled = "disabled"
download = "download"
draggable = "draggable"
dropzone = "dropzone"
enctype = "enctype"
for = "for"
formaction = "formaction"
formenctype = "formenctype"
formmethod = "formmethod"
formnovalidate = "formnovalidate"
formtarget = "formtarget"
headers = "headers"
height = "height"
hidden = "hidden"
high = "high"
href = "href"
hreflang = "hreflang"
httpEquiv = "http-equiv"
icon = "icon"
id = "id"
inert = "inert"
inputmode = "inputmode"
ismap = "ismap"
itemid = "itemid"
itemprop = "itemprop"
itemref = "itemref"
itemscope = "itemscope"
itemtype = "itemtype"
keytype = "keytype"
kind = "kind"
lang = "lang"
list = "list"
loop = "loop"
low = "low"
manifest = "manifest"
max = "max"
maxlength = "maxlength"
media = "media"
mediagroup = "mediagroup"
method = "method"
min = "min"
multiple = "multiple"
muted = "muted"
name = "name"
novalidate = "novalidate"
open = "open"
optimum = "optimum"
pattern = "pattern"
ping = "ping"
placeholder = "placeholder"
poster = "poster"
preload = "preload"
radiogroup = "radiogroup"
readonly = "readonly"
rel = "rel"
required = "required"
reversed = "reversed"
rows = "rows"
rowspan = "rowspan"
sandbox = "sandbox"
scope = "scope"
scoped = "scoped"
seamless = "seamless"
selected = "selected"
shape = "shape"
size = "size"
sizes = "sizes"
spellcheck = "spellcheck"
src = "src"
srcdoc = "srcdoc"
srclang = "srclang"
srcset = "srcset"
start = "start"
step = "step"
tabindex = "tabindex"
target = "target"
translate = "translate"
type_ = "type"
typemustmatch = "typemustmatch"
usemap = "usemap"
value = "value"
width = "width"
wrap = "wrap"
|
Heather/clay
|
src/Clay/Attributes.hs
|
Haskell
|
bsd-3-clause
| 3,332
|
{-# LANGUAGE DataKinds, TypeOperators, TypeFamilies #-}
{-# LANGUAGE UndecidableInstances, ScopedTypeVariables, FlexibleContexts #-}
module T11990b where
import GHC.TypeLits
import Data.Proxy
type family PartialTF t :: Symbol where
PartialTF Int = "Int"
PartialTF Bool = "Bool"
PartialTF a = TypeError (Text "Unexpected type @ PartialTF: "
:<>: ShowType a)
type family NestedPartialTF (tsym :: Symbol) :: Symbol where
NestedPartialTF "Int" = "int"
NestedPartialTF "Bool" = "bool"
NestedPartialTF a =
TypeError (Text "Unexpected type @ NestedPartialTF: " :<>: ShowType a)
testPartialTF :: forall a.(KnownSymbol (PartialTF a)) => a -> String
testPartialTF t = symbolVal (Proxy :: Proxy (PartialTF a))
testNesPartialTF ::
forall a.(KnownSymbol (NestedPartialTF (PartialTF a))) => a -> String
testNesPartialTF t = symbolVal (Proxy :: Proxy (NestedPartialTF (PartialTF a)))
t2 = testNesPartialTF 'a'
|
ezyang/ghc
|
testsuite/tests/typecheck/should_fail/T11990b.hs
|
Haskell
|
bsd-3-clause
| 981
|
{-# LANGUAGE Unsafe #-}
{-# LANGUAGE CPP, NoImplicitPrelude, MagicHash, RoleAnnotations #-}
{-# OPTIONS_HADDOCK hide #-}
-----------------------------------------------------------------------------
-- |
-- Module : GHC.Ptr
-- Copyright : (c) The FFI Task Force, 2000-2002
-- License : see libraries/base/LICENSE
--
-- Maintainer : ffi@haskell.org
-- Stability : internal
-- Portability : non-portable (GHC Extensions)
--
-- The 'Ptr' and 'FunPtr' types and operations.
--
-----------------------------------------------------------------------------
module GHC.Ptr (
Ptr(..), FunPtr(..),
nullPtr, castPtr, plusPtr, alignPtr, minusPtr,
nullFunPtr, castFunPtr,
-- * Unsafe functions
castFunPtrToPtr, castPtrToFunPtr
) where
import GHC.Base
import GHC.Show
import GHC.Num
import GHC.List ( length, replicate )
import Numeric ( showHex )
#include "MachDeps.h"
------------------------------------------------------------------------
-- Data pointers.
-- The role of Ptr's parameter is phantom, as there is no relation between
-- the Haskell representation and whathever the user puts at the end of the
-- pointer. And phantom is useful to implement castPtr (see #9163)
-- redundant role annotation checks that this doesn't change
type role Ptr phantom
data Ptr a = Ptr Addr# deriving (Eq, Ord)
-- ^ A value of type @'Ptr' a@ represents a pointer to an object, or an
-- array of objects, which may be marshalled to or from Haskell values
-- of type @a@.
--
-- The type @a@ will often be an instance of class
-- 'Foreign.Storable.Storable' which provides the marshalling operations.
-- However this is not essential, and you can provide your own operations
-- to access the pointer. For example you might write small foreign
-- functions to get or set the fields of a C @struct@.
-- |The constant 'nullPtr' contains a distinguished value of 'Ptr'
-- that is not associated with a valid memory location.
nullPtr :: Ptr a
nullPtr = Ptr nullAddr#
-- |The 'castPtr' function casts a pointer from one type to another.
castPtr :: Ptr a -> Ptr b
castPtr = coerce
-- |Advances the given address by the given offset in bytes.
plusPtr :: Ptr a -> Int -> Ptr b
plusPtr (Ptr addr) (I# d) = Ptr (plusAddr# addr d)
-- |Given an arbitrary address and an alignment constraint,
-- 'alignPtr' yields the next higher address that fulfills the
-- alignment constraint. An alignment constraint @x@ is fulfilled by
-- any address divisible by @x@. This operation is idempotent.
alignPtr :: Ptr a -> Int -> Ptr a
alignPtr addr@(Ptr a) (I# i)
= case remAddr# a i of {
0# -> addr;
n -> Ptr (plusAddr# a (i -# n)) }
-- |Computes the offset required to get from the second to the first
-- argument. We have
--
-- > p2 == p1 `plusPtr` (p2 `minusPtr` p1)
minusPtr :: Ptr a -> Ptr b -> Int
minusPtr (Ptr a1) (Ptr a2) = I# (minusAddr# a1 a2)
------------------------------------------------------------------------
-- Function pointers for the default calling convention.
-- 'FunPtr' has a phantom role for similar reasons to 'Ptr'. Note
-- that 'FunPtr's role cannot become nominal without changes elsewhere
-- in GHC. See Note [FFI type roles] in TcForeign.
type role FunPtr phantom
data FunPtr a = FunPtr Addr# deriving (Eq, Ord)
-- ^ A value of type @'FunPtr' a@ is a pointer to a function callable
-- from foreign code. The type @a@ will normally be a /foreign type/,
-- a function type with zero or more arguments where
--
-- * the argument types are /marshallable foreign types/,
-- i.e. 'Char', 'Int', 'Double', 'Float',
-- 'Bool', 'Data.Int.Int8', 'Data.Int.Int16', 'Data.Int.Int32',
-- 'Data.Int.Int64', 'Data.Word.Word8', 'Data.Word.Word16',
-- 'Data.Word.Word32', 'Data.Word.Word64', @'Ptr' a@, @'FunPtr' a@,
-- @'Foreign.StablePtr.StablePtr' a@ or a renaming of any of these
-- using @newtype@.
--
-- * the return type is either a marshallable foreign type or has the form
-- @'IO' t@ where @t@ is a marshallable foreign type or @()@.
--
-- A value of type @'FunPtr' a@ may be a pointer to a foreign function,
-- either returned by another foreign function or imported with a
-- a static address import like
--
-- > foreign import ccall "stdlib.h &free"
-- > p_free :: FunPtr (Ptr a -> IO ())
--
-- or a pointer to a Haskell function created using a /wrapper/ stub
-- declared to produce a 'FunPtr' of the correct type. For example:
--
-- > type Compare = Int -> Int -> Bool
-- > foreign import ccall "wrapper"
-- > mkCompare :: Compare -> IO (FunPtr Compare)
--
-- Calls to wrapper stubs like @mkCompare@ allocate storage, which
-- should be released with 'Foreign.Ptr.freeHaskellFunPtr' when no
-- longer required.
--
-- To convert 'FunPtr' values to corresponding Haskell functions, one
-- can define a /dynamic/ stub for the specific foreign type, e.g.
--
-- > type IntFunction = CInt -> IO ()
-- > foreign import ccall "dynamic"
-- > mkFun :: FunPtr IntFunction -> IntFunction
-- |The constant 'nullFunPtr' contains a
-- distinguished value of 'FunPtr' that is not
-- associated with a valid memory location.
nullFunPtr :: FunPtr a
nullFunPtr = FunPtr nullAddr#
-- |Casts a 'FunPtr' to a 'FunPtr' of a different type.
castFunPtr :: FunPtr a -> FunPtr b
castFunPtr = coerce
-- |Casts a 'FunPtr' to a 'Ptr'.
--
-- /Note:/ this is valid only on architectures where data and function
-- pointers range over the same set of addresses, and should only be used
-- for bindings to external libraries whose interface already relies on
-- this assumption.
castFunPtrToPtr :: FunPtr a -> Ptr b
castFunPtrToPtr (FunPtr addr) = Ptr addr
-- |Casts a 'Ptr' to a 'FunPtr'.
--
-- /Note:/ this is valid only on architectures where data and function
-- pointers range over the same set of addresses, and should only be used
-- for bindings to external libraries whose interface already relies on
-- this assumption.
castPtrToFunPtr :: Ptr a -> FunPtr b
castPtrToFunPtr (Ptr addr) = FunPtr addr
------------------------------------------------------------------------
-- Show instances for Ptr and FunPtr
instance Show (Ptr a) where
showsPrec _ (Ptr a) rs = pad_out (showHex (wordToInteger(int2Word#(addr2Int# a))) "")
where
-- want 0s prefixed to pad it out to a fixed length.
pad_out ls =
'0':'x':(replicate (2*SIZEOF_HSPTR - length ls) '0') ++ ls ++ rs
instance Show (FunPtr a) where
showsPrec p = showsPrec p . castFunPtrToPtr
|
tolysz/prepare-ghcjs
|
spec-lts8/base/GHC/Ptr.hs
|
Haskell
|
bsd-3-clause
| 6,465
|
{-# OPTIONS_GHC -O -funbox-strict-fields #-}
-- The combination of unboxing and a recursive newtype crashed GHC 6.6.1
-- Trac #1255
-- Use -O to force the unboxing to happen
module Foo where
newtype Bar = Bar Bar -- Recursive
data Gah = Gah { baaz :: !Bar }
|
urbanslug/ghc
|
testsuite/tests/typecheck/should_compile/tc226.hs
|
Haskell
|
bsd-3-clause
| 265
|
module HAD.Y2014.M03.D21.Exercise where
-- $setup
-- >>> import Test.QuickCheck
-- >>> import Data.Maybe (fromJust)
-- | minmax
-- get apair of the min and max element of a list (in one pass)
-- returns Nothing on empty list
--
-- Point-free: checked
--
-- The function signature follows the idea of the methods in the System.Random
-- module: given a standard generator, you returns the modified list and the
-- generator in an altered state.
--
-- >>> minmax [0..10]
-- Just (0,10)
--
-- >>> minmax []
-- Nothing
--
-- prop> \(NonEmpty(xs)) -> minimum xs == (fst . fromJust . minmax) xs
-- prop> \(NonEmpty(xs)) -> maximum xs == (snd . fromJust . minmax) xs
--
minmax :: Ord a => [a] -> Maybe (a,a)
minmax = undefined
|
geophf/1HaskellADay
|
exercises/HAD/Y2014/M03/D21/Exercise.hs
|
Haskell
|
mit
| 722
|
{-# LANGUAGE Arrows, FlexibleContexts #-}
module QNDA.ImageReader where
import Text.XML.HXT.Core hiding (xshow)
import System.Directory (copyFile, doesFileExist, getCurrentDirectory)
import qualified System.FilePath.Posix as FP
import qualified System.Process as Prc (readProcess)
import Network.HTTP.Base (urlEncode)
import qualified Control.Exception as E
import System.IO.Error
-- import qualified Debug.Trace as DT (trace)
voidimg = "public/void.jpg"
imagePathToResourceName :: FilePath -- directory of image files
-> FilePath -- input file name
-> IO [FilePath] -- list of image paths within the file
imagePathToResourceName imagesdir f = do
links <-
runX (readDocument [ withIndent no
, withRemoveWS yes
, withValidate no
] f
>>>
(listA $
multi $
hasName "img" >>>
(ifA ( hasAttrValue "class" (=="inlinemath")
<+> hasAttrValue "class" (=="displaymath"))
(none)
(getAttrValue "src"))))
paths <- mapM (
\((basename, extension), counter) -> do
let imgpathInEpub = imagesdir ++ (FP.takeBaseName f) ++ basename ++ (show counter) ++ extension
imgsrc = imagesdir++basename++extension
dfe <- doesFileExist imgsrc
if dfe then (copyFile imgsrc imgpathInEpub) else (copyFile voidimg imgpathInEpub)
return imgpathInEpub
) $ zip (map (\link -> (FP.takeBaseName link, FP.takeExtension link)) $ concat links) [1..]
return paths
ignore :: E.SomeException -> IO ()
ignore _ = return ()
mkImgId :: FilePath -> (FilePath, Int) -> String
mkImgId f (s,c) = FP.takeBaseName f ++ (urlEncode $ FP.takeBaseName s) ++ show c ++ FP.takeExtension s
mkImgSrcPath :: String -> FilePath
mkImgSrcPath imgid = FP.combine "images" $ imgid
imgElem :: (ArrowXml a) => FilePath -> a XmlTree XmlTree
imgElem f =
fromSLA 0 (
processBottomUp (
(((\(alt,path) ->
(eelem "img"
+= sattr "src" path
+= sattr "alt" alt
+= sattr "class" "figure"
+= (sattr "style" $< styleAttr)))
$<
(getAttrValue "src" &&& nextState (+1) >>> arr (mkImgId f) >>> (this &&& arr mkImgSrcPath)))
)
`when`
(hasName "img" >>> neg (hasAttrValue "class" (=="inlinemath") <+> hasAttrValue "class" (=="displaymath")))))
styleAttr :: (ArrowXml a) => a XmlTree String
styleAttr =
((\(h,w) -> (case (h,w) of
("","") -> addAttr "style" "width:90%;"
("",w) -> addAttr "style" $ "width:"++w++";"
(h,"") -> addAttr "style" $ "height:"++h++";"
(h,w) -> addAttr "style" $ "width:"++w++";height:"++h++";"))
$<$ ((getAttrValue "height") &&& (getAttrValue "width")))
>>> getAttrValue "style"
|
k16shikano/wikipepub
|
QNDA/ImageReader.hs
|
Haskell
|
mit
| 2,938
|
{-# LANGUAGE PatternGuards #-}
-----------------------------------------------------------------------------
-- |
-- Module : Game.Tournament
-- Copyright : (c) Eirik Albrigtsen 2012
-- License : MIT
-- Maintainer : Eirik <clux> Albrigtsen
-- Stability : unstable
--
-- Tournament construction and maintenance including competition based structures and helpers.
--
-- This library is intended to be imported qualified as it exports functions that clash with
-- Prelude.
--
-- > import Game.Tournament as T
--
-- The Tournament structure contain a Map of 'GameId' -> 'Game' for its internal
-- representation and the 'GameId' keys are the location in the Tournament.
--
-- Duel tournaments are based on the theory from <http://clux.org/entries/view/2407>.
-- By using the seeding definitions listed there, there is almost only one way to
-- generate a tournament, and the ambivalence appears only in Double elimination.
--
-- We have additionally chosen that brackets should converge by having the losers bracket move upwards.
-- This is not necessary, but improves the visual layout when presented in a standard way.
--
-- FFA tournaments use a collection of sensible assumptions on how to
-- optimally split n people into s groups while minimizing the sum of seeds difference
-- between groups for fairness. At the end of each round, groups are recalculated from the scores
-- of the winners, and new groups are created for the next round.
-- TODO: This structure is meant to encapsulate this structure to ensure internal consistency,
-- but hopefully in such a way it can be safely serialized to DBs.
-----------------------------------------------------------------------------
module Game.Tournament (
-- * Building Block A: Duel helpers
seeds
, duelExpected
-- * Building Block B: Group helpers
, groups
, robin
-- * Tournament Types
, GameId(..)
, Elimination(..)
, Bracket(..)
, Rules(..)
, Results -- type synonym
, results
, Result -- no constructor, but accessors:
, player
, placement
, wins
, total
, Size
, Tournament -- no constructor
, Score
, GroupSize
, Advancers
--, Game(..)
--, Player
--, Games
-- * Tournament Interface
, tournament
, score
, count
, scorable
, keys
-- -* Match Inspection
--, scores
--, winner
--, loser
, testcase
) where
import Prelude hiding (round)
import Numeric (showIntAtBase, readInt)
import Data.Char (intToDigit, digitToInt)
import Data.List (sort, sortBy, group, groupBy, genericTake, zipWith4)
import Data.Ord (comparing)
import Data.Function (on)
import Data.Bits (shiftL)
import Data.Maybe (fromJust, isJust, fromMaybe)
import qualified Data.Map.Lazy as Map
import Data.Map (Map)
import qualified Data.Set as Set
import Control.Arrow ((&&&), second)
import Control.Monad (when)
import Control.Monad.State (State, get, put, modify, execState, gets)
--import System.IO.Unsafe (unsafePerformIO) -- while developing
-- -----------------------------------------------------------------------------
-- TODO should somehow ensure 0 < i <= 2^(p-1) in the next fn
-- | Power of a tournament.
-- It's defined as 2^num_players rounded up to nearest power of 2.
--type Power = Int
--type GameNumber = Int
-- TODO: use int synonyms more liberally?
-- | Computes both the upper and lower player seeds for a duel elimiation match.
-- The first argument is the power of the tournament:
--
-- p :: 2^num_players rounding up to nearest power of 2
--
-- The second parameter is the game number i (in round one).
--
-- The pair (p,i) must obey
--
-- >p > 0 && 0 < i <= 2^(p-1).
seeds :: Int -> Int -> (Int, Int)
seeds p i
| p > 0, i > 0, i <= 2^(p-1) = (1 - lastSeed + 2^p, lastSeed)
| otherwise = error "seeds called outside well defined power game region"
where
lastSeed = let (k, r) = ((floor . logBase 2 . fromIntegral) i, i - 2^k) in
case r of
0 -> 2^(p-k)
_ -> 2^(p-k-1) + nr `shiftL` (p - length bstr) where
bstr = reverse $ showIntAtBase 2 intToDigit (i - 2*r) ""
nr = fst $ head $ readInt 2 (`elem` "01") digitToInt bstr
-- | Check if the 3 criteria for perfect seeding holds for the current
-- power and seed pair arguments.
-- This can be used to make a measure of how good the seeding was in retrospect
duelExpected :: Integral a => a -> (a, a) -> Bool
duelExpected p (a, b) = odd a && even b && a + b == 1 + 2^p
-- -----------------------------------------------------------------------------
-- Group helpers
--type Group = [Int]
-- | Splits a numer of players into groups of as close to equal seeding sum
-- as possible. When groupsize is even and s | n, the seed sum is constant.
-- Fixes the number of groups as ceil $ n / s, but will reduce s when all groups not full.
groups :: Int -> Int -> [[Int]]
groups 0 _ = []
groups s n = map (sort . filter (<=n) . makeGroup) [1..ngrps] where
ngrps = ceiling $ fromIntegral n / fromIntegral s
-- find largest 0<gs<=s s.t. even distribution => at least one full group, i.e. gs*ngrps - n < ngrps
gs = until ((< ngrps + n) . (*ngrps)) (subtract 1) s
modl = ngrps*gs -- modl may be bigger than n, e.e. groups 4 10 has a 12 model
npairs = ngrps * (gs `div` 2)
pairs = zip [1..npairs] [modl, modl-1..]
leftovers = [npairs+1, npairs+2 .. modl-npairs] -- [1..modl] \\ e in pairs
makeGroup i = leftover ++ concatMap (\(x,y) -> [x,y]) gpairs where
gpairs = filter ((`elem` [i, i+ngrps .. i+npairs]) . fst) pairs
leftover = take 1 . drop (i-1) $ leftovers
-- | Round robin schedules a list of n players and returns
-- a list of rounds (where a round is a list of pairs). Uses
-- http://en.wikipedia.org/wiki/Round-robin_tournament#Scheduling_algorithm
robin :: Integral a => a -> [[(a,a)]]
robin n = map (filter notDummy . toPairs) rounds where
n' = if odd n then n+1 else n
m = n' `div` 2 -- matches per round
permute (x:xs@(_:_)) = x : last xs : init xs
permute xs = xs -- not necessary, wont be called on length 1/2 lists
rounds = genericTake (n'-1) $ iterate permute [1..n']
notDummy (x,y) = all (<=n) [x,y]
toPairs x = genericTake m $ zip x (reverse x)
-- -----------------------------------------------------------------------------
-- Duel elimination
-- | The location of a game is written as to simulate the classical shorthand WBR2,
-- but includes additionally the game number for complete positional uniqueness.
--
-- A 'Single' elimination final will have the unique identifier
--
-- > let wbf = GameId WB p 1
--
-- where 'p == count t WB'.
data GameId = GameId {
bracket :: Bracket
, round :: Int
, game :: Int
} deriving (Show, Eq, Ord)
-- | Duel Tournament option.
--
-- 'Single' elimation is a standard power of 2 tournament tree,
-- wheras 'Double' elimination grants each loser a second chance in the lower bracket.
data Elimination = Single | Double deriving (Show, Eq, Ord)
-- | The bracket location of a game.
--
-- For 'Duel' 'Single' or 'FFA', most matches exist in the winners bracket ('WB')
-- , with the exception of the bronze final and possible crossover matches.
--
-- 'Duel' 'Double' or 'FFA' with crossovers will have extra matches in the loser bracket ('LB').
data Bracket = WB | LB deriving (Show, Eq, Ord)
-- | Players and Results zip to the correct association list.
-- 'scores' will obtain this ordered association list safely.
data Game = Game {
players :: [Player]
, result :: Maybe [Score]
} deriving (Show, Eq)
type Games = Map GameId Game
-- | 'score' clarification types.
type Position = Int
type Score = Int
type Player = Int
type Seed = Int
-- | Record of each player's accomplishments in the current tournament.
data Result = Result {
-- | Player associated with the record.
player :: Int
-- | Placement of the player associated with this record.
, placement :: Int
-- | Number of games the player associated with this record won.
, wins :: Int
-- | Sum of scores for the games the associated player played.
, total :: Int
} deriving (Show)
-- | Results in descending order of placement.
--
-- Only constructed by 'score' once the last game was played.
type Results = [Result]
type GroupSize = Int
type Advancers = Int
data Rules = FFA GroupSize Advancers | Duel Elimination
type Size = Int
data Tournament = Tourney {
size :: Size
, crossover :: Bool
, rules :: Rules
, games :: Games
, results :: Maybe Results
}
-- Internal helpers
gameZip :: Game -> [(Player, Score)]
gameZip m = zip (players m) (fromJust (result m))
gameSort :: [(Player, Score)] -> [(Player, Score)]
gameSort = reverse . sortBy (comparing snd)
-- | Sorted player identifier list by scores.
--
-- If this is called on an unscored match a (finite) list zeroes is returned.
-- This is consistent with the internal representation of placeholders in Matches.
scores :: Game -> [Player]
scores g@(Game pls msc)
| Just _ <- msc = map fst . gameSort . gameZip $ g
| otherwise = replicate (length pls) 0
-- | The first and last elements from scores.
winner, loser :: Game -> Player
winner = head . scores
loser = last . scores
-- Duel specific helper
pow :: Int -> Int
pow = ceiling . logBase 2 . fromIntegral
-- | Count the number of rounds in a given bracket in a Tournament.
-- TODO: rename to length once it has been less awkwardly moved into an internal part
count :: Tournament -> Bracket -> Int
count Tourney { rules = Duel Single, size = np } br = if br == WB then pow np else 0 -- 1 with bronze
count Tourney { rules = Duel Double, size = np } br = (if br == WB then 1 else 2) * pow np
count Tourney { rules = FFA _ _, games = ms } WB = round . fst . Map.findMax $ ms
count Tourney { rules = FFA _ _} LB = 0
-- Scoring and construction helper
woScores :: [Player] -> Maybe [Score]
woScores ps
| 0 `notElem` ps && -1 `elem` ps = Just $ map (\x -> if x == -1 then 0 else 1) ps
| otherwise = Nothing
-- | Get the list of all GameIds in a Tournament.
-- This list is also ordered by GameId's Ord, and in fact,
-- if the corresponding games were scored in this order, the tournament would finish,
-- and scorable would only return False for a few special walkover games.
-- TODO: if introducing crossovers, this would not be true for LB crossovers
-- => need to place them in WB in an 'interim round'
keys :: Tournament -> [GameId]
keys = Map.keys . games
-- | Create match shells for an FFA elimination tournament.
-- Result comes pre-filled in with either top advancers or advancers `intersect` seedList.
-- This means what the player numbers represent is only fixed per round.
-- TODO: Either String Tournament as return for intelligent error handling
tournament :: Rules -> Size -> Tournament
tournament rs@(FFA gs adv) np
-- Enforce >2 players, >2 players per match, and >1 group needed.
-- Not technically limiting, but: gs 2 <=> duel and 1 group <=> best of one.
| np <= 2 = error "Need >2 players for an FFA elimination"
| gs <= 2 = error "Need >2 players per match for an FFA elimination"
| np <= gs = error "Need >1 group for an FFA elimination"
| adv >= gs = error "Need to eliminate at least one player a match in FFA elimination"
| adv <= 0 = error "Need >0 players to advance per match in a FFA elimination"
| otherwise =
--TODO: allow crossover matches when there are gaps intelligently..
let minsize = minimum . map length
hideSeeds = map $ map $ const 0
nextGroup g = hideSeeds . groups gs $ leftover where
-- force zero non-eliminating matches unless only 1 left
advm = max 1 $ adv - (gs - minsize g)
leftover = length g * advm
playoffs = takeWhile ((>1) . length) . iterate nextGroup . groups gs $ np
final = nextGroup $ last playoffs
grps = playoffs ++ [final]
-- finally convert raw group lists to matches
makeRound grp r = zipWith makeMatch grp [1..] where
makeMatch g i = (GameId WB r i, Game g Nothing)
ms = Map.fromList . concat $ zipWith makeRound grps [1..]
in Tourney { size = np, rules = rs, games = ms, results = Nothing, crossover = False }
-- | Create match shells for an elimination tournament
-- hangles walkovers and leaves the tournament in a stable initial state
tournament rs@(Duel e) np
-- Enforce minimum 4 players for a tournament. It is possible to extend to 2 and 3, but:
-- 3p uses a 4p model with one WO => == RRobin in Double, == Unfair in Single
-- 2p Single == 1 best of 1 match, 2p Double == 1 best of 3 match
-- and grand final rules fail when LB final is R1 (p=1) as GF is then 2*p-1 == 1 ↯
| np < 4 = error "Need >=4 competitors for an elimination tournament"
| otherwise = Tourney { size = np, rules = rs, games = ms, results = Nothing, crossover = True} where
p = pow np
-- complete WBR1 by filling in -1 as WO markers for missing (np'-np) players
markWO (x, y) = map (\a -> if a <= np then a else -1) [x,y]
makeWbR1 i = (l, Game pl (woScores pl)) where
l = GameId WB 1 i
pl = markWO $ seeds p i
-- make WBR2 and LBR1 shells by using the paired WBR1 results to propagate winners/WO markers
propagateWbR1 br ((_, m1), (l2, m2)) = (l, Game pl (woScores pl)) where
(l, pl)
| br == WB = (GameId WB 2 g, map winner [m1, m2])
| br == LB = (GameId LB 1 g, map loser [m1, m2])
g = game l2 `div` 2
-- make LBR2 shells by using LBR1 results to propagate WO markers if 2x
makeLbR2 (l1, m1) = (l, Game pl Nothing) where
l = GameId LB 2 $ game l1
plw = winner m1
pl = if odd (game l1) then [0, plw] else [plw, 0]
-- construct (possibly) non-empty rounds
wbr1 = map makeWbR1 [1..2^(p-1)]
wbr1pairs = take (2^(p-2))
$ filter (even . game . fst . snd) $ zip wbr1 (tail wbr1)
wbr2 = map (propagateWbR1 WB) wbr1pairs
lbr1 = map (propagateWbR1 LB) wbr1pairs
lbr2 = map makeLbR2 lbr1
-- construct (definitely) empty rounds
wbRest = concatMap makeRound [3..p] where
makeRound r = map (GameId WB r) [1..2^(p-r)]
--bfm = MID LB (R 1) (G 1) -- bronze final here, exception
lbRest = map gfms [2*p-1, 2*p] ++ concatMap makeRound [3..2*p-2] where
makeRound r = map (GameId LB r) [1..(2^) $ p - 1 - (r+1) `div` 2]
gfms r = GameId LB r 1
toMap = Map.fromSet (const (Game [0,0] Nothing)) . Set.fromList
-- finally, union the mappified brackets
wb = Map.union (toMap wbRest) $ Map.fromList $ wbr1 ++ wbr2
lb = Map.union (toMap lbRest) $ Map.fromList $ lbr1 ++ lbr2
ms = if e == Single then wb else wb `Map.union` lb
-- | Helper to create the tie-correct Player -> Position association list.
-- Requires a Round -> Position function to do the heavy lifting where possible,
-- the final Game and Maybe bronzefinal to not take out
-- the list of games prefiltered away non-final bracket and final games.
-- result zips with Player == [1..]
placementSort :: Game -> Maybe Game -> (Int -> Position) -> Games -> [Position]
placementSort fg bf toPlacement = map snd . sortBy (comparing fst)
. prependTop 1 (Just fg)
. prependTop (((+1) . length . players) fg) bf
. excludeTop
. map (second toPlacement . (fst . head &&& foldr (max . snd) 1))
. groupBy ((==) `on` fst)
. sortBy (comparing fst)
. Map.foldrWithKey rfold []
where
pls = if isJust bf then concatMap players [fg, fromJust bf] else players fg
rfold (GameId _ r _) m acc = (++ acc) . map (id &&& const r) $ players m
prependTop :: Int -> Maybe Game -> [(Position, Player)] -> [(Position, Player)]
prependTop strt g
| isJust g = (++) . flip zip [strt..] . map fst . gameSort . gameZip . fromJust $ g
| otherwise = id
excludeTop :: [(Position, Player)] -> [(Position, Player)]
excludeTop = filter ((`notElem` pls) . fst)
-- zips with Player == [1..]
sumScores :: Games -> [Score]
sumScores = map (foldr ((+) . snd) 0)
. groupBy ((==) `on` fst)
. sortBy (comparing fst)
. Map.foldr ((++) . gameZip) []
-- zips with Player == [1..]
getWins :: Int -> Games -> [Int]
getWins np = map (subtract 1 . length) -- started out with one of each so we can count zeroes
. group . sort
. Map.foldr ((:) . winner) [1..np]
zipResults :: [Int] -> [Int] -> [Int] -> [Result]
zipResults a b = sortBy (comparing placement) . zipWith4 Result [1..] a b
makeResults :: Tournament -> Games -> Maybe Results
makeResults (Tourney {rules = Duel e, size = np}) ms
| e == Single
, Just wbf@(Game _ (Just _)) <- Map.lookup (GameId WB p 1) ms -- final played
-- bf lookup here if included!
= Just . scorify $ wbf
| e == Double
, Just gf1@(Game _ (Just gf1sc)) <- Map.lookup (GameId LB (2*p-1) 1) ms -- gf1 played
, Just gf2@(Game _ gf2sc) <- Map.lookup (GameId LB (2*p) 1) ms -- gf2 maybe played
, isJust gf2sc || maximum gf1sc == head gf1sc -- gf2 played || gf1 conclusive
= Just . scorify $ if isJust gf2sc then gf2 else gf1
| otherwise = Nothing
where
p = pow np
maxRnd = if e == Single then p else 2*p-1
-- maps (last bracket's) maxround to the tie-placement
toPlacement :: Elimination -> Int -> Position
toPlacement Double maxlbr = if metric <= 4 then metric else 2^(k+1) + 1 + oddExtra where
metric = 2*p + 1 - maxlbr
r = metric - 4
k = (r+1) `div` 2
oddExtra = if odd r then 0 else 2^k
toPlacement Single maxr = if metric <= 1 then metric else 2^r + 1 where
metric = p+1 - maxr
r = metric - 1
scorify :: Game -> Results
scorify f = zipResults placements (getWins np ms) (sumScores msnwo) where
-- all pipelines start with this. 0 should not exist, -1 => winner got further
-- scores not Just => should not have gotten this far by guard in score fn
msnwo = Map.filter (all (>0) . players) ms
placements = placementSort f Nothing (toPlacement e)
. Map.filterWithKey lastBracketNotFinal $ msnwo
lastBracketNotFinal k _ = round k < maxRnd && lastBracket (bracket k)
lastBracket br = (e == Single && br == WB) || (e == Double && br == LB)
makeResults (Tourney {rules = FFA _ _, size = np}) ms
| (GameId _ maxRnd _, f@(Game _ (Just _))) <- Map.findMax ms
= Just $ scorify maxRnd f
| otherwise = Nothing
where
-- rsizes :: [(RoundNr, NumPlayers)] lookup helper for toPlacement
rsizes = map (fst . head &&& foldr ((+) . snd) 0)
. groupBy ((==) `on` fst)
. sortBy (comparing fst)
. Map.foldrWithKey rsizerf [] $ ms
where
rsizerf gid g acc = (round gid, (length . players) g) : acc
-- maps a player's maxround to the tie-placement (called for r < maxRnd)
-- simplistic :: 1 + number of people who got through to next round
toPlacement :: Int -> Position
toPlacement maxrp = (1+) . fromJust . lookup (maxrp + 1) $ rsizes
scorify :: Int -> Game -> Results
scorify maxRnd f = zipResults placements (getWins np ms) (sumScores ms) where
-- NB: WO markers or placeholders should NOT exist when scorify called!
-- placements using common helper, having prefiltered final game(round)
placements = placementSort f Nothing toPlacement
. Map.filterWithKey (\k _ -> round k < maxRnd) $ ms
playersReady :: GameId -> Tournament -> Maybe [Player]
playersReady gid t
| Just (Game pls _) <- Map.lookup gid $ games t
, all (>0) pls
= Just pls
| otherwise = Nothing
-- | Check if a GameId exists and is ready to be scored through 'score'.
scorable :: GameId -> Tournament -> Bool
scorable gid = isJust . playersReady gid
-- | Checks if a GameId is 'scorable' and it will not propagate to an already scored Game.
-- Guarding Tournament updates with this ensures it is never in an inconsistent state.
-- TODO: really needs access to mRight, mDown (if duel) to ensure they exist
-- TODO: if FFA only allow scoring if NO matches in the next round have been scored
safeScorable :: GameId -> Tournament -> Bool
safeScorable = undefined
-- | Score a match in a tournament and propagate winners/losers.
-- If match is not 'scorable', the Tournament will pass through unchanged.
--
-- For a Duel tournament, winners (and losers if Double) are propagated immediately,
-- wheras FFA tournaments calculate winners at the end of the round (when all games played).
--
-- There is no limitation on re-scoring old games, so care must be taken to not update too far
-- back ones and leaving the tournament in an inconsistent state. When scoring games more than one
-- round behind the corresponding active round, the locations to which these propagate must
-- be updated manually.
--
-- To prevent yourself from never scoring older matches, only score games for which
-- 'safeScorable' returns True. Though this has not been implemented yet.
--
-- > gid = (GameId WB 2 1)
-- > tUpdated = if safeScorable gid then score gid [1,0] t else t
--
-- TODO: strictify this function
-- TODO: better to do a scoreSafe? // call this scoreUnsafe
score :: GameId -> [Score] -> Tournament -> Tournament
score gid sc trn@(Tourney { rules = r, size = np, games = ms })
| Duel e <- r
, Just pls <- playersReady gid trn
, length sc == 2
= let msUpd = execState (scoreDuel (pow np) e gid sc pls) ms
rsUpd = makeResults trn msUpd
in trn { games = msUpd, results = rsUpd }
| FFA s adv <- r
, Just pls <- playersReady gid trn
, length sc == length pls
= let msUpd = execState (scoreFFA s adv gid sc pls) ms
rsUpd = makeResults trn msUpd
in trn { games = msUpd, results = rsUpd }
-- somewhat less ideally, if length sc /= length pls this now also fails silently even if socable passes
| otherwise = trn
scoreFFA :: GroupSize -> Advancers -> GameId -> [Score] -> [Player] -> State Games ()
scoreFFA gs adv gid@(GameId _ r _) scrs pls = do
-- 1. score given game
let m = Game pls $ Just scrs
modify $ Map.adjust (const m) gid
-- 2. if end of round, fill in next round
currRnd <- gets $ Map.elems . Map.filterWithKey (const . (==r) . round)
when (all (isJust . result) currRnd) $ do
-- find the number of players we need in next round
numNext <- gets $ Map.foldr ((+) . length . players) 0
. Map.filterWithKey (const . (==r+1) . round)
-- recreate next round by using last round results as new seeding
-- update next round by overwriting duplicate keys in next round
modify $ flip (Map.unionWith (flip const)) $ makeRnd currRnd numNext
return ()
where
-- make round (r+1) from the games in round r and the top n to take
makeRnd :: [Game] -> Size -> Games
makeRnd gms = Map.fromList . nextGames . grpMap (seedAssoc False gms) . groups gs
-- This sorts all players by overall scores (to help pick best crossover candidates)
-- Or, if !takeAll, sort normally by only including the advancers from each game.
seedAssoc :: Bool -> [Game] -> [(Seed, Player)]
seedAssoc takeAll rnd
| takeAll = seedify . concatMap gameZip $ rnd
| otherwise = seedify . concatMap (take (rndAdv rnd) . gameSort . gameZip) $ rnd
where
-- Find out how many to keep from each round before sorting overall
rndAdv :: [Game] -> Advancers
rndAdv = max 1 . (adv - gs +) . minimum . map (length . players)
seedify :: [(Player, Score)] -> [(Seed, Player)]
seedify = zip [1..] . map fst . gameSort
grpMap :: [(Seed, Player)] -> [[Seed]] -> [[Player]]
grpMap assoc = map . map $ fromJust . flip lookup assoc
nextGames :: [[Player]] -> [(GameId, Game)]
nextGames = zipWith (\i g -> (GameId WB (r+1) i, Game g Nothing)) [1..]
scoreDuel :: Int -> Elimination -> GameId -> [Score] -> [Player] -> State Games (Maybe Game)
scoreDuel p e gid scrs pls = do
-- 1. score given game
let m = Game pls $ Just scrs
modify $ Map.adjust (const m) gid
-- 2. move winner right
let nprog = mRight True p gid
nres <- playerInsert nprog $ winner m
-- 3. move loser to down if we were in winners
let dprog = mDown p gid
dres <- playerInsert dprog $ loser m
-- 4. check if loser needs WO from LBR1
let dprog2 = woCheck p dprog dres
uncurry playerInsert $ fromMaybe (Nothing, 0) dprog2
-- 5. check if winner needs WO from LBR2
let nprog2 = woCheck p nprog nres
uncurry playerInsert $ fromMaybe (Nothing, 0) nprog2
return Nothing
where
-- insert player x into list index idx of mid's players, and woScore it
-- progress result determines location and must be passed in as fst arg
playerInsert :: Maybe (GameId, Position) -> Player -> State Games (Maybe Game)
playerInsert Nothing _ = return Nothing
playerInsert (Just (gid, idx)) x = do
tmap <- get
let (updated, tupd) = Map.updateLookupWithKey updFn gid tmap
put tupd
return updated
where updFn _ (Game plsi _) = Just $ Game plsm (woScores plsm) where
plsm = if idx == 0 then [x, last plsi] else [head plsi, x]
-- given tourney power, progress results, and insert results, of previous
-- if it was woScored in playerInsert, produce new (progress, winner) pair
woCheck :: Player
-> Maybe (GameId, Position)
-> Maybe Game
-> Maybe (Maybe (GameId, Position), Player)
woCheck p (Just (gid, _)) (Just mg)
| w <- winner mg, w > 0 = Just (mRight False p gid, w)
| otherwise = Nothing
woCheck _ _ _ = Nothing
-- right progress fn: winner moves right to (GameId, Position)
mRight :: Bool -> Int -> GameId -> Maybe (GameId, Position)
mRight gf2Check p (GameId br r g)
| r < 1 || g < 1 = error "bad GameId"
-- Nothing if last Game. NB: WB ends 1 round faster depending on e
| r >= 2*p || (br == WB && (r > p || (e == Single && r == p))) = Nothing
| br == LB = Just (GameId LB (r+1) ghalf, pos) -- standard LB progression
| r == 2*p-1 && br == LB && gf2Check && maximum scrs == head scrs = Nothing
| r == p = Just (GameId LB (2*p-1) ghalf, 0) -- WB winner -> GF1 path
| otherwise = Just (GameId WB (r+1) ghalf, pos) -- standard WB progression
where
ghalf = if br == LB && odd r then g else (g+1) `div` 2
pos
| br == WB = if odd g then 0 else 1 -- WB maintains standard alignment
| r == 2*p-2 = 1 -- LB final winner => bottom of GF
| r == 2*p-1 = 0 -- GF(1) winnner moves to the top [semantic]
| r > 1 && odd r = 1 -- winner usually takes the bottom position
| r == 1 = if odd g then 1 else 0 -- first rounds sometimes goto bottom
| otherwise = if odd g then 0 else 1 -- normal progression only in even rounds + R1
-- by placing winner on bottom consistently in odd rounds the bracket moves upward each new refill
-- the GF(1) and LB final are special cases that give opposite results to the advanced rule above
-- down progress fn : loser moves down to (GameId, Position)
mDown :: Int -> GameId -> Maybe (GameId, Position)
mDown p (GameId br r g)
| e == Single = Nothing
-- or case for bf: | e == Single && r == p-1 = Just (MID LB (R 1) (G 1), if odd g then 0 else 1)
| r == 2*p-1 = Just (GameId LB (2*p) 1, 1) -- GF(1) loser moves to the bottom
| br == LB || r > p = Nothing
| r == 1 = Just (GameId LB 1 ghalf, pos) -- WBR1 -> r=1 g/2 (LBR1 only gets input from WB)
| otherwise = Just (GameId LB ((r-1)*2) g, pos) -- WBRr -> 2x as late per round in WB
where
ghalf = (g+1) `div` 2
-- drop on top >R2, and <=2 for odd g to match bracket movement
pos = if r > 2 || odd g then 0 else 1
-- testing stuff
upd :: [Score] -> GameId -> State Tournament ()
upd sc id = do
t <- get
put $ score id sc t
return ()
manipDuel :: [GameId] -> State Tournament ()
manipDuel = mapM_ (upd [1,0])
manipFFA :: State Tournament ()
manipFFA = do
upd [1,2,3,4] $ GameId WB 1 1
upd [5,3,2,1] $ GameId WB 1 2
upd [2,4,2,1] $ GameId WB 1 3
upd [6,3,2,1] $ GameId WB 1 4
upd [1,2,3,4] $ GameId WB 2 1
testor :: Tournament -> IO ()
testor Tourney { games = ms, results = rs } = do
mapM_ print $ Map.assocs ms
maybe (print "no results") (mapM_ print) rs
testcase :: IO ()
testcase = do
--let t = tournament (Duel Double) 8
--testor $ execState (manipDuel (keys t)) t
let t = tournament (FFA 4 1) 16
testor $ execState manipFFA t
-- | Checks if a Tournament is valid
{-
PERHAPS BETTER:
WB: always has np (rounded to nearest power) - 1 matches -- i.e. np = 2^p some p > 1
LB: always has 2*[num_wb_matches - 2^(p-1) + 1] -- i.e. minus the first round's matches but plus two finals
tournamentValid :: Tournament -> Bool
tournamentValid t =
let (wb, lb) = partition ((== WB) . brac . locId) r
roundRightWb k = rightSize && uniquePlayers where
rightSize = 2^(p-k) == length $ filter ((== k) . rnd . locId) wb
uniquePlayers =
rountRightLb k = rightSize && uniquePlayers where
rightSize = 2^(p - 1 - (k+1) `div` 2) == length $ filter ((== k) . rnd . locId) lb
in all $ map roundRightWb [1..2^p]
-}
|
clux/tournament.hs
|
Game/Tournament.hs
|
Haskell
|
mit
| 29,171
|
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE QuasiQuotes #-}
module AoC201607
( runDay,
) where
import Data.List (tails)
import Str
import Text.Parsec
import Text.Parsec.String
runDay :: IO ()
runDay = do
let tlsCount = execute addressesParser fullInput
let sslCount = execute2 addressesParser fullInput
putStrLn $ "7) The count of transmissions with TLS is " ++ (show tlsCount) ++ "."
putStrLn $ "7) The count of transmissions with SSL is " ++ (show sslCount) ++ "."
data Ip7Address = Ip7Address { primaries :: [String], hypernets :: [String] } deriving Show
-- Part 2
execute2 p xs =
case parse p "test" xs of
Prelude.Left msg -> show msg
Prelude.Right addresses -> show $ length $ filter supportsSSL $ addressesCombiner addresses
supportsSSL :: Ip7Address -> Bool
supportsSSL address = let
myAbas = abas address
hasBab = anyTrue $ map (\aba -> isBab aba address) myAbas
in hasBab
isBab :: [Char] -> Ip7Address -> Bool
isBab aba address = anyTrue $ map (babChecker aba) $ possibleBABs address
anyTrue :: Foldable t => t Bool -> Bool
anyTrue xs = any (True ==) xs
babChecker :: Eq a => [a] -> [a] -> Bool
babChecker aba x = x == babMaker aba
babMaker :: [a] -> [a]
babMaker aba = [(head $ drop 1 aba), head aba, (head $ drop 1 aba)]
abas :: Ip7Address -> [String]
abas address = filter abaChecker $ possibleABAs address
hasABA :: Ip7Address -> Bool
hasABA address = 0 < (length $ abas address)
abaChecker :: Eq a => [a] -> Bool
abaChecker x = x == (reverse x) && (head x) /= (head $ drop 1 x)
possibleBABs :: Ip7Address -> [String]
possibleBABs address = possibles $ hypernets address
possibleABAs :: Ip7Address -> [String]
possibleABAs address = possibles $ primaries address
possibles :: [String] -> [String]
possibles xs = concat $ map (windows 3) xs
-- Part 1
execute p xs =
case parse p "test" xs of
Prelude.Left msg -> show msg
Prelude.Right addresses -> show $ length $ filter addressSupportsTLS $ addressesCombiner addresses
addressSupportsTLS :: Ip7Address -> Bool
addressSupportsTLS x = let
pAbba = anyTrue $ map isAbba $ primaries x
hAbba = all (False ==) $ map isAbba $ hypernets x
in all (True ==) $ pAbba : [hAbba]
isAbba :: String -> Bool
isAbba xs = anyTrue $ map abbaChecker $ possibleAbbas xs
abbaChecker :: Eq a => ([a], [a]) -> Bool
abbaChecker x = ((fst x) == (reverse $ snd x)) && ((fst x) /= (snd x))
possibleAbbas :: [a] -> [([a], [a])]
possibleAbbas xs = let
l = windows 2 xs
in zip l (drop 2 $ l)
windows :: Int -> [a] -> [[a]]
windows n xs = filter (\x -> length x >= n) $ map (take n) (tails xs)
-- Gross intermediate data handling code
-- There has to be a nicer way than this. I think I probably need to learn about parser generators or something.
data Ip7AddressFragment = Ip7AddressFragment { primary :: String, hypernet :: String } deriving Show
addressesCombiner :: [[Ip7AddressFragment]] -> [Ip7Address]
addressesCombiner xs = map (\x -> fragmentsCombiner x) xs
fragmentsCombiner :: [Ip7AddressFragment] -> Ip7Address
fragmentsCombiner xs = foldl (\acc x -> Ip7Address ((primaries acc) ++ [(primary x)]) (hypernets acc ++ [(hypernet x)])) (Ip7Address [] []) xs
-- Parsers
addressesParser :: Parser [[Ip7AddressFragment]]
addressesParser = do
a <- many1 ip7Parser
return a
ip7Parser :: Parser [Ip7AddressFragment]
ip7Parser = do
p <- primaryParser
h <- option [] hypernetParser
rest <- option [] ip7Parser
optional endOfLine
return (Ip7AddressFragment p h : rest)
primaryParser :: Parser String
primaryParser = many1 letter
hypernetParser :: Parser String
hypernetParser = do
char '['
h <- many1 letter
char ']'
return h
-- Input Data
part2TestInput :: String
part2TestInput = [str|aba[bab]xyz
xyx[xyx]xyx
aaa[kek]eke
zazbz[bzb]cdb|]
smallInput :: String
smallInput = [str|abba[mnop]qrst
abcd[bddb]xyyx
aaaa[qwer]tyui
ioxxoj[asdfgh]zxcvbn|]
fullInput :: String
fullInput = [str|dnwtsgywerfamfv[gwrhdujbiowtcirq]bjbhmuxdcasenlctwgh
rnqfzoisbqxbdlkgfh[lwlybvcsiupwnsyiljz]kmbgyaptjcsvwcltrdx[ntrpwgkrfeljpye]jxjdlgtntpljxaojufe
jgltdnjfjsbrffzwbv[nclpjchuobdjfrpavcq]sbzanvbimpahadkk[yyoasqmddrzunoyyk]knfdltzlirrbypa
vvrchszuidkhtwx[ebqaetowcthddea]cxgxbffcoudllbtxsa
olgvwasskryjoqpfyvr[hawojecuuzobgyinfi]iywikscwfnlhsgqon
jlzynnkpwqyjvqcmcbz[fdjxnwkoqiquvbvo]bgkxfhztgjyyrcquoiv[xetgnqvwtdiuyiyv]zyfprefpmvxzauur
vjqhodfzrrqjshbhx[lezezbbswydnjnz]ejcflwytgzvyigz[hjdilpgdyzfkloa]mxtkrysovvotkuyekba
xjmkkppyuxybkmzya[jbmofazcbdwzameos]skmpycixjqsagnzwmy
zeebynirxqrjbdqzjav[cawghcfvfeefkmx]xqcdkvawumyayfnq[qhhwzlwjvjpvyavtm]sbnvwssglfpyacfbua[wpbknuubmsjjbekkfy]icimffaoqghdpvsbx
enupgggxsmwvfdljoaj[qlfmrciiyljngimjh]qkjawvmtnvkidcclfay[bllphejvluylyfzyvli]heboydfsgafkqoi
ottpscfbgoiyfri[iwzhojzrpzuinumuwd]orfroqlcemumqbqqrea
zhrhvyfxxcsdpris[xdqecoqujrnqbgla]bpwibmrkcfbzigf[rlqtqykdltcpusvc]ybtsglkxrhucxwv
msaebhhuxyaevahov[skkhuecthcqtrvtunw]bzlvljpsapsezchptjs[lbcxoczqbyysmha]zdqlfydjdctfnuetghr[owwhfhnjmpekukafw]qqitepzwooogqifl
jhdfwesnofrkpse[mkruficpgplktbmoo]mnrjpuvsauanolvzhym
ucibfxxivatgxlupp[rxlbgrqostcioowo]faiimhdhgpockadenua[teomupxzwrernokhyud]ohsfljkyjvkfzwus
gzxcgjqdbyvfndfpw[ypfsapvecfqihnpuszq]mvwxgfkniekgqzqid
fipkggpfwvgrqiwosi[itadifxotejgzkt]szwurlcbvffhgse
ketltdpowbxcusrcua[oonjssgqvcgwvlz]otjxgpizqfpcriuco[mgtgmwcjecomtdkxdev]dnrecyeyhqcpausqzsw
lcototgbpkkoxhsg[erticxnxcjwypnunco]notoouvtmgqcfdupe[hubcmesmprktstzyae]unuquevgbpxqnrib[egalxegqwowylkdjkdg]spqmkzfjnzwcwgutl
nesmourutitzqtolwd[rurfefjvljejcufm]jagkqdwpkefkjdz[cctohikipqxxbdjxsg]badmffkslhmgsxqscf
vvbwenaczgfagvrv[dqjzprtikukbikojlgm]bkfrnbigwaitptbdcha[llnwgonsrsppphnnp]sqozspzzfbeigmw
jzkzjzzghblqqme[fsqzyykcotbavruyp]vjzohzsunrevhmpi
jlngucjirfgdgorbgb[nvvkvebcjahujrwjmy]cfnlrssuthgusytkqt
kegsdcxndhtlskseb[zbtcngduxclffzlw]wrdqbtrqbcpbeaiqvx[svsyqhkrryycnkceq]ztrawvffepndijceeih
imtafeyfivrcegpagsl[tjzsewuwboushjl]mtnyptormlwiijlds
sblhlpnuutqgtuvlc[jlkivbtbkivklrnr]zkzcykzkyjxarepzvrr
ojuqmcidxmsyjkhuh[gsegkxlimzuyceo]dlhjiensaurluhul
sxkxluastorxmnd[gwkeczwgmamhjquth]yvpdadteadabxgsplmr
cndxxzfcmwwtcibgktm[ntsvmiwosuvniztv]onnfaenxutizlbxdk
eqiwaqxxstamxgzc[vnomzylvfpmcscjar]rwdqevxpeqvrmvliu
tvzbzkhvpzedqtp[whzeqaisikjjbezzcow]hqbizwaaffwbtfglq
ajwpjiqawievazmipkw[mgfhwrppaxagfdgfsa]iaqcnovhgearcutadns[anaukyaljeflxdnucbn]bhqcwrkeolrhwdih
neakzsrjrhvixwp[ydbbvlckobfkgbandud]xdynfcpsooblftf[wzyquuvtwnjjrjbuhj]yxlpiloirianyrkzfqe
jugqswdvlbaorwk[dfqvlubdcigzpcz]aqhybhnoukoyxuiw
kkkfysfugyvqnfvj[ahhqkrufcvhfvapblc]jfincvlxbjivelqrs[mpoymhslpyekjmy]eicbqlzecwuugez[tsqmqvjiokqofbp]senbbdxrdigwcjwik
ogiiiqaxakiaucwa[ltdchlxwnzefocrw]koxethzfvlsewbqdt[qdfqgtzftqpaxuzcruo]fvkgjcglmmxqnifv
epmnxkubnsnyeeyubv[ydzhcoytayiqmxlv]edmbahbircojbkmrg[dlxyprugefqzkum]svdaxiwnnwlkrkukfg[eacekyzjchfpzghltn]ofwgevhoivrevueaj
vvwvubpdeogvuklsjy[psnqcfnqhxaibnij]fwzpkbdgmpocoqp
pjdxcbutwijvtoftvw[zkqtzecoenkibees]llfxdbldntlydpvvn[uaweaigkebxceixszbh]xxlipjtlogbnxse
zmnirrxetiwyese[cedxmaoadgjjvsesk]nuisspyclmncqlasmuy[zxwlwmbzbjmvubgcf]hfqniztoirmsdwz[zlffqhttbpehxoabzhx]upmydjqzzwefvgdpqu
lwvsssgvvylrvqh[duxjrrqkzchbpvnmm]pckmefvejytvzavgzgc[dcekfwnrzooigwio]pmutxfiwfowlfnnggl[lzytuzirtzgwhkz]yzgxtksuqrgvvgfefon
tpmyecqhqjjpertn[qomuwmxstmgzexds]ftvqqwsvsrnmvpg[vtpebuufpyieqbhuu]dorortnekxkwnploro[pzajzflqvbkhautupl]eowpcyzmyvnntvzmvx
foguzgeasrkncbny[tlyweucylxkswwxb]jtzjubgewwhlddar[dkddqrpwaqvlhdp]skkegnatbjubqglwu[pkwscrmgvjzarzb]ibaagrqwnxblvtkg
ejgpdxesfyoyaggmymi[axfkdoyoqkpkhusfwe]pnczsmszqevkqiwlfc[dqhzcqjzpgnoknmv]ldrjdhopfyctlqtn
gqhyasteoryuofc[bhblyxlbiqtzzyzvzqg]dtvxrlkyuwxttyw[qvvzvuzhkemwglh]bopvfttkwtaeckq[vvhkkgrddaoxnzctwar]gsscsjuictekguq
sviwnvbtrgyydtadhz[ipjrrywkoxwuzmlrzd]kcxruwyisqvokporkub[tvarlltnhjmcuvvcck]raafszljrhconjqsqi[snbxmvzrkojpjybkgpi]ekoeuottccqbxrvpkb
vtouviqjarqwnoexuy[lzxhegzxptktueqo]azfsikzbwiajcrhnas[hvqxgtffjyyfgsjowxy]ddbmpksrtghvvypev[eoepwehfavxzwgt]igsulpdhrevkghzh
fucimprxzsubuuzmk[umzezmmnkfzvjlela]qxzdlcryifsinmkgeha
kauzjbailyzpvtji[hgeslalzqgpdkpuvomw]utsywinellykvmuawwr
oacbdgfaszolybf[hsytrkjoylrkkduzfz]bmoelqhppaxshmfjl[cusgbbuydfqtbbmsju]mcftwalxlvfvvpeu
ybylybngqxxrmplf[mybpfztzwnisfpfgqmb]fsllclehoezgthek[ldxhvhwniqfpqbl]ebybalwrmrqldukb[okenxoqxjgrenrcjd]kluumgtqybryflqi
mufsafgfxiegfgf[ydibrbrmiaulexjek]ouwchrlvilmygbuppjl[imyaxsiodgjteppdyy]ugondbuqnhjrzzzn
idihouejjocbahe[mclnirhxghanatge]ubwhxskdzgkmyrp[vksyktucsyumvxoc]bregaefrdlrgmtwt
qnsqwkqttdevlnzg[noyxiueharjajsalnhu]heaxmujxhpgjddqur[xnqwujjeasceovnroiv]hnrnwuogebatnfsa
evruuxfhpivnmknolsj[itpsnnhbtrrbllsbo]gefodpceljlvwuahz
ebddlswrvbjohtnkyip[qkssdudizhcoaazvyow]xvnqicorrkjrnxixp
bbmmzbebuexzmtbr[tpzfxmwgamhaikfpaeu]kraaocehdtalyjrf[zzqqtjplepyidohpvx]kzehgejueimxlqglfj[zgysopfdgxtokkdxwk]gwcfaflybmhdgoxjq
xztpwfipuczrtoyt[uwnlokmtopkhdtemm]sdfmvgvctgwbdjpmvhh[ozjpkdigpjqzqgy]yrkwokmkrevauzroaqm[vctyupmildfnnjomue]cvagxsievhrukgyqzg
jpmvqhuabqsvroxgmyk[toieqxrazxhhsbrm]wdwhoqdddwdacuo
mlaqnefjmwbxeetyxz[sziklwesunikpiqjark]iltkcgfzmhvusdnlr[bmfprkswemctykvio]hhsmvppnztgipxij[kvlbovfklljaumwmy]mdpaiazrlputabj
czdgmoqwzhvfnulxo[mlbkytxjhscsxrgchri]veugcvavrzihzencp
rbjtyudgcswzezr[inlznakcutfnnequc]uhisbxotgqqtzionoq[hzlgqtkpeubvudi]qqsryagiowmcijbejhr
wkvwdohwocizssun[kimsjrwwfpilzpkf]ruqhrplgugwhmnn[iouhwbjnqzlqyewxof]exjuguxwmphfypvsivl
bcnuloxdfhnyesgtdky[hvmgfzcjhhiiqino]sfipughwbebgstwrua[behnamammdxrnnok]ttpbmbflilacfvwiwd[sosjbmmjygpbfetziv]qcosdgrbfdsgqqrlhym
fbmthzppxydfxiipo[zsyfzbueqoaoxeueado]santekllapuywlmwjkl[yfsonktbvuyilcxf]xjerezinsamruvn[cceqpogyrsztadfap]fiivtuyynltqoypypou
lfjigofbbnyrdlhxv[gfblbnmkfnpxbio]zeqevpmpjowrxtw[mofuoyllwekzcjtxjhp]lnzewigzwruzlbjh
xjgdfbtgqmgazgvtif[farekeencwufapef]dxjltmtfxuiydactuko
njaolcljynwvrwy[qplxbpadtyndosjcch]fscxierutuanappsqiy[jftravlojauqkmgludp]pkfwxpdfcrjrmbucf
iyotvokljqynxnpjsfs[lfwwocnwcwstidfpb]mutsdjbqfruxxprzrnk
kpvxcagazjsxgagg[sabugyxucglnvcjb]uvrdglycowrjddy
zclgitkurpfdspcbk[yedvkzgbawpthoyn]dhvnmtxbrpttrdrio[drdahsrphffqsigrlmk]ykghbvcdosmtcgxdeb
rkmajkdvlbqwtnuanue[brdlutivdnfekggixum]pbsgstnxgghrygqwpf[rlqzaflmkbvvefdoc]jhbtzkodsfglsaow[onlllmfziapizsd]usvejrxmziulunvjux
jqlketojwcgvuce[ftcxdqqebijrnfzjriq]ucwgiavuxrxokmvxgad[zmyusreluasvwgzngmx]semjnvafnqvwtvkimy[owvczdccmvfohtbijfu]dmhbiikbzcualbbs
roewzhbnwyvondnn[ejikyjgtzpmepihnnl]yurjuztavzqkxqlrle[mbjcyqrzfuhhsnipzx]fcrtuzhrqorxrdmrcn
ycznijylnnqwmqzdd[ycnztjgxgyapvafhwaa]pzdtesugxpchhdb[sdruhgxaqpitoxlncc]exnhjwmnvqmquvclhu
iufdjzqflteyvhrem[eqiluhtbfuegasby]ikqccaxrpnjjrevdsev[wfluwngzffaxhaflbf]wnlyrgvaxzsmqvc[smkdicgtwwwxmdizdi]joaqneodtgvioxzg
pddsupswtnzture[pehcqhpltqocptr]ymzrvibfbeasccxh[jwwhastouxzmyhh]xsllfxcuzbtciegzcd
rnnvfdyavlqnvwze[aistrderxrrojbsspnu]hfkzgodowrlajmmeq
qnebfycqdylighjpgo[ablnwbutiwhdcrmwbg]hnqeseogqdsdhith[nmrgaeenxhizhoqper]tjxbhutvqtjzpyzh
batsftctktgebkvzv[rovosiyqqpafttgdmoc]ynnztvhekfnexdcuq[lnevylboilqebnkf]udftgymwddomqmy
ybrcyivzafzoubcj[crhigqvjszwqflocc]aesdfdfgzcnyxsmzg
oskvnzcbuyaytyixp[ypctohskpfoxhpydwpf]kgkbxhyfncznsar[vulxrgolpxlqzkknzva]ightbuekpmjodxzfky[nyjpxhpycxjrqdno]jhvrgxgfjwarwzkmfj
relqdjmixussrbijgqj[mfsyrfbtjbojcesuyw]wsckbuhopguszeh[unyhvpqjxxgfbgyf]dddjalolfjwliasyezn
xahbldxnvsviywko[ucmjsyoejvcggbtx]prfpnzzlexpolsgsmsf[bgocwabottcqekxs]ijvpreqlfejnqhfbi
qtcopopjmmcjlyfrtot[dmnfjowrhqtqhevs]pfczfmefcnnfbxiovzj[exoentzecnbfjsy]comgdcvnlyaemmya
plhhfkjlotvzupi[ilbcfjbrxuildya]uuvdzteoijumhavq[tcuesohvzusidbgpw]hdsgdngmjtlybnas
yoifccopobbguvkytps[xhkzrdcfsyhpmuujbt]ocidhllwycinggwu[kouoyzxtwiwknduclv]wkokzcbbqvjxtubqg[plgujclgyfmafflyurt]rpjrpxriaxyinneajvy
jbmiqrqkpbjasqhvwcv[zlyzpnhzdtqiorod]dkigqgjtzmpleja[ijenfaygzeceopbmxks]iwzcpoekmitcckbxbzr
zixveaipmutzulr[awdlukrjbyxtssfksb]hreqwpgrawaqwtqpt[bykxrwwuypetebhs]xhtujigporvkxqot
cldscqwnyjkrzvyegsf[zwsvoudppoalxeja]dbqrfscekpmhmpoellj[xxxpuyedbyuihdzdf]bmtfdebklpxvuacq
ohdqlkppqasvyrkkjm[hevshusrmyhuyyo]qbmrotalialbvje
nvwdnytzqwrugam[pflhibktydncffbnlva]lguqdlkusqqwovr[bgufsrqjnngbwxnhuco]uanvcpxragayfoj
zkvrrzmgitfjnit[gezdzgcdvxdkxytcq]avznjhxyjldbqpfoua
mmyxbuoieontkaxvnk[lijzkcghkhiryhceqc]zuouxoicowwkhklyp[baqxxkavhepnpepnj]jcdekzxrpfucavdq[nxrhabcrumlshoitzba]httcbsbgoyhjpkv
hpzoxihsevceefdjv[nxgkyykcfpjwtlz]lkszzbxqdrwyktr
djqunzvzcyxmjqhy[qapfiyujulhgqipfm]htqbtlhlsqxnjyply
lilhndsdretyqjojrn[oxrhvlpgqiotmvruvh]hgdlazecfzdrmegmnw[alxxixmnnjkyhrqjgh]mpbjuwwcyhdfxynyk
fcrwgutcgcqizev[nwszwhfvqtdhrymgqf]iiahiososrpdafnt[gbkrardsossgcvu]fmudukrxbiqyrpi
xpcgsvaeydonptb[ewpsimxlttaeoth]gersjqmmdamhikqtv[sxyvukeegkkbbarjknr]sohijvshdnoawujw
vnjkhbmpsmvxkdt[yrpltayaihgspvnjxb]ivhwkahhjjlwzxfpz
ofoancxlupttxku[hkedaqsibrvtvqu]zkssllvuecmgtqvs[eklsqwgwuhucbxykl]ioompempaewmnco
nwviejwlkyokiqhuvo[csddbtlbfdwtakxlmss]fxdoqlbdjhoslraj[shasfhtvpcsajdsmxfp]errsdzqcqzbrfnkeux
gvmytvlyluvnmemhgjr[bvqbhytqwpyemefwo]sygljhpvyjnuxzjqy
zootaoveazcrmtbda[qlxlwntntbkjtkqve]vffdsbekufzemgwomh[vzllvqlmloffyyldfh]alltnttrzqrchacoiqm
ksbuxsjkmtzsfsy[shracmzkycsuqrei]qrmgsndwzkqhtojsn[innhjjhyfsffgsboglx]zhwuwgyrwmucjfii
dagldnrnugbavjwiiq[vrsiyprmsvuapxvn]piirprosbofdwzuuhn[epdsrdcpgzkkzdjle]jylrtjltlmvazfpmh[rqqteknolbyzykdysvr]ieejzvgtumekqapi
mtamroysxwglblwmjn[gmebbprtzaogucvyzv]tjzuzqyyfuihjubuzu
pcfbudkakpzlyou[zznswrvmytntytfkt]kvudoarqnyybzeddvn
moelqaykzlstyntby[qmpxihbeysykajdo]omqcjgdbuqvvydd
ddyczdjdwnoacci[wpgjlohduqnlrifih]dfwcghvsdezgdixnpxe[ohhccenoirazgekq]lqtssqpzgusrlvyrd
ewirhlfcfhkqbvmvi[ixrorekrimzzkckpel]ihyukzubvqdpnmqpgu[mbtybrusfomfdhlg]ucrcmbvpnjbghnxdo[lyajfieycgiubui]llelwgnuopqhjax
jpltuunwbrijwnudg[ejxyrxniclwnqxxnh]krckhlysnmqahsz
hkdpdpshmftvxob[fsdhonsqalgpydpub]dirxpfxsxhpxliqg[tvbhlcqkymtbnytjp]xuvawokttfililgwgue
mdnmunbnueofzddapl[wxfahokzfixiapig]wekvqzgvufgztlgldh[zwglgerouhvhtbrdib]xeogmvaqszvkdvxv
mbqnuqonmkxmczjo[ueqnkvfdskaqwesufs]zmoqtlzfcwqaxdnddkk
qoaqjkdsftjstyjyqd[fyvizziweplccjt]ryvpqznfcdvjxuu[syspurpgsonxbbdrcc]vvedpafqmoeugwuize
ctdgzypcrjqxirm[ouyjhaohcueqwdez]kroowbthpspnnzgzuau[pqijczlztofszvdzhx]iccbpchemtflqnhdrnw[esvbnyvlckqirev]psrquqfxaotuzsojbt
rgukaurlmsyzovie[noclopxqrusykxpix]zbbopbxzogbeppp[anouobvemneuuztti]rpnbuugshsxxbbkhauq[zpqywyyxjfabzyppw]ecdrhvipvzregbgl
vmbtrbtoajfkswgy[kailajjwltvmwasynoq]goxmpryedtsrgkx[hljqifnoadoljqtub]xucplzmspnbxvliaap[tfqpmrhbakiidoxwa]iceqprkydjgouemqsmf
cvpnedbnibipftign[cigxthfejgyjzvspaam]esifvgljjjbexwm[uspsplcqhomoszleq]qnogejwqjdiznyfellc[sszzsifsfavntyghfs]btswodsrhcrrbodmtz
lvxwpuujqxypkhqfymh[wtizujakvxzrqwpols]jffeswrfpnhhakyhwlz[lzyloeveicgwixnvdx]uvwhpnjlszclssbf
noblqdnmgtyjbxjq[chxjibegmcbmljibes]edtgpajthcmqgpz[qafbzkjfqbjzilzh]aorhwssnugyflolh
hunicsoijinxshpfskq[lniiseazhvpjiyg]wirqusdwvaiyatimhx[jntjijtppuekuvvzz]mxebkmgiqyfaglow
wvzgoeqwcuudhjlc[nsjqegpxfiwvbtyuo]hehqjsarzkbbidy
ncjcjhyagdubxcibe[qpddbjyualjarnnpkf]cizleaqaaewqysxwys
jqslpqaqntewoglud[xtzdawarqxbigpuf]qnxdyobxvfsrwoaz[snegbwbzchqcbavh]kipasixtzznhgkjskv
hptaschabsnqdgmuzoj[satvzxkqetnonungbjb]gqhigqimupvihhwy[nejqgulbxtzfjbjlya]jywahuqdzrufxenshjj
sjgpoxxqtfsltzk[jqwzhblplilweukbso]tgorxisfymrcgyr[tfbebfnnljlpcfeps]ahpjfbonoajtohthzri[tdgaokthtdhxpsg]ajcykosmkhftnrjqphg
tnwtnvvrpilvadiy[taucexvsohfmaxd]cfhrctuhgqwjgtll
xzzmvrhyhwvprzczwz[lnshilvbyfjqgff]qfkoodzijhqkpuob[iyyvvfibosnuwlov]fhbcvpuqvpxmlolhry[osdmjplktygtobvt]msazwlubhinqvyfh
wanhwievduqinfwlcou[uyalesnoaqmajcc]zbdddgzmqprwiia
dfovljmseevxcfarf[enpclythxgepfzqcw]wechankwzxxkkutq[mvzawbhttzrauulkxvd]emcdawwiunjraebra
sylgfxqcfrqgeeuh[dljwdydnbuddmtdgp]fhenkxvmwvdyaukaxa[xcdbxlqqfgqtjyhoi]tbnpjbnpoxxaxef[rlnmcnmntjlitsmn]vkculrpgrmqsrayre
xexefhsfpwtpxuygp[omxfywhnlcapmpalz]foblbhtxieggkgpcru[lscwcbkqvexwzzbri]ipjoiumgoyugfzq
hbeghglpgqnwpxqio[pcujpvhzhghnyjkmppe]jwcnwmqwctqgoxpj
apqmhkpxrtrfwulqbq[trthojavkcrlcgc]oikizlfqpukeudv[afgmhbusoqjubra]ajbuhxzuhecopcxm[lowqlmwiyvmdojjla]jrrhjmopywkqrhlgicl
dxrqnbrkijtvmkwq[dvtqzljjbreayipqgp]erhjjvypeyramuaab[cjedbzbceteuydrps]kolgelhdemrbeviu
gwjakwyuaxixflozol[omjuyjzbtditgoznip]nqybdawthoydext
lcdwaahhbhajoai[cszvgduipwduhgmo]vpsgnhmtypusbgmhwnb[qitqpalswmqvjiu]iyjenmmobfasnzqefci
tkxizzrgmsxvmrdawsx[edbhkciwrqmoflyang]nbuwbbspldrfhic[guhvpvocfyjpwwclv]olxhqqgrylvzzqxxd[cnhwdegsxurungopo]rdenofdlpgilpiuvmr
wkadrydzokfmuiah[mihkmnzzjladulkvb]weqzktdsbwalcdijda[rejzrqqdtbvrwgbgojt]ggruyvfdesfdwenyx[jjyyleykqeskpfmzl]ssqauxmvzygppvncz
djzzsqykcfbhgfoq[frykddayaohlxmkem]kawloxhrgcpronph[xxkgjvdfespwmnja]jddmrdznkctmsmaxih[uxotxlcobxfemckshh]irmewesnknuknipl
hzojrovrbmfobhsau[itboujfkrmpgjpsvsr]qgczawmbunmisxs[dtrvnzrayqlvdpyzbuy]wrcsquxgcxpvbwwzlqo[kqbfajfleopglhfui]bsoomwrdifoekal
cntxerwyrvbludhaa[fclfiyjfekdtavmgy]lnvvlflygrewrgswx[juijxzrpwfrmshbttg]yjeuhzyjbmbdslbdhf
gclzrtvgfbqqqcl[fdkwmnpoansxtklyusn]ywwzqahbabjbcbzd[kuiejkftwfuzmjbiify]tabpjhaiwzcdnzvof
hmshguykeqstxgzs[fsnsxtrvkdyrlek]rkzkooteryozbwmda[jyjzddadewtuaqulp]gtprcoocgdsfbtduekc[llfoixzevsmexhuitz]ppiutxxuvaxhzgiib
ouvpvcchazfdcljaux[kxqnkynylosbuekz]arsuffkkpzlwuibqd[lmmxhndkoldfbtyfpw]nvcrjoborzogjhgwn
ojesaevpprrzqaksixa[ykxbgapdjiulhmxgihm]nrxxnhdwodfgqoeproy
vzbltcugyxvtlxqnkxu[fcflcasuyaljgewcynf]azqaltkfsglwgkeh
urcslegrolaaalf[grobiijzrtgpntne]uhpzjqkslgahpkehix[prmevyrajmgfhsjpag]kwfhbrhzkojqazxjocg
zwfeopovkggasxxb[fadbebqmbxwktwfdeui]ftomtaogfvgkkdrkc[rdkdznntsigigjiv]warlzbzbnfbjjsh[etjzyzfdjztsfsyi]dulnqfxjoewssxgkfb
nvrsqzcyguparczn[ewfmgkjaibzjoiex]kpooaykofbtkpawayfh[ssuzuankcdhqvold]qaeuwxgakqvcugn
rnlhwrnjgxwleghohuz[nktpaaaciwyfagkpqw]yeyzojziajnryse[bmpxxtaljjigfiv]ojzukghfhfhykqrcdyy
doqbqcwjoldvwtws[qaxghysnphejfacrnkn]iqyhfkjogmrkjpk[hfjqxqeuzwywwmnzj]uzhpypjadzqcpeibcgc
kmcmhdptzlhgqui[cpluzrcwihnwxrsdoj]czbxutspkzdwesrc[fccnqmeaqfmxtqqng]fitsnmdmyzwsifevbat[fxhgcmqhxrudtnleoww]yhxgwphkxlzhxzjnvcp
tmjpplcwhmsaxav[epfnxqdzfpxmaztdqn]vwdoatnafiotogpsxk[lydghxujguhqcjqtbbk]mtvqsesoxvybfrxyoi
fslvgbiibdkhchajyb[zpbhqrokrbfuqrowop]gqqzoqvfsdfcjcdurrs[xhqfcfytbbekivnvod]jxjwuxivnyhppvfhaol[evfnrmrjnnhychtpv]emiyjcjsnojxexs
gqaygymjihevbsps[iepworrljuepufyvne]fzfjulzebpsphczby[kxaohggiqnjpdbf]bsjfluhncewudkumaxj
mvjlhovwivdanexv[iaphahshtwtnhoeoqsk]syolycabjeiwtwtec
ikhcujftlekmcnmcy[ubsoslmlaitakaqb]ruyiqnoobymxiim[ppxtpuphuisxnqumd]qxjhzfwvixjjmfgaqej[bdjpilcwzhqphfumpny]itvjttbjsbfmxppif
xhemwtnqvfankrccdtk[bbjzsytqxhxcgtedp]ksfozdggjvyvpoyw[tberajbwhcirnenwv]juojuogrifenjsbldn
bczvqdwkurvezjxgrg[yjvuwvfypobetomm]vtfujjaergrizoots[snwcbtqylvuhnxyvb]turadiqlfjvclpvbweg[mekdlejerxpllbf]bgkveafnrceyxufsqj
duqeascyrgxyhlspebo[kzimyrleaopbbwmbi]xsxqyleqvoscazopte[debdbibiuaosfdyioum]vjaptdzpitqctukwhf[jffyamdmvkrggbe]qrnqpwcdoditjixsc
cuxdugzthpcubgw[qjvtzbgagyebkobkhf]tsbcghahxswropcgj[yenmfdvoxlqekjsk]kjdmhdgepvdoovzvg[mafjriyxqtotmhxgvty]mdyayljihzqxhiga
ehkhfoqcdkpyxeum[xvjaglxwocodctbzj]osufidsaijsczhtfg[rvmapxxierwnjkc]pgshnzbphxdoaitou
wagqtjalswmbehwmuwm[oarjxyzwyhxzhpgilh]qapupwvuflcoryf[hmqhnrjiahzdfbaz]kuprvbaykjhqagnl[wfxatijeapdinkt]hadtvdjbkdduycdut
emfkovpbnkaxykrmwjg[otoxyqlkgczzivgdt]nsvpzdvcbsvrbpo[vdfxwihznfpxlbsju]xbcniikjhgzelav[opidnljejcjawbikt]gedgtkiksnpijteviu
fxbpujpvuboflfip[dogcwovzlakonhdyww]tkzftiqvyzumadasjtu
rqtkvmbmqtdrqsahsdy[dhaassflbjfdslopp]zetcyybbahysvheand[uncbkqyoidhvxjf]mxqjozeotsollwolhs
pxfqsysywqfsmername[yfcktnozutkhniqyp]tjzzakrnlxrtscena[bitenzjdqfopqevroqo]zujogbgemdxiaven[dtxlpfkysfcivyrxqt]fsgjjgzltbnlvdojqvk
guclyozvgpvbuhktwbh[qmueutcpmdebodbilp]vglsdvkxogzhzewjpl[guoovyobczavohc]jdguogegerfiwrxthui[hdcvpajqgpsoxuoawmz]ztwnqkdjnnwazrdzpc
llcocydhktglycn[aqvpbqqcyyjlfspio]bfwtqbvqbywnhvn[bdkrsfpiokzttiazuaw]kchhszhegdhxega[mgfuozyxaqcxmillwlx]mzcerkylhvawvyujx
jceiyppxbreywlqlc[fizmzubzyefdntbmd]bmholmqrninpjuux[wkbshvxwlfhlrpkbk]bnqhoqtiqqpsibgykwd[ajvhuevpxmsrjrdwt]ejcwhcsechltmxlycwv
lhzgbwzjykgdqwj[ksxhpuzyromwycwqtmi]fqkgkgvjfshsltg[ypmdudbfamagwadtia]nxqvzfdgxlwbbkrssc[zqmfrjzhsztnqbdgo]dvzoywqsqizywigsqsm
vvnbnhvgcpquhzbarub[ufazesxvliazvkcanib]agtuglmgoxupumcispr
mtpdvvydctgradgywc[mtpimzrgtmnlcge]vxbxcxjkpticzboc[ffiyihkovkviqjifrnt]yhxctiahahicybqti[latcrvinlucwkxhmc]ajivvpmxwiypcjtevwh
dpnjvkzcoyyzmgvvs[gtjdsruwdhyukkx]qndpbpmhkdngjmab
raugsxxkqxpsglitbj[ncskiewbnqnhxvojfx]qnqtemgvotsgnlgxyb[exshfmlaagkpxueykd]vgcwastyxsoddgu
vtmkqugezjlfpad[ljdytmxdmcfjvqus]zwkxtirtowwwoqybn[wwbggxlelxpmctsyio]ojizduyxsklhvogj[wkjkwbzdmusrmnwuq]dnvercuduocxwzzqvc
kcuaibmbtowdpkk[behnytmljmvkfzjzx]vwmeazoaavjnyopedp
jzmgdckgiwbhbits[qapkyzlxkcinhakr]zymyymfbxgiypcn
kbcfgsoqgqvurokxs[ygvbgzijbgfeylxvl]xsjucuevvfddgod
unfolwpdrbsrzgoo[xcskhiayzcpeegqfoe]sqhinsvvbcdboctc
yclpzeggejjnvkssg[jaxstjrzmutqmaqq]buvqcwkayhypitxnmp[hpxwubjyepaqhyhud]qhqlpdiqdhhgffsgtqw[ijhwhbvlbixaeywd]fwpyiwyrgoquoeuicxp
jwgenomewntwyxiawpa[eqcukoqwwwaruuaeoaz]przxcbqvsrozygtcyl[krwnmcxmgcgfbvkj]pcifuzymidokmsecl[wetuprgdinttljgam]wiiixvydbevhtscp
vzuukbqyqsivwpeeygi[bsfyvyrjgidexcfzq]wyfowikcidviqqnzcw
nsvfdglsbfbwlxfpfs[hdfyjgnwdgeropdfian]gznlvhnfjawhokhugz[klxeguqtsnydunmtj]gaauhesdugovoftjb[agqwktizuxyqgbvt]zhbzbgfwnkahvueja
xcnkdghtgpxbfefay[iekwzcvfquaynjpflf]rfmwtjyxputzpsgr[rxbiyhzboydmvufaz]vbibxkxeazvkbzpnrqv
efxnnxokdpeqbimle[sygsnwvurqpxovmfv]bfkvfubmjyasmvc
pvyunauqgvtigep[ypayrmkixxbagcbawlh]gsvqfsxbquttcaayobo[cwanbliqbdzlcur]ckdwzoeeeldqnmpnzta
uaxiegivsmmvixygiih[bwxhotmjiqmiffwt]ifggldhrjitovzh[wtrrvwjwudasapqdal]zegculmtzsyaxytuhih
hvikzocatynjoxxzjrr[yowwrajfokqlojraj]gvquwhdppqvtcvd[sqcangyggkdiljktl]fpjugbjlanzohbvfylb[fxdhqobssfucfmeaz]mzrtcejhidkqkpqc
lcgelocktqpqhjgon[vmfhipgnrbypfellki]bqgdqxjnlynzdjogpbk[ppgoudyairolaaomp]utxjqpmjzchqdhz
mtfryyrtmzzlooy[qltyhniowpskiqmolx]nuxblfnfrcqtjqfbzi[bdslgcpqyowecpp]vlxwrojvicfzzzfb
widpcxggzgbkofmmtkl[bhvmncpisdisugtk]azxcnslcqsbtyufnt[lqwxnibqiwuwzwkf]iqnupikuhmhvvhf
amceoqorrqtczywlb[znieihkpkxkvvqxk]rmoexicvufbvzrcxisb[nrrbalocuvporahypgm]sapytlndnufcmsmnl
ldbwysbqqkcizwlkqk[kxbcvzlolkrtyzou]zsqlgwgtcvtkmrc
bejhbhwlnmysyqgzk[gombhcspwwomoqoprog]zgwpzkhgbgaveqpe[kldisefosjggfqzo]eiyzwmdoqqsrpekrs[yoblfghskpxbimnq]ewghiykdpitzdsydl
uxdgjfelalnofqouoee[obhlfmbrcdwvtgs]hgtqhblpsfyxxdmruq[amhlljtgsqandpxg]uftttypexliymsri
xwcoczwpeprblqvdsze[fcqzupldpqdpibi]peaetflnafpkrqz[aibobqkhvfzpwaajxj]mzlrkrfslubibbu
fpofuivhqvybvczq[zbhaursvrqknspvj]zlovzphchihqwko[bxcpnqiijtjpypqk]hmdzgwlnervibxuz[hxskzadaiwuhkjrvia]fqtcewytffzarnbdid
kqzfapnhrgdwnrxtwcw[keiqggcxbtzwrcvrvl]itnkudvtbvfwlcvguev
folpqmauykgkbtb[sajzutpltmpwuvzu]qgkgeonxzucthfluwfz
qiniyhvlxrpcbscgf[mmjtkliysclrogfxsx]snxccrqkeuqchwfi[wbbptxydvrbgemquc]uyqttlcltqvqmhu[sawrjbeubszmuwsjuj]rowkyiykcizmcgha
xafcvdeuuhyxixxn[abpngbyvpnkmojksc]anahdcroysddmoxf[tasztimgjqwkkic]fiycikeddfoyafacbfl
fzmscbkkolwovgnjeb[qzholetigkxxmnmkoc]ffztdtemtdnustwuu[zjrqslegqkywtcaqod]qdtqbyfhwehdezedf[qqvslpytqtjuzrkc]knqvowafliildhqxgex
hicsgtpdpugetplbufu[lzlwcptzokxrsxtrl]smxnwfvtzttcsesdu[wmucgluptdavbca]xggqqcfaxxcagagkx
hwnfzlhdbchsmjwaytr[xfggqnxtnpdjzuyqm]efiweqzxmsxetmyjnhc[mgjnkbfmmvyrwyocr]jhviqqnrgzjsdmidsjs
nvouetegmutetgw[keqvyocxdetebkcgl]qfhnyfdnjqnklpad[swuvsfhrnzsnatb]zjwqmrmphlgwdnms[hdlfprihcbcemfn]lrraefojxvtpxljil
fowkqklueytawgdxklx[pmrpenfrmskqjttdqiw]ttqjijvoxxfxrrdve
nsyzzlnqjssmirvejh[gpqbubkrsqphkdjwg]gvzcxqgbvhopkgy[nzlfaemkjnuwvhul]vxdiuaimpogvtkx
pofmqefryoxboubl[neoxktodwrswfsxwruj]frlrumshrtcllqqf[erlodpkifgfpjlbl]bbfocfbyqjagesavoc[ajasttvajmlfwec]enqqcyveejcayzw
rqtdsfpdgwrlmfj[nmeovqshevzueyvd]ibiplfpvkyxvacl
wtvwzmpwviqbzol[oqlqunyszsyebxbm]ywqypuyvaiegekaok
ijcorxkdzocwisjb[qvcjrwytrzftjicua]buuniicmziszwzikph
pplaiaulcciebujjsx[hlyeskfzscwmeqss]tuuolvvbnyymfmo[trsqblvfyagxmgtwfk]kcigogbmkzsjlsrj
dbsqyxlovoghbra[lwqmeeclsvfsrezsed]odqamvyyhsmctpqegav[xxoamahurojgqse]tngvfzhoprhrxsccgnu[zwwglwyqrieusmlfmrv]tzfresqfmfspigfeo
tmnutczqpsydibk[skiokxeqdgilzjq]rfkxwumjpjulbkiz[folgircuujlcjhjqxa]snhsgynrkjecrsu[vukuvrankaiilqegzup]clzyhjlcbrfdbjrzlu
opgifufncugjrflllk[epkqgmpkzdijtdedk]xmvotyghoniyalmmg
ovtwjnqubjphsgapb[cnrcpnxrfclncasoeka]duqduyvmbzwdopyxp
imtmstorxxvbvmz[muklxeyazsgitgb]sjuudyrlbxgtlph
zbnvlmvzeitlrvclu[rwlyxjkxlvgeyfzdl]uzlfzyvmybjonpqay
cdxryezdoiyoopuzgl[rnmncixgvbxromitr]jgqlptcrlpzdrqh[sstvgpzcldcmoslnycc]cyrecvckpuyjqifsuil
acjvnpfqosyvnvzbjyv[tmnczokfkjaxcvwjo]cszegpeuzanwadl
knqqmdktrcvcikcfvcg[lnsoisfwtfpizbpo]xfxuxthdxsekjpi[qsroiaojvihodgq]jaamntgiaqvdasnz
mqefdyhtbqynychpbh[rrjozrtcexpbrpvfs]dotleanpfblcxfltod
coayqpuuvtnwmxzhgnu[fyjdjtselprfevq]elfqjzpryzqsyqykkb[utrizxtivhakgjoeryu]ozeuxjmcorkcejprcr
ybbgylmtmhxlhqizp[uvknavcimbacgtcaq]bcmdwwkdvfnmnunyp
xfdywwnnhzqqvuywq[drtdcfuoxvlflptlca]oimttatgiboynmu[sdgkeffjrteokyiby]tdiaadhkqdginrtqpq
fbpfhfecwfprygkwu[hvqikgwyrdwtieahmt]dvtcvnchfsienpasxw[ybkvqrxztwzpsnz]aecndxpzpamjkanchaa[gbjwjnipsmepfxpee]wqjnfjiezpzacmgf
adwjbyiantljqwsixso[wpjjoobofoumdxgrxv]rkvrcmmrlditmjtsh[vthldqtnlpjrqbobzs]efwiuqkqzfdxyhvgim
hbbvxnhhxsvghuh[fcrgvyndxojknfr]twczivatsbiynqjxeby[ckqrjoolqrxxjgejzua]omspfwphybvgiqpsc[hmnpdaumzrmqrti]sdysxoudxhpllkknvq
gfussckpoykcibjnoi[fqnfbkgojenspavpz]xqwvoktikoqyzpofg[xhdumbvmqllllthhsrv]vattqhipurbfvlk[hbebbjewrlmxdblgq]dmdhdbknmkouvie
tupwpbmrvffvqbfiw[rqpefvswlzjnphduk]mvafdoftaeiojrirv
bawbqabxqwpswzezv[cjmoppcjgifyfignuf]uawfxptpbgjnqbv
sekswalpvwmmczwdxbf[wmcngumevhrbffuzwp]tqwvmkfngyrhgknowv
dovrepylcvtomveqe[vzzskfllpjbvrvrkryl]byjsouhntlopqffti[lqxrgcqywryeexyao]qsukbxhzoifswmycw[rktzizqtdvetwyrchc]vtsdazzrpipfcrnxbk
ydnkchnxezkalny[wlfhmxcboamfrry]rmzprrgselhmfbeamf[dssnudvuvyhvzyacu]jyzdefurrnaqrfzq[rnndewpbutqgejcy]qxuganmeckxcpdtd
xhwdvxmfxmktgaz[qfzqjtuqokjeznwalq]ddgmotioparmkkudqef[pkgzogoaxvcwsao]cyebyhigpzgyclscf[qehxqzuztsluyweopsq]tikkkgtpkewkzzkdu
cygqebguktathghp[qlkscioiowgqftpd]ytftmijxsnhgacfmmf
ccuocdvpjktkdceebi[pshiishnrprqohwpt]bubrhtrzuabpzzvbwrv[msdeugbygsvewfxco]nzavazcgkniyxva
coscymyrfqgisrge[oggmfoqevlabvhm]xfyhzwpfzhhyhimqkhz[cybjjylavqoqjyyoy]igzwdivoxazgajmiy[kkxkhfunkpsgyvwp]isgotyzlmyzfqrij
vaezncmuzyyjpeomif[lyvwvohtlkcdyuxze]wzdkddeqkxmqbqet
yxcqysoxpbwjlqjdp[jinwxwcdeflygawd]hgdgruqilmuzuzhsg[ivpimcyrtifudwjgso]ostoopidgdzcrzzyzts[vvaiuzzuzywesuzk]ccmdnuyihasnldexf
jhpygjolrfstkxwt[krdivayaqwfuktykopv]dmposdxasvjkzjesg
lcprcppxkrnwuytdt[wysluivwtmytfgqpks]orlmxnkipofpsdteaa[vroskwwxeeylirbkna]zkeahngpukldeszwuk[harebfdcelqdbfemgo]usisvvczvasjomnjrip
eybojdjnfockfbsdjd[xjxxevnxuwjdamien]frogttytivtegcy
rezxczwcihbkywyq[sdzzflizzygfiovwyw]jhtiwvelkbaqhvnylca[xpnwnmqbaawlyqz]kftcwdejxaznztqsbhy
zitlyztihmeogushh[wpsygveulmddxdzvwvt]auvwghiyvkvfxyzf[ccnkvkboczqbgcmekt]hkqnuaoeffocspxkck
ucliphnwkaxtwgnma[wxkbcziemdvopzeq]nwxnkykbefamsdo[lveynsoldnjkcdn]kluaaaoiqsepyqfz[bgjuhrlfjgiyngwkwgj]ofjimzheftgbbyrugn
hshzrytllakuifsbuap[znsqxjzxbeewshkb]tdiohjkqimfsaijvmvf[wxvmhzzkjopfxhshsol]qgjutmxlputvudf[thwwxcavnensivbscm]dounftyvyaoguqzy
hktpfbzotlbrgddcff[adqmcoiraqbphjpag]fxxdcjqhwkftprk[lfeudfsbvnqjvywynfl]whirlnojvbkpyndhyv[xpypetlsykaucaibapl]gcpogvgqrgensxdeyh
afbiuqpasfjkniuw[bqclbergutdzfdqhdpm]gcgpimwjmvopfjhk[geztaacbsloyevwikqp]jjmlssrsuxmhbtnq
ojotaeydgumtjrfdtam[gpkjanckhqjvfjewt]zonzrwxnucpwtrmqyhv
llkryzvclmpozerpao[gfrhlpemunmdackfmp]fbntrvdilgbposhu[koksbsqnmtfdsyifpp]eswrneaxvurkzfs[ixjekbpjqsrhnpgw]pppbdmxsdflptotr
vbmibdiednxxbammtn[gqvlmbobpzpiuoda]agjiighkbopkxvwakva
fnlgxejzkpocaonnloc[ojrecrvcmirtehjfcvi]mrafnbifqfcqxpmqdrb[obuqfqpyrkeinweynd]qceebfqvcmnowjanh[ejpkcpwkjfbvyjmyzoo]hhjyeulunsuagwq
nubgjzyeuxvtwcc[vlpjhggsyeiulml]evysofvjmwxxazzr[tapuneqjkzgtblgy]gvbvijhcgtrdsybt[sdufwiyfojmptfruns]zqzvbotgmrcynfyq
ibcblmwnlhhftwfd[ajuhvgkyaqeikjgju]rvuwgrbnjxvbcgdpy
hizeoqbkkesksvtjotj[wkvmcgctdzwhzlubt]aegcgfmdneprdbw
lqyvebgqsrsfbcdccps[hygatrvziszspyihy]ratonoqinqfwcmm[pfieelpgzrfzhdffhx]zwaytmidpntpolajcg
admawesoilkvcfx[rqurmchqtkuifxm]tliyyitqauzegwst[zwpbngnlemkipcku]hpxfncvznjgfglvugk[ruinbrosnwmxdzav]adbvgjbxedbmxbkpxa
gpqgezsbrdmqmeihdr[etboranxahpniwzr]woeyirnlebizohoa[rufjzeicrsxgitspt]gltoxcqgcsnvlys[dcvxqvoivyuxxayd]zkxlasittnitmoisr
acoxthwyfwbhszfoz[wphyzlksmfenksfs]hpzmfaofkobjpcdxzs[sncrftlydahuqmuvoqq]ojvuhabayhrsynq
nxtmkatkddomlbnxs[qdqxrwoaamrztvkzq]ycyqxxaijhrpzamcbh[japizeqvlqsmdqygr]xhxvgqmbzgomhsm[kizldaqvytagvviondv]tidqihojfrzvyxy
lllcbzykxbdewnyff[iomemkjmyaqllvcx]vjvnigrbpnhdrbi[ukmffsdgnyqxafwstg]ralpevvmfxtqbzyii
vphviazdmmvtcyc[dcomcirqycymvqkm]meeikjmqliqraeqd
jcgueeliyoclqera[verzkovhghnquyndr]lptflbxptsugmbhvf
rcdghcuautflhme[zngtjffrvagsmdrxurj]mwsuxjbytlzyhinxyr[cibaxfqjdkmdwxr]yikrelnmbneqrsg
jyvaeqjealrbvbvekn[yharteswtwefyedz]wosalojtbxzaujpiba
cdfzjfycznejinx[uhnuxxhxgipoujnarw]bkwbisknvmurfnhp[jwbnvuvlvegrddzf]bkeykrhmjuphuvoza
aalmyxywwvbwwttad[daxeeneiiiupzvqz]cqcjxzindssjrqb[komptxyxwgtnuedefro]xfbjflfujclbqflke[fpatdmophhvpcmwfj]cqbuduaifbuhwiy
kogkhuakigjclxbjoi[yuidmmdeopwzvatxc]qdsbzscrwpmnloga[xsnwctwrdpgqvggoian]yayspjjhhpdsyzkkzx[qbttlvpkbplhagtb]ndnljzkxhgdvclz
rojijwgcylsaspmmrdy[jzptmasniljjjusl]fslcazgojebnrrrz[ybcsqnloovizrxiwal]ghjlkcnvkjjlqodusp
egzqbmomtlqvjfo[cdarustihbcqwpfpcv]fzxqpzavyniyjbfvc[wkmiofpbdcsnbtj]kmtvlxnlvdjflivtuge[jvlzovzdpwxwbcak]hwbtpuolbupvwfcbh
drzhzwluzurvcjogd[haakukjmwslumvgq]cmwkhsuahrqxfae[kugdxfrtkjmyyfheze]dyxxyffqsfctugyca
mlalvviidgseekfkqtk[rmltlzesxldtmsnyn]xdqfkftanryqfqrqkhc
vkajuyjjhekfhmwwek[uuanfibpmdbwxesfmsk]dxpsqnnmrnspifpcyts[ezmjkdjacskqhhbaupr]wkzxoqszqigbajudnq
wmpzatzujoibyjdle[awbuzjartnsdxfqtlh]votzdrynubyfrdip
tstuekiwimhtizzlky[trscvkeiiriseqj]glbwxwiwdqhndmnku
kjgjcnoipwnlqnk[hpukxdqokakrgjgjpk]nvinvznddzuhupepemb
vuawkeimjefqtywj[mgdvjppiouqnnyhzz]eeemepklcxhhfot[ktiuxquqhzrojqo]zcwlowvczfjucqeo
zatolywcfoplujidaz[avcmpullpablbdhusiu]bkwehsbzcysrauzz[tbgkmrwkzqfysfdh]anakunhzskapvmq[cqzomvulpzbizfuqug]untygoozordiywrnkm
ozynyagffvaeava[lvsgzdvrtdifdoxgvwy]pdkwomqrhfolkmj[fhemhaolmihgxlehn]huscypjzuujagfaqk[deqkgecbrdfhskujqg]grknbktwdyznqgrwm
mywakayudrxzofpri[qlywfoydoqmsmaoygp]xpwmtcqqfqsmsys
sdwltsgbumfnbqq[irstsqsogmppmlmkont]lrwnbdnpkxgfhjeo[eqstbbwumfepxoqaszs]fdrrfpfiotaugunbdrr
bappxujhicaqxhwiaoo[bjvhcmhrnldlwyrf]jdxfokaxlkbifuwyv
jlziyvwcuubpsziikv[mvkolefxtgoarsk]tpixifdoybzfwnwle[lpbkitwthyxdbvwflp]eyuzdxvhuukuiaqfp[xcwvlmoqpjnehwudh]sqxbifjmrgwknsno
rblicwlpfezecfhati[aqqhagfhathupym]vspyjiyytesirim[rqjyqiviftryoyychs]voksponpgjfuwsp[tmsccufpnvjdtgs]llptwgpugyjizqfch
admwljcwmrudrrph[rcxxxswmdlllfdwrk]etyjbtmryjxeajzccmq[nivhwmfzjwaspuon]tslmnzikhnbtqwkf[xnwykihihgkletgdy]mrtryzmlleorzwpi
ibgqtdglmjgcdfsycxt[ruddaxuheyvamwyi]neoneshgxmsbpydg[ytpshrjgditzqmjdlz]nlvhgtzsbzoskiva[asuilfpsgtgyftgtsho]xgoevzdtjemapbnady
appgubyezsrmwec[wbqyvobthbuperojt]gqxsjlchxpwvdfvdf[xlndklktmbpjkzuo]molwavhkvungdkvwywm
jusgjqhnjemncvbvy[voitjezdotclvwaggg]ffunuypbjmopbbvoh[lhufstqbkhqxqiworpi]gnhhneydiasvmbvbga
hvboappbxdqyjvxqyd[yukgymhpumetulsznf]hgiqjmlrezzsfndrx
jkovbtabgnbztjmzsoa[flxcmdoflhlgvaio]qjxscacvdykhkxclej[taocvcbcyfrjgcxlkm]aovpiymrcdmebktxwfa[coviwkpdmukcsixdob]trjjdhlgwwkwtegkqmp
ibnaxwwqjgtgxnlax[zozdkkwbccwdbvbpf]dwuzbcgeqfepczlvwo[pmlmuysuwyudzjam]pvhpqtcigtknoqxlib[kvwfykhxumzltcxidt]hybnroedkguawhgl
xqwhbiiflggraco[uwhisdtpaprjfji]dexzbtghefojvtt[nlhtexyhufqeneytdtu]fpskbqhfhavnbkjxwn[gtxmsoydrotriljoov]labmxjlalzgybpdjm
ibxakiwqconeyudxj[mwzjwhmnlaobsdy]gvxbmnzqbrzuorla[dvbreuhggwgdtbjet]hjrvpdrakncsfejis[tstdqmetsguihzdws]ukllrzriimevvsekrkv
ztiyqybtvliidsq[mvhqxpqunpsqouvgrbx]qmhkzbqhemycwxeq[cdadaodqyhjhelanr]rtrnroumhiwdadrbe
nswbgqjuxdygjrihvn[mkznbbryojdlhwee]kccwymwlzrsilyn
sebujequsxstufe[romzdeirdhctzkmemwt]vqcobpsqzelktljh[twewiabushguyyp]mktiojirfewuoacey[tgnliawsrpkhyko]kaytwdodmxqandynomu
qvfoyofzmhctntofr[xcokguepiaisrpwewng]lwwzyewekuamxxlepz[vybjmfsierveheb]bzvvxsdlcohnpmgir
txjecoixmxyskgactb[tvgiyxcbgzkdmgb]yvjfganhyoguuygau[vztmvqrrheqkzasss]mngxndysymgybqw
ptprazbzxzrjpnrcbko[qtdvwjwftefqzaw]ajavbdsfdjghhismds[vvouytxwsxpkttqr]kobwalobjsrwmxz
ucvupuxupiasbzxsuo[hnocitmtlqgttgdr]qghjdvyrttaklumszdi[oyeqkgycqizvaok]xpnaaapzbfqdzvcqhr
vvjibkoyadzluivaen[cesqlbhxmigdxphcr]ztmuzxnzeprichmdsc[daemwvspbbljrfc]jmqbyfpmjcddlepf
ztncnhqvomvfnkhca[ohbigcgrevrnpvuwgpv]lnjucgcpghvtzlrgkh
nsdamwafqwcjnslx[upwtncktpxkvkyhd]smtcegxuoakvjrl[dhvmeqrfgnbwqtd]zwlvwesmxdcnywjdb[whrrgcaujehwqcf]ayjiiktvzvxxquszmh
vnqareestxydfvuvj[psgzifyszldodtw]zkrympmklegtsstov[gblinnqlnfqargqx]hfcchypjbzvbleabbo[xvlxasumenqxcdgzqo]zyhgaickhrgscmo
jqaahcqcjjtinevp[kkntdvvdghnkloliin]zmrsdzabbeotokuz
vnrmthshyygudsrbu[yjvauysxhjhnmqenmkd]jbjlrunbjbzvilmyqf[gnoejrqddyzsdixecs]qipibwxkrnbmdgtevfx
uoqovspbksjvndhjz[gntlvpnmkbjcbsesyk]thzecqozlhmhrpm[ebvhbuhvuyfudyeyeey]zdlhgafvupyipekqoqt
hwilsmnzpcjvpyor[pmphksrtsuqgkdqfyx]psibvhgullieqqwyd[uqesmzorfwbvwgkiu]hlxqjuuflhxlgrub
dzxxmdpesgrpwhw[ohdfatbpppptmdyia]pqxvivkjxrisnmzbrl[iilqjrtayjrvxccs]gwfohsvsvsldpwaelep
vaenounqqmpnzww[duovdncntfceyoqojlv]qttmppevxurnlzde[jhwuqoqwdxjwilrgxil]ehuvfpawjlrzmssbzkm
wwxcidipvnqzxsvhaxw[oivkplzzdeoyqlemho]qthsqnpnbraqqkeyvk[pdkqargzfikxoxwsimn]biqpfsweppknwjvuwx
yefdguujlfuicqqiq[hqlabsggdampkda]tccxpvlmetflxhnd[oqnlgkzvzbhvnzzwz]rfugmbtihisgdklb
cmapvofvmxpioycw[wsmfasgncvdkvjnodyr]dkxkldjxlpdineg[omntdlldszepbdcynah]swcjxnbotrewahi
awbucpjznymkfhjaa[avrrlftouhjbnle]atvuoxpckhvplxm
wfrfilbmvnfdjycnlsf[thxhuqnznohekfern]ndjiygqshnkfehr[jpdgoiqcdevzyrywcp]iuqxgoskimjzasbvsct
crckwgzymgpzhckbgct[euhwrvuqcknwnfwokiu]muiqtteekeqzajvnuc
tljyrckyrcnheftu[xshakjmkjvzulic]mrloxmdpqnxcjhnwh[yyqdzldmfgsnmph]lwlpnskgxbkivqku[bwyxcdoyizqjmfvmc]reyetuasijwucrgylh
zkisfuqufwbhfklf[nicopfmlcpsvwfq]nmwkhlxmquqelszgbe
cqnuuhyddzalcxc[fjmqzkljrqjbexcxxf]pbjsvyixepnkthndhb[xztvuzlknucygyvegxp]nwxzswdvaspdufotcxs[bivsecxgawosnflmfd]bvdtxxionieorvecr
txqpvnrfxykothvao[uikgxsmnyxwlobod]tddprkiwjtdcwbobzrn
qjgftnxktteviik[hsnjrychdzepxamtfop]golzdtnptijzmpo[gfgevfrczlektwaohmu]vauncttcwnozkrwc[ljvbawzsqbknkuktnn]inwckpvsipmunmpo
kqxvmryochlslekzhl[ivuyfsoefnqqtwspxtu]bytaafalzlqvjumuleu[apezlzoaspstxvknv]mnkfbppakmectmiafs
vungsqgzakhfjlbuwig[cgydynonrrgfswomgev]lkyqpvlplfsmznc[kttzkoqpeplpfaoheek]ssijcynyhenhnwvd[hleabsbwqkqqnvdd]xbbxdphvgzmnauj
rxweekbgidxrpbcxk[zvguddibzffxqcmvq]edhnueezmvxinaxyo[mqhjuhujxklirvkm]eaozfcadmhsyfpoj
rcdwnquofraczluzh[gvtnjtocgohcsiswush]gnajmbxnrzppwobfjta[dckvvzvigupevbt]veqtchjayfclaltohjl[mkwsfnvdltripnzdkwr]jhdwksbflywaaul
iltlipfzwdrsmefm[brcprzzhfwsrzbk]dlegyxlpizwtlts[fcqadgpocjjnahyqm]htwrqtzfxoeamiqgeq[utrgqiasppoxrbhhv]hwkrxhaxxtltgbuvj
ljimkpaohzhoifdaiko[dkjxnandaghzxflymm]szzkmlubraphtnokpcj[irrxpfhtabogipufkev]bjucnqsbphjhekfvco[vejyxqrtfxuxeuelvmv]muygwodxspxrrijc
inovovgduyohxdw[tbzvjivtssmlxyc]pimyxafhdeyomgeu
ivahljnswgwewyhhn[jvfdvgftpukjcny]rtisgwgamadavuw[lmwlmlrkckbundmzjvo]eqjgikocnpbjpdh[mdpfdbxenzwycoou]uelglssvxdcxlwucz
zolsnrosfihzzhu[ravlcysbjoagcvaacmk]czfdqdbrlvweyyvbq
vktqafvmirobwwhtr[iqvczcryidfihypuz]adgkyomqrwfucufmm[ecbtnwriqiiaurzkn]vtyotrwlidvraksywke
oagqrhpfnkdvvsqemp[qsjyvadkirmihtfezev]vuuantqauwqrbyzxpev[mpaqvjcfntbdcpdi]ghgstpggptgbvwnmyiz[hghmuvsvhqxvxmmnx]owoulisjbqpndzgt
yyyrtktdrrprfdtbyli[tqbcxefwdtzllez]uaixdyuensmvobo
rginebxdxtfoudqwqx[bvnzfxfxsztzqyyq]dfvdsghoihksjcoccbe
avmokgrhvdnoptv[ngynfydflwspxifoi]lcdqccyarzcasxrbue[navvkjotgujkewhrx]ogzqcdvefknpghfjssj
sshuolwwobwchug[cwcurmfcxqblopvho]ghvtsqgltvvlsahwqpt[skxuphjregpzpqm]epmegfynfypbewftism[mwtakvgutsuppqz]tvapecuvnpedscjkfs
vsqfdssjnhoineb[tmcwmioejrnbdyrq]hlclokouzhvmmywskkk
zuxeupjvtrzzlwezm[gsptwvqfzpvkevapsvq]pvjuezgybonsblmmxdv
dsyuvmvaisuqxff[vmguqxuvvtbjrrva]ivytyfdovrfmzudyzcw[kwgjymkeadjgvdvxarz]rpizkvgpobjriqutyt
rpetcixepthhnydtsx[dvivlhhlgbxftlw]ensdqrwytpwniviwh[uierkmawdkijrbrbb]ywvqqtldiulgtft
iruarpzjrxupbdovqlk[cipcsklubepettbee]jfnvwjcgypepsbnauh[ncvfofkqfotujbat]moqzftmyjreztaugkij
uqqijwordoicegmn[ihceutxbgzatiwhtd]hxqgbplciimactv
kthovdomnavxzkrtg[utmtbhgqydotlxos]rtwopdppoocytum[ptdpdrndjiboffigipy]fwxyvpdnlhjofwjtwx
vitzjdhxjjossygyje[vzysmvvgddhvkufqb]fhwstpatifhmyespsay[mrpnqgygncsiwial]cwbbaisjnqrpuzca[taqkhmlvfdelcrzbryp]kwsdxlkmoplziobgct
iwybfvkucobqwagtdf[nafgfydrpzzdujp]nzdzwcpazorvzncb[niuturhwvakdywurves]txickuysfxeaamhlv[kpiwhdphpimfnmjinua]crunehowomfdmznrc
qololsmsdenfcxmtqxo[orjyxjutzakvhok]wgcgzavspuxtiyhdds
fvzbruyrecjzobgjfnv[tfnighcrmbgeklgaq]eanwrgtehcxvxow[hrmkbicsuekiicxw]pmyfavysbfzttzncxbm
frjvccazhabvndxri[wrmbltymeeoqpqtx]hbyuxmlxfrjrzifpj
nkasezsbfuldeolo[wshypstyfliqxplkh]nsoplkbnmiagngvusr[mwpwshlkyfrxlgcofiy]ycplnfgorpssaitngop[rtplyrqezwrwqhc]houlrclmoatskoufgti
cmsmitcywtmhtimj[pevbzyuhvaqftnugc]rjaxtggjpjvayzmhx[pvfplwswzpusjzhom]jmaurmlkkbusduxd
tshzomvzzouayvevgb[esegiphlwqwlkgt]letvbhxdhuzidevee[zngibooquknjqqxnxz]dtnugmifjztkwjpqd
uuzovqhxwovqeki[ddwwgejprtbquodnj]nafunjrpotozufcf[lqyfeicklrejcwwrvxu]kfxgdnpvqdmvvitzt
syawdtcaspkeubwty[vyxykmhcofzktwfex]fmevgmpetmzurpou[bgqqdkgrojeesxj]lhnvraueoksvtjz
hkyhsguxgsejarhub[kuluosrzpmogndwe]wzqvcpdculcwgqldxm[uybwzbsgzjqfspayk]nysymudwyxdocossgu[usnahkjspekuwvgtje]gtjxtcjsdvtzwmf
jiuygraiggbzoxz[wopmhgtzdwlkyzvfhs]kquojxccygvgujcopbq
rmdqmtbvzoocsjddyj[mmwewpzkjayrxkortj]cznmpvsiqtjdpbgbbf[dfgdncqhajjrohr]kjsivnolfcccyijyd[smuudgbnrfqkxzec]zukmasqygzxrjqoz
zvhafubtbxcnggnnec[khfuhiaikrpowmg]udtuciwamjspaojuks[wlzjqwtmrfrfxmxcfd]plaqjdorfrbkkppep[exrlzahsxksdqsllkn]fooqtqpmnglrwokq
rilxjscompommcmc[qpdxzxqycqutfyj]xvoufpojhanaloymvez
crvrlgjjpprknkurjq[tuvlylfiibnpkzmi]ghncayxzzrrhwfe[atnpozkssbyznplv]elzhtwbiernezqns
yvdbhamisqligavziqh[jcfjonwpgcszajk]xdszcpfvefvmlduoo[vqszbxqazfwgrfazh]geltrpsnlfyzzxjsg[usmmfawdtvkvkcm]wqimqpbsojuimmf
fsgjpguxmrmwxeymhjr[gsunymylqpnrbmiqyi]bwqcxjzweyndcslvxx[rhtvuzqaxazgzhhwp]lqiceppxpscreytystv
zdzsidcfertfbeifye[vdttvawxhnsjirsifn]abpddikgqtsqalilwl[mgqwvkdulrgdgni]bqjuliwrgnvycgnvcr
jrrmfvdpwdborgjxw[uqsuxsointqfsbunl]qosvmfqnyadjfhrc
huekbtocejhhjud[hzglqavqagcxaaksxp]afqncrfalluiiqzfo[mdgrvbtzxdzaztpeg]lsthchkkrvofbaa
lsehhfmwrfuqzewvxkv[rjrryjrjwhgtdifux]nnhqgwmoxdcixsna[wgburhmplkpkrgmpco]hrakazqqsstcrxupvv[mhacbkzqgskhorwf]fbobhetgehykvsbmb
cjmaltrbirusgyoirp[eipxzkuhukkdcdh]iqyymukrkwitywb[dcvtitgqvetxqip]sldydwlrcdcrljhzu
oqpgfzdkcrsrazei[geqerlvxxatddmn]igakhcntksmsttyqsv
tjhfyftjaclsdwzby[oiinbkqwzmhzxeic]ehyliwwisegufbhh[sqmpgxuqhsxnzdi]whwxlqgetakchwht
ukgmtuvowisscvp[nhzgobykdniheamz]ekflzosxwmggiuuudz
sqbsxlbyunhhepfx[okuhhqbyojpkahiz]hhywggdmcojawfpvkhx
xlqohzjcztxennv[cnbtlwijpkczgrk]pwxkxivbtxzovdn[bekntreckjtfkrsihm]ouowyjrzyjbgsygj[cbirdomndbelavpb]ujdrausbmqhnretkhtw
jaowfyulkleymkdpl[yxwftdgbtfzugqnnzwr]ztmzcodybfzmfrv[sttkedpckbjaxmqvhds]fidvanwfqvpywervo[jtludguqxuwucvzcjmv]mfnoqzvgatqhvteacyp
txyjtniwndqckudby[jbemysikizywlxbv]bezhcvssxmbmzgpo
gcxfeqprbvpwtdnrxcx[kvhziidtwrxlhejxm]kxzumooacujxvuwsiui
vvzhcfuecgfvrxrnquo[oqgutuxthxlcxhpke]liqjotlxzbmsassyxrf[colshvmiwbfjansdg]vggdkkyqrjvthtvp[dmozaqtceghrabasafj]lnsoewepnlbqvibyk
keehyqsqydfzlqrqqu[obaslijmtiakxkc]wmrxgysajmjymaqpas[tqwlwdqldidsapjtzct]mjeqlhemnwupulj[xdnkrxbbtlkzeapnat]btxcxfncwhdqlhmh
qwdiosimjitfulva[dhnypfmjunifrhopd]plrzlaakgfirzcccif[strfuwthjgfazeoq]lvhimnjpbpagrozczhn
adqktintsuslnns[mtlbicyrgqgnxuhqcd]mdadfpkvbkvkaimvghc[cvqgxjplvvqbato]lbskgsbvqnvndequq
brftuxdhebezivqio[yukrabpvgetpxpylxj]ldgifnehggvkdtq[pobhasghdmctwcgl]ccevtzwnziffjhqu
ibeocesspzaammu[twfeunwtyqohdtz]kiknftbdbkwrzhrdj[ywsjzyncsuyykqgu]yqbjeqoftsblixeozlz[mmcmncavhecsxbxi]aumsmhzrbxpjqrxllit
hieqiicvqswviniteuv[ubxwceioqqhagxybrl]kikxmdnftjiqazj[oyvdrxwqbljzkjbh]mejsqgnksglqmsfrlf
zjeouhblfsglaxzz[efenlnptrfbopulk]tbdiezqxnkiwmifiyy[pylvblxazwozkdv]guaxwfuktjlovasatlc[blnlcbxxlcgddfquwgx]jkemembgzzxssliiywp
juscmzarbykdkbcf[naosptvhazhfydzz]yflhbtlxgowuvmf[bdmledxprwnfcaflpf]fvjeubkojokjcfnzoo[bmmclnpuykellsdywvh]vibjnjgmtpoyvdw
kqmrdsifaonqprpach[chzxtugxvhbjujlzgq]ffbjsynmytyajcbsyn[jsondannallzwhz]gjrnybnhyxjismip[nocashryyqnbsszebpp]pbugutcxooiznkwwim
vfziparbxeibtccl[efwcwvbtlutmoltmrr]fjwkgsaambdhwvefs[nsrvprujruqdlxrls]ivmnrtvdbkumpiio
bjweouryhlzxnkfj[uuqptwyhasahjmkirh]rrxwiqmpcbwkhzr
bgdivzqqpztnswtd[xwfurbswsweduce]osimciokvwbydgqojkk[yyjvptlwdknyxnzpr]cqiztxdhugywyclvz
ftcvabkblehqjyqtl[txwnhqhrsrnengcl]skhszkrtpljsgiylab
ackokzybncuxpku[xzpocuamnohjypcdq]dwroulahreyhkraojf
hqlijbwudkycvijqs[buaclznmftiadyidde]jxhkyqsoqbpxcjgsus[atcehpnpgwuchfzekk]rvyzujpclugrfyksmk
hnrkcioqaeeqjrpg[cowbmmovdcsubwiltd]myuwiosvtmymgfyav[yvyjgtogmgxxnawpda]saqmtvyakacfwsvtxvd
tyanupyqajrxmuk[bkxkehodeqxpclfebq]kiupgpdlxfvzydgs[rvbbrqbdsolzrgse]srmrovuaxvxvzmrmev
pjbnyjsxcwyhjzpvqkl[qtgofokbciwsszwa]bwvnbcneuvipqaaiyjv
ecxbamdgtlfpmqhi[khvmvwiorzygnitsbb]znripfwspcqgsdzosv[nfhgdavrprmveeexppv]uhzugtmfmipmaznbby
jdoggfnexvkxovwiatd[xzxovisxynejpyxhfz]ciehyiyumbbwwxrc[nozxzgzvotunvgnhhjk]umzgdkvcwauvkzr
qhdaymaijahfkqzw[mbjhxuvbksqtvxwveau]rkvgvfqsehbynbom[keygsbhockgurps]nzmhlxxwjlpjhzbhw[ujitcxihwbjrmrep]cbfpxvdzbljvbfpzsw
wiuprpjfojcowmy[vmrpruwhtzbwyciid]ntbkrodejcrwavjfqfa
ctqdkuxwiricymu[wexourbkgedaqbybfj]revrxjgaoalievfbj[qtvcolrhwgqtjesuvkw]ozphhuwwzzguldf
bqpwrkyhlysqvwxga[ghyqnatqnccegjnkgw]pdgglsmagwkwemidd[fcddsukcrksifkv]cyutddgeoqcyopmm
mxmpasrqdexjpqfapbh[rqeoslcvcwqteki]zpervmncbpfbhwaxmd[rnljbhhtgiyluaaetx]aycxgjfqyxhgeraelo[fukyvtlgjzupjjrxvt]peumsiryqvhwcsutrj
nbdnniplhgrqkrcd[thcyuekybfqraxspek]rlwhyqiavfrfglg[luswlglyiuklvbuqe]mdgjepgjbhuyqkcs
lwueejoqpguiciw[kpbyblloubmxdhk]omjurxlkfpsdwdmbl[qnifmaxwapfvglrt]vssmqdzlxyyrdgkwh[ljslsxolkkivoakh]upwkosogsrzzuej
rfqbvdzxrnrbuhvw[wzurtnrnslhoqkdoaja]vuxsxofemkrjzqkk
pqslistydhvgulggwbi[nipdejpoxqfmbeft]frepgyumygqywwycjl
excgzlqtguboybi[guywktnzbmkwqrbp]qghuyihqlgjrdbuljs[zrkzhirafcadgqnifuz]medyulldvxdtpmqifpg[lsmokycxcicnxcyfpe]cobezkjtvpuqyqu
aajcheqlcfjvktswy[lsgbzwuxqcbgicd]skvwyyeawvlzzfp
afnnxrxdhbqqixcli[msrrsiakxynnwiard]tzanbapzvxtabeuz[rbyqhswrxrofedlykg]phyilynmscckkxgbhks[enrqxrwqiotksdor]phnmohcaqxspqhv
pjyiwunebggfgpgsk[ovrxnqwfhtrjoxwi]lmkquysxzdebvarwfxu
cdztgjverhjafgemi[aogtmpdwqhazrij]dmypauxszajopbp[sdsrejzmjvpjijq]okitpugefdhpbfnzs[jyospqqhusxbhfuuzp]btfwfpiblknocxncj
djgkwjxzxrgsncwd[iuaqmffmnfklkieaq]agtkftischmbszqpo[conozrxbpdsuonpvx]mflbagusvgzybhasrlf[ntidmtstsedfdbfwost]igffrxgipzxzzyjy
ahfhhpqofpjyshcus[lrxchnknzrjtzkgt]hvtqhnuzihgxovj[wbnqnjjnzltdyvxswv]bmppxzhzgwdsckuo
ghwlmylxxuybkpmo[bkxcurwihedpwjm]ypkvoiavnzgzlkahlp[lnxohqbghwsnbeqgk]vsegowbzcrqwcsgy
whzaoswycajecyuw[nwzgcizbidljdtoull]zfyczyjiqsqxgzsjm[nfkpyfcjwjijtnb]dabgzqajwpzsczrfzrl
sitsnxvhgjjnlitqs[vvlbonwoskugqxo]bqitwdmlvnlcziltj
avgdblmcidneynp[gkjdefhfakqungkij]eztuncfdkicjhaytdzw[dcfldbgzscsumjox]okqkplzsscszdsxejso[yihmpxvcbnsofchozr]easrxwgppwzqern
cvefvhycaorfsfbmi[fkvzdrremrlrvdl]cfcjirtcmdphvfircx
wegfumofnzigbnhy[oqkrudppjpvcuvr]fzyxsxrktwkgrvyiwz[jkporwybtotanposc]exmwkvygccdurwge
iqfavtweexjxhdkz[drnsnxjziacormb]yftyjvtetmuvwew[vlrdviggcdfnribze]xzykwuzopkedwfqjxo[vnadxonxshmwhvk]mqbtnfjmhjmfdftwm
odyopnscztauzvjvbfe[zpgqzgzcqclarhkkc]lfuvvhwhtlypbfv
ogaqzpgfwlmdrjgo[abvqsomptscdejeyfg]rukgbtpqwyyvnvrdz[bcvgngjhgitweuc]bljvftlzomvgvmlkzsd[yhpnqsmblsnfgfnyv]nvnkvwwllyygxcdnef
jlbnwewczmvtoshkwk[rmtpjyqhqxturbfc]ulsjqpziwqfjccmdpgy[neunvaltjjkcxvf]opuswwcrtqbkqyq[wzpxgeaohprbhvamaf]ybxisfhszawrtgsj
mmrbaaqjvgpshmn[exjdqzgpzdalrwmtha]qrxggoccbehivaiegs[udbyzlbkpvwfkaot]vfbmvytjziptkyv
pjtbkayljttjwyztu[clbiouysqsjbyjguhe]srltvgtetxcbkud[qnuhjnuziihtvqtbeyw]iccppmvrkzyehgiv[lldvqxdqvpcrizue]vpwqjhbktcmiyed
vxqpmalvgeaxtkpv[elquojhkjsxpmks]dqvuljielvjopjcuvsx[yoklegkajhhpatv]cnfivppgdnkjzmrr[vnjebiwfefjgqzle]aqkvijxvgljbxmm
lhkkzniihzzsqxdr[gvhbztmgmlicdoasdxn]fthfehxdcnyjhdwvsx
sthxexgjpexecjzr[semwlxfagpybhblcq]ztkmocjbxsqnwfs
tsswuaezqpzyevei[nolctgupccscwsj]serolamcjmqaawea[qgjyyldemhsqivwmvtn]rlmxvchrccptrgmmbko[qtiqgvilvevjvlkxc]jjcnzdjdxycczflslq
geiglvdxwpsdtyt[isbkywwxvuzljpnv]djxvppprsgjagqtfgl[wmhnkumvdpikdjhmt]snjqvydpmjqutduh
ksqeegpqcodzekvp[htprcliyvqdgjbqv]sqykqimpyqiwktnq[bfjsisougvnyjoyha]ixghemgcvicbedylz
mwomvddjcxrdzmqplow[fznhevtpwhldwpo]ygskvziyhzxmtbcikbl[tjhieqjuukoqmixm]mgzzrsccohxzfgak
xvdiafigrvgrckwol[gttxgvtlreruvonzl]fgwyzafvtwaqdwuo
siyvzqpzfobnlgtxn[zcgxyzgysabhpvsviup]xfdpicxyxyjgxyxd
tuyintcsfdyhfxofk[abiuiwquiscebxbk]zqazrpoxqqswycjwvk[hayvaaykkacbakpom]bwwhqzhuiitdaed
ckkmzdomnglfwcbeh[avqftwjqckajjqe]fkpgyrqzygfcheoctfy
teuvnsaipkrkmuu[rtiypvevtipwuelkzxf]xqywsffobbokraw[oonkmkqovksdycu]noxwpblcqqbikpbck
bwgmejgaihdorgcqq[djldztucejcjizv]nuuzvdhlgqscyrjmab[nwcglzehbfzzvgr]aybubdihvypmvqmpfhi
gxrmeqpjnbegqjeuui[iqpcaqmpavyeeqkye]etydxarxyxculok
wakuruxdmenhmcsgt[lndpybwsvzyibmd]tfabajlzuxwwhofz[msknqgraxzpzwytjx]lfoqigitqufmhfmgwgi
gpusiwyruzmkoluea[ofbgogetujmjnqv]dzmarlipdqkgwdzwzd[uhsfvlrawossxvxyk]yeseypubhoapfgdjom
rcmnwwzrimrifziyoyg[avrikteehxhxcqhsq]yklfcrtqwaxmoepr[lahpskzjdwrjonqg]wddynujhryzkunrokho[ixwzkdpcqefelgcoabt]arjhdevhgaqcohbut
zkcxzfkwxxdtbumymqv[qgaztskshqiukhwuelq]wxzpzaxuhdtfbimub
nlgurkzredyklilaicv[mtxzdczugdhoowtp]hnhcyeygqrbqdnsc
pbbcmecbydtmjigfn[giiambqbdgbgntq]zaaqvlpkysxuvbgbo
aqyxolkflikpaxr[iqrnhzdtynkqymz]rwmgahzmvwtfebyguxh
kcxhmwgrvommccee[oqvsuahbhwioqeunkz]mhcyripmlfivqsimnpk[zptnyqihvavtlxkq]guacutltkqoixskg
ldpiuuwsszyidqxqj[tsmectapcwuyhhy]slauiehtpaocaeqyd[wbhrligadmsgznlyvd]nyvfiipvkthxjuoubc[zplkhqbtciuqnhjhiwy]olcmrcsayukgcbf
tzcpkpyrdolcerqnwu[zqvhulfxfhgaehbwf]zaekvjegdligfrsh
ghellbvwbjaummjjoss[pevgyftbjzmlsryfzv]kjdgnwfofftlxbiabir
pidtrxbnvaobubqwah[nftxjicikdapqexh]mwssisitrwjgxhk[nghedqdzfdgxaqacas]hvehmhbxzfwylzdrjf[bisktoqalmaapoomzt]lwkkhvacvuqvmsv
bdqjqlmohbjvqlson[mupepkeeoofwydse]ekylhrfsudqdcvkv[joofkljfkmpknazry]anyojhejtzfofcg[zcvpdeswtvtngyqleri]seqoyrfsqawkrudmg
lmjegqfshvauxngz[ysmejumumaurgvgrsy]xrmslpnljfmaidojz[mtvwolafkcxlwjjthy]yjqsssxayanfdrel
qmmiampdlsscnqml[ymselibefbqnqakirdw]uzxhisxyqljsdvhfe[jhjnivjgqdfyeqcea]nxbqpgyhtqzcwoptq[frlnwadwwyfnndeqv]qcbefaxmhgspalprcdo
tavfmtbizkrpnerc[kmenfsatjafincrwrlk]pbbxvydrsqnfyap
hwrkfzaovfbmrqhff[qglmybgnoytlkma]ibbbvmtqegqqxdk[gquqtiaqekcwiudebb]ozhpyabnxipgwfs[xqcajsdxhwpkofa]ssaordrnwjyvmcmjtp
pkyhiseqcvejtkbqcgf[xvgqerenvyizecof]sflyqnazxuwbyexzwyq[zppuknfnnngpwihe]hacwithomkpaveqjrs[whsspxqxxqihxrmqxvn]ifsktqmduowpuhck
xqctscaefqpvqcrm[rqbjdsxwoynqeoubwz]zycfrxbkijaedhkr[rzzbvjmogwxgcqa]hpzjokedwwmsbcrggmd
hcbohuwdyeacvgmbmea[mmpvzmjiryorskh]tydknyaqhgcxafmqj[ejadhaojfjlsfxs]duohhgjdfjffvwzcgel
ltlddqcbkkayshw[qdedbdppzuqdhfaxt]doedeeehsibaylpsnk
bywykrbttmmpyacsoo[ghicjobuumyckupnmw]wzxuueyajmgprxe
gejngdvsephfgyawm[eahzdehzhyymhcwx]qejrbkjhhplzgbehwdw
hobcaacuxkoxnutlayu[yvsylobmhtczpxdhvh]qpwhgyojuomiubmahcd[pmspsmyxaqrdvcpwnwj]ghdvfbhifxhphkseh[ntyabnyuoadseevhvpf]opibtuiwjogylqzt
bbuecmhireivvxmtw[kkvuwrudhmpqpmqr]cqrzfeasrpqapvtjqnz
uxsiwqfamsnemtcqyym[wemijyiqgxbcsvdz]tdhlutowbxpxrkrlpx
tnnlwlvfrrluuxjnvx[fgijrjghghgrkfmfb]lslknlacvseuzwy[acexgqeksduhjpf]enxevtqjetnyftgrad
wiegevfedudnajr[uryivbxbutbhfuh]zrpurmrupgeggdyc[tfykavyeulosotky]ahsieiakxnitxhaa
cdymukpgwzamxpe[ihvwjlomeozhnxq]zqlglkiyekzhkesoyui[dqdkxlczjrxgbdfqf]pdipsbuxwhibjytdb[ngoqkjeboqlsuic]efcostvlclbxvzhloan
uuavzipkjlcgutoxrbc[orpbrqapdzdsagy]hbgwsmgmyowonxftjl[wrimpmzmwyjjtnkaf]qmlpvrkqhqbdswyyvpf[lpjhsulqumdzgjxuajn]yocpoqqrpuquduay
wivyimuplkhmmkxioub[vqfixqklclmrbume]trenzswrpqljwctfat[ulkqyvjjpchvkpd]mvlwfrclcfqziho[pbmrqudqsivfemt]osmrlwtwstidtwmbmzc
owpgvzzedsxwjjdeuz[kyqifdbwfxcphnb]kyeaxxmsplabrbd[gayquqvysxjwpckzlvj]tiuxhodkebirvmdb[zhnicexwwcgbbnfd]hcxwgyjpphxocggfl
vrjvymyzflpaqfy[fokfgiaiyyzruyt]yvfrfomlsjqkvtps[mprfrwzeokyjmdetnl]znjipokvzxljjgqaw
opczfzhpovblsevqcx[twcavjnyjerbqfqvooy]tmyyybovoyqcygzzyk
gpifunuvcpqjornc[wcenyqazsxzksun]dijyypqoxxmjiyi[kdzvguquhohgsghqqko]tzknqsgldnnbotqnocj
xtnewbseisluqott[ukktnadfrptzmvmnmwe]nfevmvifmaaubdrytcb
uvwgvqvzikkvvaltpbs[darnokckfpuiwvaq]qjgglscrdhximnfg[cplqfytiupsnlwjnz]tjjkzojxijhhghoo
mwvyjvnzfbptvndlui[dvpxdnwzdssddngva]nkvlbcdcwjumrqmjuw[xgrpriwhdpyxvakfpsu]jzugamflkelhfrzswca[hvdnwrkyrvcdkep]kqyiaalprdowzeudqvt
zahhurbvayisuhkxluc[dpkhtfqcplnlwkr]moobahksmsqtmxasrw[oyxemzzmvwvxrldebja]tqnquzqoslugwcqcwtr[vibjzqdbmsmtxckkkn]ylujuamatwbexgo
ffpiprpoymeaccwoun[avnvjzwvzowgthwymt]sakvpfnqtnzdyhodzud[egijncssvgvsofu]dplbxmzfihrpopurlvn[knjefyormeaeoni]ubcbldkemxgefbnjcbj
fpyokxpcrydmqzkgr[gprmekopimtigwz]fobjyaxokhstzjsgkw[njzhtjqrhoynlzpiw]svrqxlhgpckwoat
srrcdyevzyzhxnx[bbojuevgatiabjudws]zoxxvzrngllhtrtfm[rxoiyzmzwoenbodp]keodzdiobtdfgrxzgye[akofrgfwqtqblvntv]rfyrjcwbfblulkw
kxuswiaijpaejqzoxes[cgyhiwbpjrhaacwe]uqqocaxbsotoaei[runskhbiegmjwfyjv]qgnmhdcjcbgbsztap
kvzutkvgsyiyrab[zhbqkvgbyqzgwvfpbf]nhtaiwzmvrssvxsrdz
tncgsbkllaugseepp[axryamrptnzekcb]xcvqkfuggjcfqhb[mtmzyjnvrgyuwtev]xziofjwvnbsothqzdm
hmjthvqdelrmghgnvxg[cvfmsllxyxchaglntl]ikpeldmfhjdtnvaw
sdhirfhdcxlwhxevbv[rfktrkotbfwiolxd]bhbkmmbdisqlclttbi[ueaqlmpvdaoxhezzg]baphbkfivkwpmtj
crzkarxgbgpitxjeunw[xlonohiojoepwnuhd]kalfjqpazwmwruq[erssxjpfzosbcta]exvgtqljewfuwioyq[syaeqtgrgswbgbetkzw]ofnozzjtykajqcuc
xdojuclultxptlxgci[nkmxgmiyhrrfgoshmeg]zqxcexaabvdjcaiarw
rewjiwxykozqjzneh[tczrbiawzwtndtqnew]yxrgwvnswgyxjvnot[khomcpuiavkhwjsl]ksqiuqyarwwibcssseg[dsrplcalbjojxlecjdo]falbpuscbjsdxvyn
dusvvyynezzobcrt[yrikyxqxqreoqcyyq]vkjxvnlnmleqybmgt
qzmjfdvoruomeilaejd[ksrwqvmnyiessfejo]lvhmckdfwzoxwmydxm[icmiecrnoqepcuzctl]unxwrfwxgnijdxqjc[tuwcbylgfhpaveyak]qslgbtviucbmeluf
djblesvduxlxfxp[grmuswjaheivlqvtst]yrqstsaryoqejwkd
kpyoqmyglnrmxculu[tuyuqjronsgluls]whuymvpcdxvxrimvmow
lruqeoicrisykqejy[ruqwiitwyrsithkyo]hbgqgiywqwsclcsn
pkpmmddfcezjrrs[rbzbxotrbqlnmlpidpu]aakddaqjvbbafbnk[sendmtepxbcpttn]udnifsqhogqvszi
foqjzmqhghzmymeq[isvvkjfpmvmhquoidkk]tskrbirqdtjpxolwzw
pneojhviynihvnv[meuldylhohlfwsxp]nmdwxhxuexorktj
gpnxdnxmueucaawmctx[ggcizpwllvbffytwv]riqcitchmdekosocp
kcoafhejmqsopizo[lyoqftddzxuuerafco]zrvrzbmnzcawaydwg[bhnmhrnwpzmghrprzzw]qcrnkmyfcdoymceacg
chcabwcrpxqnelguile[ckxfqhnrwlulnfgxjb]toauhcbsxmeirtlyy[cfgmasaieapbabcgdd]ijenfrqiaeiehllwpvk[ciymykejvkzxsbxy]iiyypzaxohmykgbzej
yeqhlpncjcipsmtzpi[zoidbyeatjrlgmi]rcrhombxichyykncbwh[wtduqjwbefekhnwo]kqemsisbcrcjaqzdzw
nbxvvetblqcarlcku[njrccfhdvxtarpj]rhndgwlyfzaeubc[imtcezhovdlfyixzwm]dwughoowqyazwaziea[slarywwdukqwygnhre]efzdruetqfoqqxusb
vhvbnbyluqqaqzolkrs[fbfwkawbihbzwlrhd]npfzyqkoxlgkklgxz[zboinxtlzrqbwcqo]jqhvalbjqaogtyn[razwnxfkshezamemtr]nywqcxpvmuudyqo
jubvozjfmykufhrkk[qhbaxcvcpyzbrwjlrij]itseilbvjwvzlgqjfe[lgxynowzlpqgoyrk]inolsbnzxvdmvbrvwqu[hjzfopqwsuqvqhb]wffwgmhjubihiqkpuls
rqnjadbwfosviivshb[rutsuesebrktxitgy]abukeyordcrrqvrgf
bfveiveawwoqyluxwu[trxwkfvioqzltgafma]swkyqokgtrprzzit[kuziuekaorgdgqjgi]zudaehzrjfzogiwb[fyxwwswqrbwgomriqo]sqfjrdskmdvalkhchc
pnrvpotetwyvodue[xwkxyzxflrvxdfogk]kamxypekoelgwktq
etjkovmlbwryvhv[wvubzziqtxbjvua]hmrqokvqrctugqdazz[ykobpstcxdqweotsi]eiczvmdcfjpvhdyfnci[eeklndzunbzipcqubp]tjsktxuorvbnisy
fnexznsqqbhygrm[jgnmivchcvxgssjcm]klqcaszkwyzzecve
pdmzjundpcsxbgplk[lbdsyrmgxnatuwk]nwrhpgieqrtzpktaiqw[dcxtjtkzvlxpibanjma]djszxtofdcuyfpdr[kzblikjgqfiaykr]yhiqqurlkwlrrjo
bwtgmmjbtisnzbnyedf[iniovvuewpetwsg]dgvjyrzfrqcozekvp[xsulvxvvtwcxuvbxau]vvjyodjlbbjxigdxvxv
jcanelvhybigzhplc[lhgjkwbpdlcybzgacya]uwisdadjoniyerw[kzcrorifvylivkhs]ssicvecwpkxbdwq
tuxlnjuyudvhazlxdf[oknheznyzffrtcb]joozaraxuivijskxblf
rvfdfyaemhgyeynw[hmmkdfdhadrqkxzzmsj]ugfozgghllznjhdxw[ucrgusuuqthlgxx]ipiercifxtkghbkf
jgzrilirvzcocaphnz[gyrvhettmmhxaxbmyg]ecpwkoozcgtpoac[iretjtqyscaqfqziu]wqjckfkbfoqmmjkuhqe
pswuxyynrpckrquj[wfbedboaabsgnnzzzwl]wgfrecpfkvlvjzl
zkcihebtrfmiryqkd[ybedpynfafkkrbfdm]ovrsmnhexyqblafad
pbkoczqfumwdpfu[gtcvqjuwknlrfxre]crpyxhawudbilybaomf
pnagrmxhmjftwltxh[aqlhxdwuzrvnwjwl]xhmgrrajywnizazyrdc[hxdxewvthhrwhsva]ckluhnyewiiqazzmvd
amjksgqzgmoavvxtov[ekqixufaaepczzusfga]fvlmiilpsqsgfgg[gzcyehzgpujyquhrkm]caaocajhmhqzbacvpog
hitezskizncharbzyz[nbwuldsjxkjezjq]monndtwsxuikupvi[iardznrxkorquvyvwlk]etzyolkxhyqsdirbaj
ocsxlxpsgimcvori[gawgkxlilqzeakhzds]bodnyayaioozoeg[bmaukrfdlswrnvuwy]nafolaiqfeendahms
kseklqtakbkzzhfd[ghivxwcqlgfgxeot]levjimgmcfpgqrjjic[ixwevpbqkyzthafyj]azdxqlromttwteeqep[kxyiyoxyhvgqlmvscwz]zxdujwvngqyoabmrio
elgbshsnykhiyndouao[nhumkawagmrztsamd]fwqupmyuogneywsyhub[zzcemywfdswhvjpl]ockclifwawqsyzt
hyetqdpieicmycip[ciwciijtqspvydxsdu]zjrfhyctplqvypy[hdewteddlqfaoifgy]murcplulddvzheegmgd[rooqfiqsnkjeelfjcag]pdzzjacxzdzmmgmqwu
nufvveulfkudkrvskbg[cdrvqfofoxmqwtv]jzgfbywojzvwumo[vvshcsjnhobkayk]gkwnyerwhezneuze
qhmjnzcokmkmvclhfh[ywruoexbmjwuxvrk]lswliylmniqdgybtyx[yjrzasyfroiuaeps]xevbxtsyjknqmeuv
crwelvogceorioqm[xmduhdacxyzodslgtv]wilmwenmmnwgqteftrx[zonwpkkjimmmhbrtls]vfbovjoabzwjpxd[jjxievceapgflzeldwb]onucskcmpkgsryl
ujitrvtlzcrtazmghgm[mculcmczwibnuhtunnt]izqgurxwxhwboygvmf
lespfnkqubxfoqa[exmzkeazfrfrkhzufz]xpunddczqrkxtgorc[ymsbogpyjeimnuola]kufhnwzukrdayts
mitdlhggspwferwda[fcwhldszpyfznayp]rbfzewqihtcwtjznsp
wzhbemsmffcmcswdvp[jcbuktuymokdqfjj]zyhqthqbczupmcmkhi
qulvtldmhliyflccbyg[mqggwujrznjefvjw]sduatqntzkkvgfqel[fyxdewnrtlkkils]utxmideawxrzpewmee
ggpinoooeucoxmezfi[ovisfbmebypyafknejc]ccqkrmaimxmvxhtain
cqezdujipgzaara[afkpzozyzuitollf]srmeiyjzqjruima
ivbrwakbgkrxpilylu[eewfaajedkwjbdrk]stsichtqqsksydtubf[umxwxeikoyehrou]kwddyduytdhdgdbyn
vowwatzholrusydvmdb[jarugsbvowdtznwx]oofschlksdrodakrk
oruwtttstrcvcgxz[cvidyuxfxluddzxuz]jckmrrmvolclrbam[dqptqpdwkpewhmcax]rtfmeakahrcbazlzsju
vjrkcrzvefpxgardmqb[wxmurzwunsvjaxfhik]meiaafxurfgikqg[dkoextitsnfeorgoihc]diohmorpmlhisrs[ibtzwvoovjmdpfi]oelairhwcbbltmjcjdr
miafjehtxwnfqzxg[nlovpfjpeclnmlbm]rleupmgzewtvuewypt
osoaytxzfrkcljfjv[bbpjqntkuuwpgupxsy]bgryerdaukelujvayjt[gycrjaelxuemeosc]jgdfpdoltoqnmow[yfwoyzixdzamgqweb]lvmnjywqfjfvyxhb
oiksidcbtzhhtnegqa[vdxnacjfxbcsjzqdq]ixvwmdqdaleuzjniki
ngbyqfvobuxdnjeqia[ksktvzdyzkvyvjrgkos]xwuslzgntfwrnyqrod[cxmkhhwyremunrbc]hijkgxizhlyzqfaay[ljwayjqxyrduyoebm]ancrkgmzboqtwkjah
kxcifwahsdmqasrmwi[aqzdihesmgntomgmj]jkhmcqvxqxtshprsy[wgewbxfsobokszgsivz]zlpavaqlwvauvedwf
ibhzychwgtvobvws[qaestubbbtvyylbr]ovsxlggntxnneirtot[kgqrkbiqracxbnbi]lzpfersavecdddsytb
abjcqoeeqfhvqmo[eferwxtafaxzidjzbr]qztbvxsaiyqhcsdkj
uqqngbvhyfxovmdods[zwyybohwrhprvxaaaio]cgyaactenmhiokzh
hiqqvjquvdkfcjwmo[jzrxnmbrqfhjhvppdxm]mwvibfiltxmwroeruo[fasknewgpsmftnx]aubymogtwkseupwmr[xnyevhhalilxuxqqvya]mastwtyfihocpbjngaw
aqvkyxqnjtthgkjxr[ahvjgtzfqetvqhz]vcaijasfqaygnxmdba[loyjulxsgyldkotlefn]lnzykvlsbkyuvnqb[iqjxfxdmjgyxboyzr]zbfwxpxbthtwtnjdaw
iweumcmplhykolkazmb[zgzeryniuwebpka]hsuxltmwyxogseiogl[ogacxzbrbvopihzm]ipogfmqtohqqfvowzl
hlvbzegrmbrgoepemyh[luscnqomtcxbpxjmxvx]tipsuhgnhdavsubyqha[ozroemaxbdbcpnydjqs]xqdwngpkteoyyvkq
fgpmkosjnfnltkfy[sxqzypihbntsfnryubc]oygetjhbfvozerfzw[nwvofzjfuwdzxncwvo]nvbtoxgwkmhnyox
kbqkyxwacrffvkoxmb[tqfooaoggaauopcanz]ptiakppuyxzwzpua[tefuhyaqzyeteexrsj]hkuwublifohismiqg
pdbrixpmacobfnpg[mxmgtvdlsuyhjnjxz]ghuebmnxzqfljxyutl
ichijthjvilenbfg[zeibnuadotzachqyvej]qogvchvkfeskckvmxw[plyhbwjrhhnvdumajut]xazlyayoobgkmevrpho
cbkznopiuqsssvle[gecuynehzvcmfuzcaxz]qfihmsdjfsxymvesb[jtriyipbkkpfnazcj]wbcwllfdxxdzrimwues
ntxzlslwvxztbmola[duloarwqzkzxsfag]nzrsxasndnrktih
fvvowikdydblgts[xozwhuhhngdjqnbry]hkcwbqloymkqjyzpj[xfwuoehhuljposct]ashitwoprqcooweytiw
ynbifagloxgkzlydhk[qoxltvqdpmqhawcvef]wfnbtiyjafaqfujr[crcuopstahopywinvgc]ppxsgbvevlrkdgsv
tdgutgskbatswuizuv[zpmhakbnxnkehhf]ffuohvkaxpiptot[zlykjduigarhxygukw]bucqoskhlesclyzbpd[igdjnevmqlibrugc]seyjwcizckvbncjwon
holbjgzpvhqirwrxts[lpvaadhoqjjwvijk]etjusqwbrccaqea[livhtrfodwoxnkvk]dmprijbirsnzuptikc[icjaaepybpgnorie]imtoivdxpujjmlegqn
ljywtdshrtzqzrln[lqzqgywtrpgszaigfv]vjyyvrbkjdiiminfas
xfluerhpuqsqnrq[rtxglsxbetzajmo]bktotbhryqxdqfaf[cptmsctjrifdojglh]qzpxnniqwxlbvnexlg[vooexmzwbpulnxxv]eumwdzoixhfxkoavu
xmomvhstjavjyisvhs[suremlzhaiwhikzzojb]urbiiuvmveiapcybgz[botikbmkcfsghtgtcn]jbsrxdkpxnynfibgxyw[agdmtydfehaujynym]xfpytnqyoafnuott
xjzhgefdlodsdahv[ihwwnfbwhcjdbrdixy]kmsckqifucrgpocyvc[pudtuuaebkvsrflz]qjfwaaylzyhzerjbhyn[fsnmlxncwzsdsqp]edevlblbzmwkgkfluke
qxlppzrvoymnsiyb[ybyeqxwtoberzwvcdlk]zsofrmazkapwiuxwjjn
jbdmjeyxyksaonmswm[vhxyxtashfdrzjzytoq]jpkbmclxjtprrhmaz
vxishfigjpmdwufh[oykzgieieiypyrqaxdx]etgleieyrezvbcg[scrtyttykipejzmuhy]oxnektqrkndltaixnj
jnetcyoxmhjfyfjxm[dezndcwpoghexum]xloobrzxrvanbbh[gvcaufplrrstvrf]jgdhedqsxchoorlai
enbtwxacyokhcwyhxp[ahjgrmfhavhnhqoqsfs]ahdcbzojcfgzkjfe[gtjphvcbwzsiohlha]lwaphixwqbmbqhyoccv
arwtwiiowytbbjsumh[iwdhsnllysydgbcuxw]kummpwhpyydfdaf
laidhzhbdwoezqhi[eccvqcxwasyyzqvhrw]oobigxsojqsyijmjmu[kinacswultmqsxdhw]xlildtoykeuzgzl
fbwcshbijakfapcqzj[qktwqwrlnuktxjvuvn]nbzsrphskcxzuzho[lrbnsyzvrorznoq]ewytfrszdyhcrhpcx[bmzudjktpnqxqwmblf]xtwqqocsaxoluhsh
xgnhvwkwhfbprypnak[yuwpjkfdxygltniuepa]mmbkjavsboilcvpp
hprznssbfrukcvu[mojrsfuktavnbhzty]ipdxnxmtbvsazyx
tfdicuergiqhvie[wwpqnqkyfyhuqlb]wovoujvgcwuptcqhkd[whhyzgbflhplrff]kezriqiamcvkeifegv[kcbdxrvoharumkgzufn]xypaikbmpsjqcbxrrp
tkqpijxftrvwkam[yyajdcxgzrkhkroq]qfrbvprhxlpgunqqs
fvwgqznbhbrmcaubz[lgsawqyuhadojbqwrwt]gzbvdgpwjuwqsgokqy[zpzdukphcvdqgpdoex]atanoaretkhxbyzw
fispfedprcrygxs[xqiggqkjgjhaskp]thgqnbgscmrcfqjckbw[tvueixxvxlsnaupqed]lshjncmwxgzzczjssh
fplljoayuqmjtjs[vnlhbmvowousilhym]emygvrnfsofwobaducv[flrnwxzgkghpboubuh]sdndpovsuohytnq
utkqxfkbxtoudnbh[bjatbltbacnlwzlbjk]eunawwbizxdytndqc[arhtjgntcqetkeikojq]jfooeguervzgzgudb[nhifbismjhcwqyt]xwsxwzwwvtqoadmgvoe
bxbifxmedhwkesbmjff[ncfbdgsqfejalnqyar]oifushwlnfxghktjhtq[gnapwycvocshetc]zzslupkhadbieerb
rrotstdgmwqowfmf[zlddfgpxgucuestu]dvlbhinllnkxdybha[aovlzdyhamvvcgm]dzehxcilzoxrmcyhiwb[xkeszyasnqsumpx]bnrsppzfvjhiyafpk
qgpylzwwdjxmepsc[bumaitztsvayatapvl]gotathwcrjrsknrfuk
odbkgubddtpxdsgmhvh[mbgpgqafpcrymkkdpsd]ieabelyvewiypbkjm[psowbfplvsxifqwq]szgntjujujycbfy
urqwuzkruqfgejkdoh[qxxkamiyhedlffzg]hnfntvahsaivnzmawf[mxcrmrqtgmnplma]gxcsbxvqcoxpddj
qzkfvuxmfneyrpysh[clufxjecvedwwegflp]rcxzfazrzbgogna[ogoplmljfwvizwniudc]yewvacqgzcjgdnmasw
mgweqpewhvtdjnjdbu[pecantesazignmq]upotybqiovoujemqg[ipzggdcevkbkvpyz]wqtflwovevactij[ednlhfkzrtfwpuignhd]epfijiuwnczwxdmgvzd
lavqyaejctfofhdend[enxgzalvzelvvxdt]dkrlwjpuipwnqvuv[ishvyxwuhxdxujbgkev]euytwzxkpwccexc
haibamsiwfwmdvzu[aekmrvauzoxdbtury]tfgjabbgdrwbzde
gqoyggrpzhfgrkjjw[kwhwkctzmjdpdoeey]ngurqljoormcjarv[bmvadfmdgpwpzfiiv]fkfqchwhedeymsa[etqtnxepdmolklpa]tywoaqpoowybxcoqq
vnvmbxxccmctcba[ncggihzavxxxrhb]mblrxjgtypycewg[syiizsazwqrhsllezvs]tpzocblnycaokaphz
ffpbdxvenqkihvvsi[bbukwnounmzzxody]bzfefymopdtkpdm[sjbemcyhrspadzkuwi]xlhinxfjjeajzuqjkuo[zfpeikvvdfptpxe]dhsjhnwlzlcxbkz
gulvdtkcmjewjchf[auqodvrekgvzxzyiwee]rarumiavqvnbyqu[xywssgnmbeefrqgr]lyyjmkpmqxmjbughzta[avdsmuyfdwvzrzn]qvhfqmazlactaxtxi
vvqlvlsnrxwhoxfnac[sablzmrjccqvauyjfao]avdnqlseflqxtgb[masnpoqnvjtkreifrvy]lvtoftpiotxcstvu[vohbaippdypuwpkuip]kxffhmrvrbmvhecnui
kclmgqkaprofpmdm[bhbitgjmddxhbhu]hmasnpqsttrgtmuq
tvqcqkarkyqtpvea[fjqrifichijyykq]qqtmxszpmovzfvk[xrcoyhzyxwmqwujxp]nzlgwxpkuersepyhy
zalveeaqakqjhfl[uypjekwlbcplfcasa]sasiztlswzyhvpd[weglkkwlrrvdvfd]mvsdbveypnjsymtjka[kroszrkveyammdqqool]kgmxohwwgmvcdludvdl
xbroawhwunnamvnaogo[uzdvwckcbkaahqltp]bxudkhzxrykrkffaiiq[ljfeimkibushcpclbia]wztapafqrfdpwcwpyz[xwzhahnbnaxjorpkaj]glhfrkaiizzidtmfi
cycyarwdelrstoi[rivlkfszzvyljoa]hkjtyvycydwronsgyd
mbdqighfupmzacpi[keeoafjlwzqeoaryo]vjcwhcjkjkandqir[auactffhpuwzgzm]ybkwzkxyevwrphq
cpiuxmmwrsjzbyqkfms[buipqvxsetxzsgqi]tzwpfhknlpwmtxzggc[nidtlxvnowvutuqv]qsohatjnnizngzsqxxr[klnzvuognkllhhr]clpjgdupfpanyxwjg
hhtduiwmfhibnpmhjm[emakclmaqjnvjsjyt]ntebrhiztekglpmhsrg[rgehmkrotjobrtah]gzlybshvhkoznupnhr
hyzvardyeiddsgk[vszukhazfkwqsodz]psztzqehiwcpifdlna[igstccorevbmgfae]vdapqjiijwygxap
towtxxuitgwhddsua[bydcnwqycygmimbrut]cvnvgtuiuduzjod[gpazublcnojkfnnvn]rozlfkywwjelmry[wvtxeleixyqstxjqed]vsuvzaskgyooigoczd
uywuytlehdznyxr[goerwtisqdsinimd]abuktfxdobkfqabm
rolwzkzesawhyxddo[yuuvalxthkptulugzh]tagfpsdniekrekzkt
nstbvilzeselffses[cpgyssgpjimcevp]ehfkumlscjuocclfhel
idvdfrmadfyhafvyixs[igsqckpzuelddtl]eclbbakcdyttbtse[irchopmhiqbeloiqq]lwbecblskhopzyw[yjmdufblseluvukftkv]nnawapbepipwcsfz
thqwduckwmjtxwwmj[ppnucfmtpcsawxvkago]vojtdpukjwwlnirsvle[cscyjfrxjlgxhyu]fldolxqfbxhigdom[tgacpmzitahxucqpzke]copdqvctocklhvrq
maseolhlyrjuoqdazl[klgwgcdfwhpwmnlklcx]jycbhtwurlwwsjyuubt[cuabclvzukvmoiniql]pzockwxqjbtadsspl[izzcraalbnmcopcr]cqdxcrkdnwclxcitizq
ucyccfdgxaciwhx[txuygxhekywmyuaaina]szfdjuddiopneadpot[zpjsnpjtmicknxkybi]lfirzuldnatglheyhnw[rhgqfyfxlaunabfqxl]hplszylhorbrkuy
vmgeqazfjldqcfif[fuepxyjuuzxkect]ywoxrfdxbyjomjo
qacfshruytmlwyj[jpqmllbdypmnzqoe]sdhmtuefjbrmvmeby[xkyplnmmmcrcmixkls]motyvnyucleirbnmrys[zdopkcnnuvxmhrg]feeagfdkgorsubr
knlaaiwxponscqwtqla[jxilqsyolsnanzxvqi]itqqqbrfpcexbnecnkw[bpcxykvtdbxejlcda]mxodmdxzohrturffnwf
txvqlvddwpcysvkctlu[wvuoeprflcpycbghfv]ksbpnggnitrxkua[hqyiyucnvjqsceml]uwwwbxrjvodohwznlx
oebxtpwwjtewgkwjbv[omataxkuqenxmxolwe]aiepvclknbgapqh[wywlrbzliilwwvebxbl]ljsiuvllqbjrvqzh
jznegbplekeeohnf[hegaqbzbjwdhgkouzja]msaozvrtyshcajexwen[cnleoafnzyvbvdfndha]guawhzetoxlxmjwt
nytoqgolirudokcgok[qjtvenvrstrjjlsbvzq]mwhkktxfsokxxqb[pgswnhmmgzcrgjbqcx]amhrxgwmcnykgpuzfb[dnihosgggajabkoq]jtyxfrifreihydzwjdx
bxihyluintytvypxhl[kbnizownozfekbhmsp]sjgxqgjbhoftgmbck[knoibzmlipdnfca]ofyxruebaspanxxhakl
xhrlcwziflvahls[babpaszszfgfywj]gkquumhyqvozkgubcs[gkjczyujqykeifhsylz]fhmvopfsltpzijdw
ntyxwcfpdgnsyau[eqjxtsfneseakvrf]sbzesbxxrrmpmlazhi
lwakhsvcamfxiceusua[ymczlpqkoiophom]fiybjcxhftziivsrsok[sejyfiorjpptboakf]ipsamdcnfnlhger
ncgeewwfszytkag[kizbzwnxepsvdxsbzbm]fofhxxpymrbqvcco[swphuoqvhbpghtku]hvxqclwgtxxqywhhs[ibvpkuiylqazccin]oftqdvkbzdkmycntx
yhnhzwjjsiqngmhe[jtkcipgiclbqublpfs]glxyczwidjilkqoa[ytsphdvgnawjsctty]xdofsnhnpsylvmso[pmjrjgiwhqfegydcs]ylfcipikfzvmpjn
pwlhyvxnneepoqexj[jsnwzbjxibgqnpjgdf]qndnlnzxewcrjio[hccvunupvbcyptqdihc]rfhmapmentuhoiv[kohfhnoakeglvnasojm]oggzhzybuuupwdrjrtj
eyglfycgaoqwsqqnue[woaxqinxtvrhsbjjvnk]cfnkhvorifhxedbmbmq
nrqqggalpihpjyu[dqbqopedkxhoqqnp]qguazmdjtenlvzgoemw[ccjlmsdaajwghuikrnp]xrjcyfkrrfxddnjn
wkiymdlskwyjrft[ovucvqbenolfvvu]tzymrvmekxnlptynj[dupyullbzepmmrmgwe]fnjtcvrvzstijxq[elzfqhyjdyprzfxa]uszwjwzbbzgpcavynk
jrdliqwwffvgzpu[mxoivfuwuqvtxqmbbs]tvtlqzqgwzgshkpw[hspnaspqnjvwybzfzxd]clkhutlibvxzxfrgg[yujteartlwdhzfgsn]lyfrxjqcpkcvcsnsw
gtfhmxlpptgvgwob[xlzqaoawpmmjwszqmhm]xalfbbroilfuzzqm
gqxmhinpeppmdhbdt[cpoaeltrlzmfgsipvg]iqlrhncmkmjijjh[xsbdusetrksrxjiofj]zndjqyxwvmsnrbcyrmh[qnbxczovjlrrvilks]rfpihmkwzmgxcynu
abcncmuhelkxeph[crlbybjylvbgtsk]yvnbosicedmzurqcm
fbhtialrsrrtpwcxxh[pisambikwkesdtbsj]zcdseybwrdrkxeiylg
sehxfywgpznuuypj[upswvzwnkinocjk]nabhugsxhitlhis[ilrwksgypfqgfexvuhv]torregbntatolgchv[kkimpdkcxhsxyuczj]xpfacbmnrhcxnbgwis
hldgiynbgrfjcunattg[nwfovbxygpkwmxnulm]xleqlwcajqwnncww[waoaudnttcfdktcd]yikfvdmekcexcrhsi[sntclwlhouhyjrob]wqpclaistsngwfmf
izblnsxlmqjhxvx[qpmqqzakbjpbapwtlel]vmriwjoqlrttqpoxay[ylqzxxdpycurefadv]ftcuduceaycwejp
jqjtnshmtsvokhwnpr[bxprgnaltcsqdkceygx]udqckcknpvegeryj[zvjfvligrqxnpypoerp]zhzwojzkckjwgdyu
ohxpnvtduqvsihjt[eczkrdqlgyddymrdjfj]zzqhfijxsgoisbwpd[lysfkgekxvqspagq]kemxkdqxetnkyctjp[bknjdsvchfxflsrkuum]wmxncxrwwxxxgza
xnulgysrzxheppsiril[hdxgzhscbjhkcntrmsy]vhedyohrrqclnoe[nnuxdbtlbjvaddo]xivkwdwvmkplsvfaal[omihwmflpvrshkcoci]hekqpjtrjlsaomfd
hfyusspcypxdbgzb[cxbfccrumbqqqxb]ygsuxbxdfkisqwstqp[lqctoagvchrmggtmo]dgmcjusbvlmlvkdmnpu
vmpobkctlhdwqjyb[dxeinhrldspqhgeu]ndglldouuoawkiwtask[szkthuhxdkmfqoqwwgq]zwjhzselzvirjadzvr[rholepzsidriqmlepo]yhbxhcmbkvripyusams
mzscivdohxhfkdqet[imwvpkunuzbhbaj]tohxwppjtsjykxrj[nhonsbadufgsqiysn]cogovslrrwexgzujn
pzsteeyowqmhzaqao[qsbohgqamrksizzs]vscfiltkxbxwbdlold[psofpwfkxhsxllnz]odwbidqaqpuchaew[kruwykloeqpcrjzon]famaoipldevywnouele
tuqiapyobwqwpwbqqu[ycphsbdcwbmklro]medgafihivwegukhfof
lficcecamifbjwk[sdguwtafkigjiapxagj]hmeqrhxptojctevbdbu[zvxeefaytjajdpwi]uliqtzilzcnwmbfusnm
pvyzncrszmuienoptx[bigapupzitygcxstqx]rqikselsbelyfjdm[lyqmdmfyofksmecg]wjceogefnlgelpguu
hmddytvxqrazumnnr[hpeurkbdfejhlfvg]pedwizmuhmtpdwh[efikgkrhnagpmqypzx]ltlncfegswhwcxa[bakxhwhtvxcwcxtmofk]zwjvbxyvljlfaie
oxgoszggsifsgrck[gruwptjveewmfewguku]otchieijhojsyxi
kunxbbrdhibhtlknrq[tmtsuhwakksyets]xdugxmqcstdallfqgq[tticbbqirncbjtx]knkygxawcwdhefesu[rerbfffgddyehtvl]yasblwlhikbvjidgku
qoqnwslopcpytqy[zngrksptgviifcwbw]nuislpzizqikmgn
khmctigslwdgzghkbk[veaqghpizqwjxlwcf]aymehevjgpjgwruhyc[hzgzilbhyoazljsk]jocgjmooxqxayzsa
xodvowdhvnquwtma[kvlbfwwzeuucthg]djlyemkbpudpjlnrkv[cbaqlhuwfwwfvbdewx]vsjvsxsizgwsakpx[pzyowqndqdbkdakdney]eeylqpqpuqvdyyr
cmdykdqavxgeismtlua[iwviddbtauhirfcabh]fhpsinbnwrcpxdho[tdbgrmgscvzukjl]rxupjtwbwmtgnltbjp[vgzucvscpzgjnvg]zftzsshpmizeksiz
kfzmwzmzdpxabvi[ftkotbrorpkpfxzbg]hgbrsewdgnnqhxvueya[lkjknzgrbuzjqxwqseg]oyzaqahfuqtpbzi[yflzhfxwkugpetsqli]nowgjqaquqhrlxz
ktphtjqwsitgbaii[tjwcbyfrpupwkvzrol]smlczhhekwxtlvxdfn[mqfupholnlvfhuv]mvdhzncezgunydrk
lrvdftzasxbpfgb[pglmengmgfbnzxz]hbasbstksqkkqpwkcbp
siheyyvdmjiubhlapns[xfcaevnaoexubdar]pgbougfzkmlzjqygdta
tblrafqbjhwzbwbe[iefobcqdrypwnwidvm]olrzzrqgkwiefngf[asvmlckavcwtuosgkrm]esqsgwmiyxncjjqsqp
alvaycnbqdlvvnwcnq[jwxzjzgpnzmcampkye]hepmdlzjvxhboxh
mtfkavmnrxyfzvkes[gmwvavomsyolkahey]dnqosibjkplwzjojus
gbckujjuhwnvovpfqw[qwievsrrtusgzbscuf]bnrjcovodutibjtq[fxteivdfkpixonphrog]mnumbxikkkyeositn
remzamtzlhwpndrknl[xgrbcgdvlvrcdrpi]tnzimcpmxzaxsgpu[klvglrrepqxiiewn]lozcwxnclirneaky[nevhtplqsmuhykzqxf]fgmsbwdgfwjftndzi
aybmjypdrytigyyip[zafsvprjirkniuwr]wfdyfncywtdtzezdbtm[umbxrtflhquwdofgut]lyjixlycobwpwvhfp[xoxtkyhvwqgawmike]bfqtgcxvcfwtdpl
tugswvsgbsfbiyzcm[akmlddjckugylrea]fyzltfupxnvagbshlb
lcgvlozzzzpzxeoee[zsvjydznyoadkvyxlsq]wqmgagbkerqyxjnnx[isukybwewezizpll]odqwazjphoaqhzltms[gtqeysqpwuuohdbhcnx]yqtvojobgaluizidrbn
agnxxgirnprujhsk[hagcvuqcwyhmkdqmn]zehvuytegijhnfqnk[ytlokgpipjcviulp]hsomdskdngoysnbmg[wztsneomppnewhrl]gpkauttapxhcjrsicvy
cvnowinufvrjpiqtq[kuavqbtrcelpcuasmk]poksbapbwverccds[qdddbhewvxgfoldib]mthrvrsfygbhlwlkcs[zhivcpxibufugkpigzs]qffdjnrsoigwxqhaf
kovjiaxxjvzmzvmn[cmrbwjccgphtstvaiq]onqfbpryjertymd[sgmcnqbseodopnnd]gbgealygrgjnamdq[yrjuwjfvmsmgbur]ldiztdwrwmeqrohy
tluglhveqluxpiy[wrsgxdrzuigwzfsby]bmhqmnbecjnyutpwlbk[iifejjworkzrsaj]illltueflutteej[adfixnftjenvyrigmkv]zgsqagrctomzublltjm
fhcnrceynkcnnjxj[jrevstsodmhopao]zqapczirtxrunfhl
rzmxbxurpdmzgef[agevdburkuvnsrof]rhclixqpruwxuanwxct
vxejrazzpddvobzlq[dpspaddyabqzrjgvv]elcpgozzkqjsasufcv
iaodnwpcpresylkhyy[dltvlrxbvnqslzzyvox]qownkehbhjprbzf
kqbwgctrhxwrkkedau[occltggonhshykttsrr]snshslgqtlgejanlg
jpesfmiguicqdcnkm[oawppiwdsmoidvkcre]wfifgnhqeisplngcjkr[wevtsiuznmpapke]dqgxavmudniuaml
ddewtwhdfjatjlgrt[ceurnauksrgwzondnb]znsvkdkwsimbmdxfkh
hwjwuhdokecprunbju[jhftguwujsuetdriyu]vcgpesthcnwuwpwes
cgizaalsahfzkcxab[nehrqohgkmbxiufyco]xbnclpuepsanwrwjoo[kvdifptokbtlihgx]hgynbeebmdwbkwrfbh[rlypefyljzefnft]wwevofyexvbojyc
ckxkzlpwrfhwzuep[etqgjhcmexxvaccx]qqkhjttaudjpbjboeo[gihevbqqqumfythcfm]hraqbarwvqnmvtiy[cbnfqzxyjcpmwvu]lrugefybnoiopvzi
bbmhfnwnuhvdgmoibjq[eugipbrefcqiniulz]frkuvbhbdiaoaqdcaq[ksqqrrhjltlxvet]cdjhqazjzfrphjzjr[aspkvkpmwhkzxfeic]vkhbjolvoddtaasvs
rxkbkkhnaiudojzsr[ecdvrnjjyzyqjxf]uxctotuqtvambwea
saknwxxhcybeglwr[molhqlfbvopapnuco]hbbaomsdwcfwvoi[rlvhmvffqcyftricsyb]pkeuoigxjpwfbffif
pylywhhzktocomu[sehthaaqwkyerucg]cwfmpqudeylrtavze
vmawzgbfmmsivwfqclb[fpvwdbyrfjgmidxw]btatkdonphkxtprxfsj
kspofpgsttceoft[fcqagpbfoujjulhp]fkbxvsbuwioyngydy[hnoxyyuhdviahwsf]gustmoflyrtelseo
xyiofnffruqapvtgnr[wmigiedeszezgunm]vydqpobqqrisgtt[kolobhezpsiolofxrlq]abrzbbmtlqvuhxl
enzmvjyrzypbbtmbvx[izvhoqpjgqgmmvricf]dbghstbtqgqawqjr[irvprevogenchjy]gbiwvcxncbjjvwmshsx
uavpufepuqdbjedp[itqmeflkorinwdpjwp]hlrnsxymcnxwulsmfk[bayxjuxhtpcwafadefe]srrkibtivlskepjxamu
dlwhxttrwjlxlit[atmcusmqvonodkfwqvb]ilfdsqjtjbimpaqht[zsbqjwsrgxlxbjqmulb]feblytbapctmfuao
zfzicvjnuuugutgymp[owgyvyjfhrqpuukkgok]dfkfwodxgvrdqelliaa[xaumszuhzjjsxwe]ihaxfxpxjxcbhjg
gmsgnyadjfimoemyzt[fjtprppdzhkorpqoo]eyxayeizyntiumrgk
wvdatykekdfednl[kwpjrdcfjjklpdofpq]lidlhawqalcyigapvv[ukqjuzvvxehbwzhsci]rdrfhnobcwtvivgcc
wvqxpnxpjmzfnfy[xgtkzusumupupuqvn]vmxceafgkxhnosupdkj
ypfaupbycoerlpnhvk[pjrtdmwsmsckcfongoo]bjxlfxbekwvfruvy[uccfekaoczxlyigfs]gnvkjcwikenkmvgrpdj[yrtbyzxjkmpewjpbstp]nfwcwhereraqwxu
cqxbsrqdgqudcci[olptuqqvfgunmstjc]xnppdflvdcjfviaemlm
asywjbgrfvbfnkhnc[euubbvzujqjnsxtmel]gwxqasfbyjazgqodfh
gvnexriimytwvefmo[dtuxofcgyfnaiibqx]iaaodpjwjnkbrqsmdzp[nuvnumldfhglafg]dpcqqfdrekqdfyfe
hnwaqtrqgztvegfhj[mzqkcvhmqhzwmhlkc]kytpmyhzrvtytwvfkqk
latjxjyjkwwnvyrbl[bjnilknxprpwziowcjn]zpdvccsjiuhfwrkn
nowozzvrysgsfhxd[lhgxyitirlsyljl]nodxmmwtydaqkoxvu[vgbjtbbjqgfbssytsk]gpzprrvyvseifydxz
sjihqhaecgshhhdrbto[goawszmxrrdtoxq]qvywgrnewpsordounhw[oaxydcsvrzzunbizz]nzisqsdrmmsaqwt[nmyxmrkeainaqyfe]eacdicawhfuobezyao
oyztkiwsxqcufgqk[iyxqvktohfnoymgisag]acfhjawamdhawitvjg[npflzsugezpsmunukqa]vhhxnunvyxjtehyvv
jzfmuzdlemckyiccan[rykdnvtoavzjtjxtx]vcmkcuioriltvpzzxqb[jdgqayewkwcqpkg]ulsujrvqzsmnpqgvg[lshytukyfqhnjehk]cpwbeyiudngpkrl
uruvigtkkoqkfdbqkre[wyvcwnxixwkacuu]ajvziogdmzueetqzxxx[fyevgfzreomzjbsumi]ahbhcyjbadiacwjplq[quesxyjqfbckmnt]oqehbkjyoxsyczfta
xzqfptkjpiknvkyzzt[hklpsitbnhlozgp]pkbgrwmqrbhohay[mhphptvyseydwfq]ehswmqarsalmcatb
ohahitbjjxlnkyb[umyhhgtcasbfbxqx]dxyhbvpjjatkwvpkyry
bcixbnnzlqxkisv[tapovjggqzlwlmc]vwnosivvmdcfsor[uaapwzmzarenaplcjp]jdcpazyedcdkdinrrz
kdofbgwblzpnocgpq[scfdzdrueknbdud]axnfckaaghmrpfmk
fisxkiplryvtnrvm[sypuemhvxvohsapkccc]exrrwesixcvnhzpopk[hpsilxrztuukzksyax]lixfijobrlgmonzui
zjnlscyhmjmoofha[ezglbbmqulybnvf]qvbharzbfbbustsm[tdeqjfbfxeiknfr]chpwwntytidtnnjf
qildxsfzfukzbmre[jykfpbbfelicvkqov]pyemzfzobutliokrrox[uplajddwknupdnfje]vombwrjguiukbiwozj[kcutkvgruxqqcuykn]zsbonxyerpjkfpnxchj
pdmfyadwrblhcvecezb[fhqgurbenzitepyh]xhhtisxbusntgekaps[yefgbqwocpsexwq]emmlcuwjwvluecbfo[ohehzdjljocucatf]zmgbwenmeuiftywp
xhrulprzdnbbzenux[ptzrrcmdscsuryk]ognjzqtletsyrcy[snpqabmryhyvcyztmd]lhkwhjylportbbo
xphruwdeuqibzdss[ubuaiomstyuqgcgzyn]upkpgfqmamubaqhkao[ohjojarsqpjldirf]ianntdwcgclwmyzwjh[qqeajbudidxsqfw]nenqeljkdyjucrqnsgd
xuydzitbfqwpaafru[jasqmetengbkljylhse]wkqxkjwkoipjfhkafnt[uolbyhzhmtupebneng]pcjjrczeczmoenefu
ievtjpcjrlfqwisl[pzhzabrlrdeadbtpyec]sowfrknejwbuvgs
qcuiylijqwfcqwjisqr[icjobpbxzjzuaxc]pcrdpfgwajrudfhxb[oiqtbvhfvitjvuts]ctwyepzbqlrtwuclz[smugjsqssswocjyc]lhlncivlmhmoexsrd
yqmqbdhiciqlgdmf[rywqydtlwdocdih]ofxwyqckxktvcrlxsx[rxupkwzkvwrmhuiz]znbksfkkqxephhb
bgzhbpweidflkmmjc[gxozhwikjiygyrm]vykpmxdywyfummana[mcqteiumnmmoyiwtcqw]ntczagaqoprodvhxbl
gvtyicyxseltoqfgk[eozvokbnjytodemeo]ogofokdupjyhzdgrk[fucnzhyuqkcakflcky]zfgxqfofzfdxyzetc[kdgpxyithocprbr]rpqlihcmgthswhvz
svrwqsrlntabucyssj[trbqnxxvtfiatqd]isjqyfxsoarfetrtgmm[lnwqkkgqucipvocrk]cdcsuvgwvzurnxleuus[wqjewzmcvqhhgwawyo]arzledaetbnpjmwjrl
jttgsvurypqumflcm[ccznbkqklwsxmva]ooughikefyugfvz[rzsyqmtahohpmnq]kyotvedmsjfshan[bwadbneyfitukleqbyg]oyeonratlyvtfbcrs
rpbklfvsjmisbnowf[vupfpfstcrfdxipqi]wuftflxmtftrcrb
igqcfvsqbbvpmgflu[kremgawldkinlqnr]ogcijqlgvrvbloj
ncjbiybzlsophbdemtc[zszwhtluxpobqclp]unvkyqmemvucdtwt[bzmibpkgwokausrgo]btnixophsknmjrqozwt
gxapkeestvvhodxnp[xlvglgrlzjdrpjrps]sephfhztipqaftxnqp
zalwvceeodddhqqyrk[znydhdhxhprlmip]bjijtiotyvfgyiou[odtkdhdrwuzpgwkf]kldnjprzjewdeyzmdua[wsdyljqvdmfdenajaks]zcvlwqkrytjsryab
schsgvlniqevsrjfkxw[drtzpizdeopipceke]bduaeqelcxyvykt[vhoefhavfmuhjkgooub]tzgcfhwkfuvwcif
wocmjawhtyhxksjiktg[hftunpxmlvyxauvnfj]spefcqpimqgjhnou[gmzejgwtyavnatavwju]vccngpxjmmxlruac
igqxjgofompnnrsaxoh[lmmrwzhovfloeps]loixvtpiyzagyvgq[yaiiiuvpjpuldqk]jwpjsgmvglkzuiepr
jgvoejrytatxvfqwt[hinkejefiqlrpqy]cgmvjuyjejpinjunld[qcdmwbqbqusirlxh]udhmheqsvmqmczbbofh
qffigxgklwwslnts[gwhobujjovmwfmrg]menqzjmmxrgchttltek[fwegvyhranuutxgxec]fwzgoobvkjekogpfscr
qlphzfkuyrhvkmsfxmb[unvtasxalhelbiw]gwqjfeftpkxtfiru[dhkyfsvpktyrttk]mypdaocnergxlnbodpi
pxdqzshlqhkrhzwcqkb[tudazezhnktsxxexyq]ybzclsifzrgndcaxq[ewlslzvwnqqwvljgo]nwnyptvummeraaoow
ysivygqkobbtznpxy[ydbgipznapsnkzfq]upackoodqdqmpvbgc[qnzvzwnbwrvgvwn]imcsgjzzaeltfxyhbx
hcqlfxoahajthjesrdy[nammwfgfdqnjewunwz]pdzecgfgatymrrntt
vwpdygtfuvbryipr[ehziaqbphyzzdolbfsv]rqxvfvafrauzncapu[dvqlgdgkzgpbjuihbl]sdtldsvjvvtlvjdgd
rajovnvmoxozjldjd[czqnvirgxkydoaaxr]dejvwkgmpwqvnvnzzsb[zwxifotwvljvpkxae]taoulidxuvefjqxjdu
jywqykajspyzvcw[jkqxjzfmvcrsqszgim]fncjgfxwbvfdwujhooa[otrkhmvyonynxsyap]skgdhtgcwmzixpdgmjh
wbkndoivecgnkrid[tpdmkrufmawhpijryk]untkposunbiezua[njngjktbavkmsozyy]dqotrtnnoxxejcz[nyinrkqzxnsaahwa]zpdibcyegeumjjgowz
gexzzkajyulforpnmb[mwihfmwsdpjjsnaxmme]xavowvaqybvqcqescdq[hjymwnhorqcdkoxv]myycpwmcpxinhru[koqbxfaoankdcpi]hgdktcvvxvoolccqcy
alpcsvxjoouuhjrgzo[blnjpvnbtcufzsxqn]ipijmuwbljfwuxotk[sgpwkohrsfeypqc]vqlggpiytetmkifwc
ixbszxrkuuzvvstrn[kdgfwhiapjrtiervwi]iugjmuvqljcbnmumal[ajgjfwerxsqqyrxuvob]qcdagpdvlnicajqcooo[qtuiukkwxyevxmgijtm]bgfetysdwvceqjc
pdbbmswfeutwunlcm[ywbxptxhgqpjkpeenbx]wzzaxgyiztbdftpm[lbeexhgaqvezxfef]fqktklfxugwifcfaio[ucpewlhkqnbsigioumy]cawftwrwmbnfmzmhd
xmtduxirbkbxjrqkvg[ythlqfokwjfwowrq]dguxbidgwelcrbxahi[mdumdnvbcsicvki]yhdgylmjisngrkcnbne
yzilepuvsfipivcroyu[czocwppwvwxjadgqpc]uoypwqxrpcpdzmsyyqx[mzjaguojtnjobsvpdx]vnsywqfvrnpipenwka[dtiayvtdtuyeqlddh]wpxkwbagfqncorkomi
qyebzyuerdwfocyr[cayytpduwkezuatyb]nuazweyhjemncuqpp[gwadeldyzfsvyqyk]gqjdzsuylxshtoayat
eliktfnkrxvywmvr[tlnexbwvbbdeupd]gynrdmuppfbawfcb[dqsidilgsixsudputz]odwsmpcptosjdhrp[mumunqhddegofkrpabd]bnetmxiqkwhtcsgpuui
wuozzupdubqhnbm[siwvzeelxcodzissd]niswczzlnrokkhrnd
bjxpecnvcntfbqdyqy[hjawjkugajcwmouz]ipusnakbyyxmqhyislo[xcafwiwiabdlxpaqqo]vaemogopzemmnilw
dlczcabztkrsdznjlcd[atcfirjxoipnvnoobjr]ujnimmhscetvevwpj[vnbwetjzberefmavwuy]penzvgcewibypznzpv[rqsqdxopumiqfftcb]qrotltpgkmzcndx
juqqbnfozoikxscqata[cgretlqkyynhwhmk]yiehuxyidjlzpjs[jdnlbxkxvsufsduoulo]ymrfqienfjrrgraxfh[jlopugujyekjzrfet]hqlqjkulbfsnnxyksp
epcyjxlwzmxwlulhx[pxjecldoxjwjkrndmir]baneyblyinubutjdi[cufdnjpvlwbfqbulb]dbzgyztjopciduxuo[paqntbrciorikaw]jbpsfzmzxvxlrgj
euufrqxfhnfdzlawui[zwgpectzebtpxfwbym]btexmfeuilnoqsbgmz[hvnxaanolwzkygx]hurfyrjkanhjlaz[vdmsczzhobknlhoslpg]bgitrvjaildspbz
gaweiazdfuixwqo[qedebtjxaewtracsgk]qnmuhjsbvqvcnov[aabcxwfcazxjqajv]xlhkehyvjohrqkbzyow
uqxzgyclomagldxv[amcvkpboneuscronwcs]qbeqgbmrdcdtvsc
xgkenttkfbysllows[bamxgmibkgysryjebgr]dhfiqnlocykclbofdzj
ppyfzqrjpxgouxmsduv[euokodyohaiajyvsrz]xfxsvtjasezevkjwjk
vcsgnfhhjkjssirc[kfdwqpdjaejqbfaxu]riqzqfwmwnsiqgamwm
tvxtikdqugadgbux[niaxwpplrlwrnipcnnc]tcunnqamexertrdm[xkxjepysgqqdphb]vnxvtxntrsqrfjaz[akxkeqvlxgaorhqnd]sfhwarxbzfbtftuflr
lwklfaiawghiwljxxow[oqmepnydmfkjbgkrjaj]clhguzdrfrmcoslsghh
eqtzgxqoviujmxpg[pkkbcdmlkvbcppqrm]zjzmsjmxdkaknido[sellbmhvshvqdsslyq]xuokcgfaxstavgkni
gstjodvjotzmvnm[mfvosfrnlksillaqs]riecejrjvhdrjvdl[sznhzufedvbdhbeq]msgvdfzoxeykqyx
ivwoejkryedvxpi[autbisivgebnntgixu]papdjtvhwtxgipbhes
apzalddmyxxmfysm[cdzptytpjydinlfdxa]gnjxiwepetlucfl[izgqnvcdaqkzgtpvwvk]cdxqaizjmvdnxigkmvm[cdybhclfttdchsbnyzs]xlqahfrmgnowlgba
slubhmrmovzbgdw[dehwvsngduvcfkontgs]zeiqylnomqgevvikm[oubxjfwewqtdjwacb]mqjinmndnakfemp[mccapdxlrmrevbuaas]hcjdpjgnoguztrdjgbt
vqeogkqjnfuayfpioi[rnkeynfubkpmjalnz]ybrwpzhiscwtyue[vnhkeaqwzawibjnvnos]ctmmursouxvylixiqko[voqlscgdnaelsbxcshf]azssljeollyzjjwkxin
sanarwdtnkaemdsoj[ojswyaadxpnpzcm]acjrepbjwnnpncdf
uvankqvbgxtgignh[zaimktolqipleig]mobimtizmlgqetrxkft[kooknezmesqkqisip]jdpwwsisdorcrryvyjn
lkiqyvxlouvphqf[wiibwrighxagoiod]mavajklcesvhiytvcx[ntesmbqoxkadtth]kovhcrsmmtllhai
ilzqxrlibfavovp[hrdmyejnxrlntti]yqmycbqlyitgkumdm
oslndtyjgissmwhqbo[lguvaxjavhlklnqvd]cbmjzevkakhfauq[huujtqleuzhwcbpxjf]hiitxzclsgphiembgwx[ixccjsoybxmjmufm]knmagcfohytzcoq
eutljtdlueiugunxsy[bmbgyvpiruvvuezir]vksxzmgftqglhrowpk[wphxqgxjmzhuqrwhce]giazmdryyjldglcivd[nsicphjzfpfzlhfymh]pfpeazmsdcttsutbs
tmdniznfpsrdaivxpcp[nlebmzzfjfklqixhk]sbusrwexlbpswiyslbh[tuvimwrkchmarbvl]ykhoceojfjugoim
vjkixsnkgnhzcsj[eqauuxevvcbzmlrvxk]owiikpkahbpkpuhkmns
yiomyydjxljwyxoeh[rxyahvmloktamapez]ygtodyeyjtqusou[esemeduybcbngynmzl]rxszjfhelknuyjq
hayzvqcfdjowlfeavo[mmcaawmtqthurqvmlfq]kbdpwcduhsjfbskcin[sueeedwjrdazxpae]drtfzfbefgvneiiqtsn
lfsgnugdavjvstpk[usjflghmtbzdzavzgos]vajnuirkzezjgkst[ixiusdyawuqkbnacri]yfhtwiifnoltnygk
fqvyvpipisvelyjfa[xewusykjjogfsupar]icdydlsidbisscyn[bpibwwfzoqajtnxlad]potpbswobrhcyvy
wozhxjyiybczbhbqvd[kfsajcbxdespfdewbjw]afcsihkfitjosfwxb[fngvcuammwspeglx]xizamsngscxtprjwkq
kmakicivcpvmjokl[rnsobihgweztudwrql]wytavzsniyqrdrxu
nawqmyenftpbvxo[nsztprtyzoacbxy]jiwvrmgzztoisveafzh[kgpykqugwgvfkztnnz]qqmehjutfdzzowkof
mxddcacabljlmyxmpn[zdlffviwrbhbjhl]niubaphkzsiybwkmh[ysxwkjpjhpyjmosgeo]kkhqupjsegymyxfh[sxxdsrtuwgsznnvhuy]licmdzzrtcxkgce
hkvugidmuerakcmmsn[mkmrvpqxfoghbyxr]brkgsmexzyvqztplvgo
inbjfdjjfofwckfckfo[nhjqvxeoedsfzfpwt]snlalnxxyjihecmxl[qtoxbcyxxtvuliams]bijqmocptaquusurml
wmwfxoaocwtzuhvenl[yzpbmaoazbchjxozl]oulzkybjweqqzml[ydkamvkncxomqsibme]fcuomzdfejvijxeniaf
clyxvevuyzylpdud[jmwhfhkzrzzkawp]nwcvtlwlwnbebgdz[cbnfsolnppgafml]mxhbrzrialopbbk
ekyvudgmgzgiomwt[ebcbzzamsuhycbcvc]gzmmgrqbbuvbzfebh[lyuflvjhaxkfxkv]bvnmyumtjzismbtig[nqoxegjljmzarvyowo]rldakoyzzgansfefpwr
wjhfgmicaoysnhmcer[kocbthyqjwsefyepgqh]vvzlwheralmhnixsb[adysumyfpsahmkntv]bnzgyilfgsepwvrdbdo[yqcnxfvzlpjxnvv]syedcecdzbffhmpztd
qdmvnazvvyyxqjkm[lcmgrtbttzwijqf]gjacmuqivbcttnp[uduzbmcdayazzpr]vabqjkbgwnjophdxwvr[yyljnrcxwwcehamtg]psdjpizyavaebua
fzjlpppzspuaflfwtv[dqmrdnatqlqnvowh]bevfgmojlmxmvfqb[smrcvucejxdrppkldvg]nbagvxquhrilbzi[dtbbwkaqepopjtgsgnz]zebxmxzzszbxtqeyjmd
kipuoxmzbydfycmkxcx[bfmjtzvthijzhezx]aiwnfmjhetyrdahmi
hiekvarctkixnmypau[dafmuxavuaosooos]czvsosvafizsjiouwi
epzppyfkcwcqiirpm[drxvceywherxdpnxl]pzylclelnhztrgnqb[qrmfgrtyqmlnsggg]seaeqafycqwjfccuyhv[fnwvqeftfesdvyu]djdlucfogiqnrblz
ihjtuvxjkvzqdpepjd[xzmyhwkdjooosritpw]rsvwysjoukgevdeve
wdgepzzfwonrsxprc[oefuycfwngwkrgklo]fbckfdmwzzwfiinlfhw[mjebaresrtulcvkeb]aqxnxzpnqukspcol[hpfnupcjrkswiwlgzz]xbnwmtcsqwbpkxys
nbaxkwtbtodcuecg[xqoetzqgjhxmuvfvnoa]edvwhehydqhhfjm[xyepeppmsepsaixyisi]txxbbqwefwuffdztlnc
aqeknneydrvnameefot[dduhtgzqtjyggmr]ausnandgijmikvgd[jjvsfofhypkfrrc]rgzmkiqggfaesoznlxl[przqmabciaxkcunhy]cnntseafxmnjldcp
rxilrztnhgzclsgy[yaxsuppphljrtcxev]mqyqgjopdetsxzmutjk[adyfostrkvhuajndjaw]ikumnitoxctaqcpop
ntotlcdwgtsgotovhyj[wgduvgtqijgobem]hhdytbkiplykiejg[sntkfbyrzgguijtwmm]mpxnepfkhssujwhegbq[sxpsxodobizsvppqptl]uqlqlsopbfmgliw
wbyugpjhymzlgbl[zdoddxxbnxqimlo]tyaobecgkbvrmgajpga[asriovkglwqiukcxtjk]nvjqkrzxwicfzdr[vzqasgjrafilljt]eobbqeenineqwps
xbtwnvkwrlnwseaids[znlftryxezmidoc]suigxfrnxfzeudpi[ahlshriqmozkpiogtc]zpjiwsbdawhjynju
drjfebkgnrcuqyzpezw[hnweqviwyjtfrwpu]popubobnviqwkqfv[plaxjplhmhjqjmqjsh]idacejabrvhfteelbiu[hhxwpwgvjcncpjcovv]tqyykiwalnnkoniju
fwdnjlvptzmxpwvsli[eidmcurldxszfvvhjf]bshskptweuzuqtjym[dpwmmspdxpiqidrfz]bulnlyngfaybqfinqn
khvidctisgemoswq[vzknkycuuvznnjkzay]rvzkmucboqomxkmtuvv
ymfxlhojyjfqvctzue[sihfpembvmdtdda]wezkljquqtkcyiar
cgzdjkbnmhptcggqib[autoeqiibhxdief]zapmbimuvhywdtsbtm
gilwnvmvdyftcdmvaql[esmtawtmepovyih]quztpmdplotzlszav
sfsncarxehtgmutj[aqauaojoqabkguvan]olgokvyhpfjzyqgvbcy[fsfdkbxhstvxlkzb]ozwgbzlhrocqpjoseq
shzexlixgxazcobmdvz[bvrebdcpytgplvii]gxdgzyoqpmkqznz[wuywofxihsgxgpcksgh]lwqsslamcrmkobn
pkjlltvbsjnfarycgf[gwkayyieahfowbrgr]ccgyjvjbdeoilsznvbi[njniljtubngiuwlil]kosrulvapzdufvq
clhvakestwquwywsohs[ubwecsjptinhzngw]dvjcvukpkdrgpbeua[svetegijnnbtetpgfu]nfejtethkqavpol
vksryzexymetdykenw[etxzvunetbovrwttr]pnmwnldqzmxzjldnmh[vnskreneiwajgmd]rwbeletsldocxguy[agccpaxhrlfokpt]wembexaqbprlrzg
wrxyiatlpvvcuroguv[hfcsmxesvpwfgtpqip]jbspeicucxtbnti
gbxyskaitzeogoej[drokshekgcpxpgktoi]ivxtocmlrugoguf
sfzpstesdmegcuhn[drrpxmsfpcjvqerjb]jqcvoeifgceremgz[chsbisfayixexqer]qyhonslazxrkagpp
bfufgciknfkthfbr[tlfmuebscorrclekjfx]offqunmqlcetebpov[bsbmhnbmmqmdbpnt]knkjsvpmffjqvtqpk[bryxvufxbsocwnd]hkxplkqhsymumxarn
ftafmqgtmaazvmstfq[qxsvdxplpesqzqg]yrbkrhtzaqtygxjheuo
xqgmldfvsmitjzhbr[yrwujpzkzksxdbthk]jblnpmdcljgadym
ijtilnlhxlkhoaftet[rgzfrfsilxhwgpzx]gmdwwndlvtvvtdimd[wyghkhzahfwpaknrxiy]ekpkylqvvxypaszcozp[hjdwslazthbzhdimne]xuptxflgcjgdajfgqa
ceklxvygwnkfrqvwd[qxjqndmhxzvhicvcf]lvrzumjuaawtgviue[xdvdtoulmeaaiiuqa]xveikrwzicxctyy
pdvdkirojjubchc[iylcutkspnuquwdc]uzbtxemzazuwottv[sojezpwrsstkdwkses]laokggzzeaobwfus
ibuowtqicxqiifze[emohxvujvolopghkrgw]secpljnouzblzup[xvpvnqvnsgsnmhwdpbn]ykpvwjlhtpdjlflxvye
botbhhrfjqjqwdgmeu[itwjgbhzrqnnagvy]pzexftzhniligeyd[egtdkuktihxgmdd]cumzxbfgryzedtsc
dgvuwphikpupaovhovx[nbwxxhepxfzlxcoma]vypmvuopklupuzlk[plkvxscxriyzeln]sopaaxvckgcbiahm[gpafvifmxvjouczus]uyqhgsdxkcylwle
gufjlajgktlwahsa[kwtpvwbvjzpmpbstiyj]nqkkgajutaofdauzmfq[zihotkwlyixmfsp]fezlipznjthttsiwpj
lqriaqvyvawemnogd[gyqqrvivtuxxbzf]xqrrsgnxbpmjsgqqr[zfwpyfwojhemhmyoajq]pyninwzcjzypmygy[qzftysfhztknzjo]zyybzurfxiolsik
iojvqxazkhdwzed[jnnntfrduoxnyqpeszj]dpeducyducrsuwa[rnfiudvklwbdbho]lklubgxkqldqalvh[ogbeiwjdaeuwjyz]cvhoaaenmeuovocvog
kxtwtkvaixeisgzjky[cnzhhsipmfawaqzc]gjpptvjnwmbqqbuum[qryazcieexjwwsvfi]cysiabvuldrkvsxqgu[koflanzstuwaebjih]krzursoabnpundffqs
bzqcnugxfeixhnvk[sjyuxwjdceauputr]tcjsgbmvjklijlowud[mdmuqbpupxhndvfcd]ypgdbaxwopztyqelfis[bvpphfvdscmfbhynf]vjaytjezersopuqa
sceyeinwgkcccgn[sgxwelfgqimdwzlbj]uvyuazuplvkhpndc[etahwkowloxlylnp]hletqjpvxzicdrs[kyrfwcyoudjlueqrvr]kdqsjyoajsfenmrol
atkckckrgntchlets[tyebmdckmayofez]hryglgphkgeoswe[jeamxrrzxgyzvmuh]vcvejocdlauybbz[lnnricpcvqztoumc]uggeimsqrjnppskl
rutaemkjlwrslmsp[jwwgmphxqlggydlsh]xdudpbdjfqtcgrw
lwddwkagigyjsht[zpizzqoqkcbqmdqfqp]vbvigihfyemwjqusdh[kqgxbnysneqgxdwzkpp]issqguyhzmttxofz
zzxsolnnbmerygtvvk[bhfexiwvaohrbqbadi]zdsieuxicwijamvo
lbfovxmrghyzhfdybb[whedwghlrxnjtvqelzp]oezlanrknbaxtmo[jtrlurnbhmuymfwx]puvsiaizbjtqnot[rssajpiwyftzhoacoqh]ihmzohwlncqrfrjpbpn
mflsnlcufwvqbhye[lslradskdqrueaxvoez]iyrdzgwbghbrctrmdt[bqgxpsiwleisnru]sjwifvnufaaedueaag
rcdjaebyojixvatc[bjybjvqonbvdtyjwet]rnatoqmpxauyiezad[ltcfporqmmavmsjgmrb]sdiogziluykhmgcjf[bkkhyuslxlarrqbqe]zzsdsepgilymdpnhw
jikhvuzivjikuxkmlus[vsgrhafeosvtphzg]bjhxequjxbqorsnhx[pvkgxrttjofimfuq]cmrxlinhwqxhrkrdzpk[xugunnrtpxbnemj]hapjbouhnfydllttkdt
xsvwiruapkldajmkyx[iohclbiotvabvkhkngm]qfvbpipvniprtqjj[ehcphknxkybflhn]ackdoidsuczifwx[bdbekqnxcwwskgxp]ofvzsecshsgbqll
rnpjfqpbnpfqtlpkc[itzrqowsquwryisqywl]mrkjwermsejxwqubxwi[plxkhpuflnhspjficnt]djldgtkuzafchfwar[auijeassmbtfdsd]etfcwmifwixeffrtpco
nkqwqvkikgnmwcnos[nmvtwkyhwtwyrrupx]emdniphxpavkede
tkcdryrjllweves[pqdjnylpftbbktemtkl]qlykuckixcfhwuczikv
cfjwosfrfjwgwognyjc[jiwoynoxdngalmreoq]otqvhbkwlkpqatkx[wwgwguxuzwlorap]rjuopkpuaftnkdeg
icgtjqangadcebdax[wyosawgqnexwsdqq]ulyhqvrzrqhibudyu
mrrdimungjnszyr[quzeqzycxcsamewykb]vqrhnvflewxwzvxwxg
aciggfsvhpeaemh[xhizavbtwzpsxdkgzdl]dbqpkvkmrbwjcle
ctxwfkazxjvguatxus[hkcjonilmmvovjawir]ruwyywhbhkrheofbpr[qeknvkabxrdgfxgrp]hymknrdlgolmqrpklal[qbkzigpdxfcgnfhdrqr]hrutorkgyzxlqlujnv
ocyqsefzuzizjllui[ttpjltsmxnkavfbviwn]ccfanejrzrghpnb[ehkgwatoncpnwfpjc]qkwynkumqgvxuslirgg[vrnprgoivxrsqlpbmke]jdygjgsfkbhrbfc
necmpldghpppjggvw[vtantcichlsjgrzdxlo]bihypdunzshlhxktuk[iusfpqesheojjdmk]ycztqgqrqsuifzgnqvw[oyjhytgpicigpcf]ewrixdzorbmmxgywf
tsddziihnzqushtoeg[ldqhzxrgtfkcrhecrm]nnesvhwbrujwmon
rdapxiunwuijmxrqf[qvekjcwvibpucemj]uidzbyozcfnpempx
fdvouzrhnlgyemqqqa[rosijdvpwbgnxzzr]moxykttwbfixxvflpje[daadlshdcnrwftzxpjj]pgpphzgfkeapstad[rptqkhjmanvnfuj]drurgqqilijigaa
dcdcoboftwhtitlto[qdqpbbobdncixqwhmn]cdjrukqmcdbzwji
fsmzzqlggnjqunemec[oxrxnckqpvilfinnolv]mgpmmemxrkuonag[wsoiyculboqjnux]urwswywdpuesxaq
gpughkygfkxahewxsip[licxlfgczxcqejs]idnuezcmwhwgryjare
shoehgaydkpbxwshf[ksbdsdldhfsxjipf]ubrrcyykdsgnywhojya[hfjwtuughentmddwd]wjpsomayxantmltuoep
srpgizgochbueqgg[qeqltfdohredaspdbmy]cexowllqgvorkapnkc[kfivkiksqxospfw]naiqwxlkjowysnh
patacqalyfmxulxxtkw[hyxkhrfewkpafeel]thgckmswuwcjgcuepp[lsfmmxuvmiyyzzxu]yiktaounkhxoqzm
maeefdbswszxotz[sdfwswrwotoblvzk]bqmhwlxmzvjnorn[phhhipunsmqfmormtk]aasvyeqeffypmcop
fhpaqlgiumuampggbha[tktjydzyzgbpqosq]dpqodhygfzmbfku
iotcaohleclcmtwp[zirjcaznbsuwrbbspl]vdyhcyoroztlltnsubz[nmnaakmudmmobxzk]xjxybbzqfoibovwhr[tpzyhrmupmrfoeufsv]nfvtlfdnynqiwrmnmt
bsadpcmsvgfxbpskka[bqcswpjvfijomiajzjv]zjzfrshleucdcwpf[ipqvielmzuykgbs]rsvzmpmpfahujfofx
fvryaokhaacjqgah[epbqswhzewpvaip]cuveezfvkvejvvaizr[hlhatamayfeqllu]ixwqbzzaekbgxkmhzaz
reyvoyklzltgudphp[oxjgegadnwxleogg]ljmtypolhtjwpvs
cbihaubuoteffoyu[svxjexmihzibcqb]jzdqjhmjgugqyur
krpfvdsywmrzxbusjl[juomxpbfboxgvkm]brhpobarqecdmqkiwy
wsbwcjnpzputekmilg[qhdrjrdtwqqaqsymipv]fyrpxnpnbowlhwkcwd[wcxmrmmzlznnrel]oamqtpijleztiuknf
mmjzxbxoyrxkyvdtss[cikixrlteokbezfi]urjcocznnivoqkf[wzqgjmuuvuniccrj]eiarnnhreduakcv
honratmzckbtooiwan[epebkioukueaexbb]xyakukoiqfmtdhvxf
auczawuragikjbyg[xqvricdlkrsbnmjqymq]uwinnxrbwluaanvjyvz
rrpjxhttogyefupw[cidavmfspeeooolb]ucfrrurpkeqltglk[ulptzlfrcvniduqkc]bytebcgtpqkknxpbh
ateymyqwgrjfwemgg[xppbfkjrlnizskzttbw]genvojuvqaudosfm[psnzsxmpjtdbznh]kljgvgkdvezzljte[ovfuojewcuvcqrfdzsk]kmbgrfpjzllvrbmpimu
mrvctdetjidibveb[msvevesuydbqwrytbh]yiliwznzilsslmachk[mqyuthyalilcmdpxz]ctawteeyyrsbncp
xhqazvqcraogaog[efbpamcmboregjesn]vinozerwxjyrytyd[vmzmjnevhaiidnhiuw]nvzsnlixrdzmzvtgfy[veacynylxxfkeep]syokzdwmkkhirrz
swavkosetgudxoshj[fvzlrzpjhrbnbqsccn]hlvbbqalpdfefmaxdse[ekisavmzzlowfwcmqp]hutgwyxxcqjdiso[vraskyhzrfjitpxakqa]rcljjityeqogidyb
hidnzkzjrekzkkqqpj[qvvuzioihfbxhglu]nzlgputvbrvwrchwhzc[rimjeexwqbdnsdn]tfzbpsuttxirwszy
wiubbpcsjjmtbnd[thcllhnafhmdojqr]viplkejozrbrwacv
jaywbjoscfdifdfalf[lvouibjhzbkxdqd]mcxggciwqqirwcyps[ztiybfroldnlieeg]vwnzbrghyfatjsxsvfl[jenhflndcjmgdojv]uyxvsnfigbtgaemccz
uutahwebslojhtl[affybmhohxqavah]xocumtcofvavgdgl[xlypyhazihrgfwllp]ptfnqjlzbaccyoaawi
akdzebybusompcsooz[xgymxdecspvdvkgit]dtnhtzkelcazovecig
jqajvhvbrkrynxg[yekfvwkborakrkfl]bovxzhceonjclmgecgy
ilythgztqwpxktjrpf[igwywudlvdqpqbu]hxmvjverypjvjtk
dbkmmuymxedkowpcws[kxtthcqfurgkuxxx]vkypnrqtmhlsqogt[rtixamexlrydluvxe]nbehtyxipwgvefctyaf[cxtipjkxixrgawvomc]ssvdpknocgugwjxpzpf
fidyxymrgwqpntyg[loqqjfrzmidkxskyfsa]mqilmzklkzhzedf[mitpmedchdhhzxdqpl]roerrhbijrjwmsm[quhrsmqqujwufnm]layxublhkfpoykadvcr
njsjelrfstonstmhq[crcgsmvxndyvyfsjku]yvyrpgjnuimkxcutgvh[gwmbqumupsdfrusp]sbedcqptxzhsohroth[wudivolpxauvxvxbpqk]bnfygsxxzqwxumonnm
ivtobvcmwywqtjkfa[tcfyhhgftbsswpnvbtv]bkuulyhtihhqcckjo[lgnkduoojrzyjhby]uwkeujommiprdopgche
mzrhrvpuyolqlku[rlofuuumtasfuknrasa]tfhglvunxtkafazyehj[hrnjrlpyjntwosogwti]ixtpihfavwqkjnlipmm
jzhfwqxoqsgnrnex[ccrtrnroigtbvrnjeji]bbhfsodufjqhjvplii[mcubmtdgwttmmnazhpt]hovifldmlnbzrwqicaz
hcchhpmerpjppsj[wftljcxoqwtoclz]xihvvfjfhefdkeip[abdthspjojqvwxx]fhffpflinospcczm
vupulseekbaiaoempu[zupmjydxyobqbfmy]xkyopqxvogwcpuwnud[orgnovcpbpqecljkaq]sdvcakqwdmgydeeup
wruccyxbyiexpnka[iirsbfvggokpwli]gztvpqcsckeaiqofwf[zdloxqdlcazkhkppz]jydaafpuoznegyif
lwxqnbbzjlckuji[bzxykmlhlgjosvs]fdocjjmtlhlghzvj[snveavqbuhnzqktmyur]xcoabwwqxexqzakbrh[iqkdvngcdtlhlhudqk]edydfxflcnpzrcjsppt
eokcsyiozfqhcbzffj[uiczyrevovzcgvu]mniuhovkpklhedhx[gbyzowvpnxpemkcrccc]avfhgxxldgtjxuy
rxjbmcovdnxoxrjter[ijiplhrlromkesgs]xwtfawphuvrjimntwvs
uuwjtmgqskgrxrlzt[nqzvntwfmxeptqylma]gbahtqxvunohprsd[strhrrwmxsuoiuvi]nhamfjzlocoufnwbgu[osdxgghdsdkbqcpj]ywmalngfjbjymkz
vsmcjtzwfubhlop[ttbkmxwjonmuscwi]ikjuxrmqhqldtfzqa
oqhkopaodmimgikwcg[biimzvsoczaxfdy]bkcbjbcusyhdpfo[vfnzlymbwetzhbcxz]zyntiiipnkmsjjemxq
hzaeznnipwioicdfa[lperfrgxekbntipyf]mnerflshwywujfsp[nrkcmayjxnxbhuvo]mdxovxksmxlwvkbrdf
cuqqyiwojnwvbybcps[bujmpcuovhebtztm]bektaixvzjpofzb[egiiqzxqdlfwoukjyiw]nqkjlpwevuxeognpnq
ryxoyvavwharlbwzeq[rphqbmnaiykgafsftjs]ijrqxkvnqersvvryz[mevoiitcztvfztorohn]hkchrvkqswjpyay[staoxhiuifnbmxuytlc]fuawdkujedmkpeto
caowivzceqsclbyp[grpcqqthiebrabqwhxv]bzmazhewqmbuhjokm
uhrtxyxnakvjydnroc[fhnjxathwyyxszmo]zzukeuqdhxravrs[zqcltmosvkqcekap]gjartckwucksqzcn[smddsrvnfxqjxya]gkumdkzqxcqxfyhm
ldzhaqlkbxfagur[qvlstlwnkzbmxlxw]reflsfhdsosjaaesps[qajtodlxlfrbdlj]bxytsckpxumuoklw
ghjjrxtnytqatjfxwt[opmvopscrillueslb]zsxtxstrwnyzolxk[lyeeidvaghynwkckr]shhkellgnhsuekrzoc
vpliqrfetzttovx[nkmmjlsskjhnyxh]ayockmlevegaseq[auzorvghfdfuuajnt]poknhujvpctqrrycfun
vzgpmpjvlzbhzhlexp[zheyfmgekvhjsnmosaq]krmficowypbxwbztrn[rvoedtkjlfpxtaot]rxwejzlarsgdlayv
jfrznpvhlbchvre[obxfauzcchgnzksp]fgimlwasdrgqvquis[ewaqnfexmitmuxhqnp]graisawghismkouwfv
nqmcashwuluyxaxcw[fdqovhbtwijgklubmon]dgxewefrjkhrylq[maeguvhvptbgmjdwhxb]dkdmdobhsbyforzmqr
huwexxqnjlofulknxz[qnbpzxlpdlsqrti]sbmmwvryxqsrfzpm[ucizjfqroaflnixzbpr]ndztjtaeahzmkyords
mwlrbdybkjhgorutus[bmbedqpcsxwkganh]ttwjrjrvxsikepdbvgs[qycnjzrbeiiplxarls]atrevpowofauioaof[nlhyhaoljptrowlmyo]hmeaxvwasyaszlgq
tqsmjetgtzmxfgakjqs[cbnxrpnckgcndpcwiae]uavavaewuucokfrm[viufzfvvuiuuehyxcw]nkskrloinkwsoukw
roximfsrbnzyzjmn[bqugwcdliqyzyaqiupv]rpdidncsfgexyncbg[amzmtmqwzipkjfy]fqnscfsjmxjlpoccvfd[bpebfxoinyaqsgjpb]dykidfsbcykdobqe
rcmbmjwgmwathepxunw[uoieoiytmrywrjevift]ourmrqqatqnwmrisyu[bxodgsozbekrcuwf]gkaigbulsjxysdiawg[kczakejsrndvzdirs]ggjgbhegtgijrdz
xtksmozdsgsclsxrfh[afxjsmsjpuqnomb]onqkiyrogyrkykxjr[bhvnrdaenimevcx]snufewjwvfqkafjjzn[cquvjkzxpbfbghmnpwi]wjbdkkloxxgsgnmriw
doruvpwqkvibnww[uslnnvqcrwjlexech]cshujlmmujfjdtjw[pkbasqruzspzipwrqke]yypbzzqwoasgldn
aoxxznvrxfhzwyyq[byxxvystyyrlzvl]jnilbnasrzvgbbhrl
wvtujbbebuyuazangzc[moooepbzqolouuyxij]vhqrubkyyuypknfh[gvfucxhufyyjefei]axvrkaeaqlxxfip[fiazyighxscxhiwydc]acvifmzzltvluos
yzyfibzwjuddaoxc[gpjgkmckxctlttgcdcm]rmjohduchcituck[noozqqxrakiadwu]mipigxbhlbtngtpcpz
zipobscyynjrecng[jeekozoaoyuuqmroisx]tgffoyomlggbyjnnv[mcfybdsenqhygjo]dnzrpghyroqbcje[aoapyvfyscqfzhihddf]vplszbvbycwxqrhb
gcoyyfxpuufglqfsczx[ebjwlqjgtgkqdeike]xtuuxrrbgiwhwqdcyw
mdwjuxoulckloxfujkj[omieaeznetsnkeoroh]ggnwbuenkgeujmap[ghrtxfonaxyhfogpjub]ptyopzxhctssbwlpwy[xmpglsqcnihwzgbgm]yqmqddmugnlrbnqkgci
xeayvddumafiomemh[euwluehznzxvpmzbz]fxcevhwksvwhrvzid[maotzdveeldpyetguj]cixjfwlbbbrrqmnoklo
larctxbpbdnbpqyyz[vzooyuwrgpgtjtq]sgizsbcjteinyxto[jbqzsxejwwgrpcgzwrj]bpwcfwyglhtuxqmy
zbxohuvlboydqvqhhkd[wgcjvlrppivpnxifvk]kmpdiwdtpmrctyhy[pprsqaqxunduprjnjxx]zfbqlbdpmcgfwenem
ghcjhgkmyfejmua[mqsuukbcdvjmdnz]ixxelnebxjrtrdwzlkd[ikojyewznghqksregl]tkthqugytcsdudoggp
hdfwyjganjbjhbjvswz[bfaxlkjfrkakeedg]zrkxyzbozmchfqgz
inmdmdyssqhykuhn[vbjasprzyxaphygdg]ucbbhyvlsjjdqri
zdyejivfbywyaaqljp[sxmtwgwmwbqelhsg]jesgfubnghtsagcu[tofvxzmzzsnywhbx]ibnbzcdhusdiqhgika[sipfigjsngidlzxxneq]bljavpomkpqzrsuuo
uahcmotfanpvzru[opmqbnngxtudnuyc]lsvafzhwwwmoagl[kzpffwsffxozirgyz]lsbjnbzflbiprwuvurf
rzietxnbixgvzxnmzlj[iygcirkrgwwsgpcidzr]bfrwgfeyyatmalyjsl[dweehclvlbefvlcp]qurpnzinmyweipshzs[lgbfgdjhddmtvbzxu]ppxtzzkiizoqqguct
zfsvifntrvbjgdcuc[jjwqwhifqbxeqkbigcl]fmyuetebsksddti[hmopwdnxvmqwqflr]jidndiejmzoutjpkdm
qwnlstjkluchubgkttm[yyndjrkhfqrxuyglebo]xdltobqidrkstozk[shmmslerstluurc]fxkrzqnfjoalxcmssq[bjenpehkwbxpktb]eaallvedtajrnupomva
zxqdqrztephcpieqdi[rigecfyegojksvjmya]rgygzpdzmpvogeurni[odgdyrqmqgrcmhfcu]ggdgejoiritcrdxxu
ezhzkozgllmnompn[sqyilkceizeygqkwot]pdkuklrqdgtgoqap[yvadgqlkffoklshvf]hkgwcnlbadpbiuzvkaz[oozjtyzsxujalkwoo]dhntuiangtulscbzg
zvwmdxzivmtzpkmhnp[qduttqlbrhetmuj]vmykluzepgxxilmn[qgswpbooccvoxlg]ujndjzfubkxmvvdib[yrneuetnuktitut]vvwnzxosnenywomkyj
phuncbfvyiwxfour[oauntpjxaqvwvqn]liffvpoxrbljogpcwvw
usabjelvalpgdyiyn[hywbrqfeqwkizwnxf]ebpcgxloqmzflbeag[dxifrjggqwzokner]ndwzylxxlkdcpbk[kfergfdezgbceby]uscylihvxfbetfnog
afgmwhqdwessspzx[ssbmbckihwjmiaw]zbbiktbhykmehed
hforuldqhrolhqsm[gofgjhapikxnhhdn]xgdarfanlnonwdielb[hvntptxixclnlqphvq]hvvdpsmvsveyaiubt[hiiscphavjogadmj]bbfjdjeecrhhrspxdpq
djtyronibzvtixf[yvofthnckundxfe]eccattkkitxyotbziy[afdaacfefrerytfh]cquizrjfjtqgjozagid[xkbcgazeolbliwp]hukcarrfnjctdycpfb
egwoebxchfxxlrr[hxugiprrlfwmknw]cpmfgzxzakyhumd[evzzvvtjwwzwzywvk]lwcfpjlcgrbjszjvf
hktuhumsttqsgfltrdv[rctkgluikouomerrv]jblnggtkdhveufixx
ejjzogefxwuyadzthjb[ibrhegtzukygkfnziwt]utcbeamzzfkbrmqonlu[yofpkwiuewvtbswaet]zxkgoommtfxezcfcweb
wbauuixpbtjnuos[ozwhlzidaubnfiuiqa]nlkdtbovsytnvjz[ztfjpnzvymrefnt]nixbxdoogrxdvuxbxbr
xadpfckydqkmbvbj[vwdzgyfbjlyslafrp]mbozdmkfztxwailiuv[uttdatknprbzvjvucxh]cqcbkumzxiaqweqfiry
bsdbnkvvlwpezlhc[cdzdiuewblcmciggdgp]halpvjdbnpbdrnkz[ikoyxulwagjnwego]twyvbkffqxasqbomi[ajwtpvliyyssqjex]cfbqtoqqlggpufbfx
qoqtovwkavyaqbkwmd[vxuqdoobfxtanlwd]zklibywcjpksseelw[roqxvvoifjmxnarqvt]zeijltexwykdvpd
obkgwgtfxwjfrepg[slekjheburvgrunuaxf]cnhsvevmitpuwokwee
flulgpwvsikwhpzpza[pmlcfhtmvuiyoidfbfh]czcxxurdakbxizbbfb[blpwjusbzbdwugwbcv]vltmmzttxuhooid[hlbpbqjpqyclebkye]hgozvhgdplllxiio
oupstawbevsasbhv[ddvybaqnhfckfvdgabz]nooqiufueyoflccqzc[jyljuydjddholsx]bbejlommzienlhz[mpbmppjwfqrgucxdqxx]sjohlscgjoprsqt
augjtgfyoatluixgc[atdsbsouunywohfnk]dpghgakdvfscbapsm[nkodybopavlbeikalqj]myhpkcbsbkbjfgj
whzlsgvuspnzdunurbg[cypfmgrkqjeppudbdy]civtfkixnmrkqmchhg[ypyakrsygkyvmfmmyf]blihjslfkbrysntsl
xeyyjiqvduxcflt[xiqxiqeepbpkkydtzxs]vbpbdsaivyavnfwj[rduzjulshqiluheud]inliammiyxregzbsrkt
txvixsvhvmxxsomvo[hgdskyjskapgvyiqzsz]shvhmfrbpxbndsx[plvytalszauhmpkr]jyujmokrvxwmanzbxbi[mefmngrdhatojkpplcv]dttxfesvavgpkbtpri
pproajkxqwedocrc[muhbyboayoghprmbtxs]odroemzznotffsaxsmg[ykfnecchdltzosnyby]nozuvokzntxrnitq
rqimalibychumvzdq[siqhwfjimixscjmne]hkvxsavgjvpzkyay[nzbxnmxgmyuwcywvd]qkuzrfifsyvonaalxu
rymadifucrlickzorqr[phxxuxpffvnjgofl]zqfbhfmzbvhbmask
gzuklpopfcjdrxoekz[lwviuuoyojzggqjs]cyacdnvkgqqafcyprae[iyazavdiashvzwpgip]sztafbunqsyjtpz[fkwjsbllccbrrdpa]dijejdfyzqycvrdkl
nhmayligrdtlvyeo[laulduejrclodvnaoh]frxoepqtmqdzwwupiy
exzcpmjdjiagpvsvin[aontczoixbznfwsvss]hdlmrrdtbumlfvril[gcuizdwjbzyhttw]apadljkbcsylwgekv
pujkeovpnvnleypqz[ecxuhbtnrlnzojsxs]eyolbkoatzbwvnvwxlx
oefowwmlhqytnxaec[rdbjjilbmiazndcycr]dvjwgldyxfrzicw[fxpbshhafqifvyju]ygagsxtxwnsphgzqrpv
lhbebfasigqbhndgsux[drchunjaqzkcmefjys]nzloazwftxoemnmifox[gjpmyydbftxggnggadd]onlcnitfjniiekbiaz[swjdwdaikyykupgyg]ltwxeordcvjfarrhx
ukvzfltucnovohjidr[apslrphaneessxbpdx]cxrovjkruohahxshazw
xnsrwrjioindnxhxrrn[mvuraryghmwxppnlp]mconcxeyryuvfqcoy
opafehetqedyikso[vjnjwsjlbiknomzuu]pjurldelcuxkdlhehm
kvpcbopojkvzykdhm[ldleeqmztdnrohjm]vejwyvzvekairyhc
yrbrakwltaduyge[qwvsxbxwiretxirlsbt]hdnwansdelcvxptiou[uhibherodkibtww]aphfcrfnpewbrblyme[lfwjpxyosiappsd]rshmipxgjvorazj
tsymbomuywfpmdul[wgulyfhhwodplfi]xixmazxgewasngsv
ktywwprbuvuhmnpwfoa[fcuicnujrweusdoe]fuarbahbvkhqjibcfp
snhkrkibygzndryeblm[pykdztwnxrawqbevu]wwiwrwfcwtirdkjh
xhomjlsunzjzgkxc[qyxzsooayiqnuzljj]jftgbnqtumwipywdfrp
mhfgzwlocsrhbfkdbud[kwtnglxzzdwqcfw]ezvrdgdyjjqfwuv[abznvdwgiisyqjxvu]khcfgchqbgwflioa[upibqontzrahabnpi]tgjaagwvmqewmfyer
yfptdfhnebzhgpzism[tglibrfrnpfmydwbea]mmoqveuvvenorhnrw
ljztcdworsemcoe[yloilpxuumxdzzxl]dyawqaacdnjlttcz[dxyytbozmlibkocr]dxpindavjlezzpogz
bwkhzerttqexrgoea[ubnuzbvktcxsxednmu]zqjpbtbzdcfmidopdy[malphrsrebpeeuw]vwdlaafkntcaqmwjqc[abciktgfeaiptay]yqksuqwsuqtckkoyh
filqrpdsqqfgkcu[obiciozcvbatglnx]sjzgtjuddnazrzfcju[svrswvhpfraptqsxolt]nfcphmwaudhrnxkzc[ysohuzukkfqlskgkd]nynxljuswasofiaarc
desdobciyiqsycj[wzvqcbwfbneahei]svofzhyvvsrwasvvg[igvhymbudpcrdgjwv]qtyrjtghnbbtekl
fygnlyiuxapyciwwnbw[fhwxcrwprlaoiybnkbe]fxvtiehvhfgfwtsdfh[mreawqbzyvkbcnkyftm]rryknthocegscrdtbcw[ktbeedxfulszfogwnqi]kqwtzaemzwmsloi
zxroedxtywemimrje[fvzlxeqgczajhimr]lrhvziwtgglifto[buxquosscraxroklx]pryldzimioibwliygt[yvmeeklmyokbgexl]oqezpvcwnctcbskefas
dcowzgprrgvczwfx[zminxdmdflugwkkkk]vfoltgijbqlhjdohr
vtrfdkwipegmqbwrvo[kshaxjtaiuyicufl]zfkbjdxhihqmtjco
djidszgreaxdweqjk[rdjzkbmqtyolitmqhf]plltubpvwojnccsygfy[mewadohjaliobsdwezu]vmrkkqgbtfmwemn[erlreifagjhqavlxxh]yplrasxtqcyowlci
ctautcpnnufupce[qtydhgcjjqofrfay]lfahmjfjyppehyp[qzaxqkpopvwzqofe]rkcqkjpgptshvoucer[qmczzorygyrwbxiji]zljzfavjmwawfrfr
mwmkedorswoukdumznq[hdujfmdkyiznceknql]wgvbskjuuwmwrsvca
sdvjnkxypkzbwaam[jrjyjxcfvipcsfv]hqpkybfiuthhszpey[cxzhyjyccoulowr]bwjcdjlwidvcfkguaud
wfvvroenfriclccedd[aqkoeakjbakjprhnj]ytucldefderfpqaibsn[gjukmqtaxbygrygukiy]xfreqhtftbfsvsjstda
gmqthnogaadlkycgrv[qrgjpxucfcnthziuqmc]fqlchcfytukeoho
muwfuurxmlzrcgij[ifojpmgnfufvhbmmeu]ezcruchallsnspos[bwlnhfxtqvwcdjo]lnfuojduqnrbdyk[jhfihfozzosipwsyk]akukjehglqpancmiy
ultbxqkpivdepjvze[flhbwrxncynirgxwt]twqbnqiaivfwlqorpa
izvobuuojtimkzlsak[moodohlaudrwsto]cxjybpccizkmeau[dqaajcusqoaatpbojuh]pxlzqhwqdgetmjcm[jmjesiihxrtbmgwkcck]ywajslefzjxwyfivv
ymymmfpvyiyegjw[auyhltgyvzodazgd]twjkvzwomymmrhfthwc
romqbwenzvevhyq[ewpxvrduvqewryaoct]wxgowmsdxrxjnyj[obazseiipwfmbyxhkdv]gjalmcoqrquvdnmzacu[abzkksqdcduhkizuzxs]uzuazfdegdfqjmmr
frvysxhaafihjpza[uuwayzhynhgliyxcc]vdcjfobjuqddqibjef[iusgoufujvqkfjt]cejktzeuphymtswrxj[nthrscqmjniokzsq]tnsfuflhwdkvsrlm
rrybzahzqjlsnrf[aexlsirbdpwkrfhms]ftuaymthroqwnjlhwv[gugocacufksbdyqsfwn]ptivpdoxkvpbwaohlfr
ikdnaifadlcqtyfpq[ftwtatuewtwyxevw]klpnngjlhfuuwykwbqh
jcjepxytivozlscfk[pdosptbukdrtforgvxk]wdghlnuxqjdaztviyiz[mqtajavotnicuxco]vovuvrvnwoedhflabai
yaiokdeleeowglfd[qzhtllekpxcjvig]ohtsvsylelaafkxk
qkopuespenokczipnz[qmncizyvbxioknj]piygfwazneqkamiq[oebzwpkixhbywqc]tglnlkwhricqqzzbkuo[azpshyiwubdevjojg]fqlqjwtirppkilhplu
wpjdzojjjgthuvhs[ttvkvkootolwcilow]lvilrilboatpxwa
sqcunkrlvqeapsseomh[hcaleossxxtjalzts]dwokbxvvtiocokk[ziimvyrfcpcagbchp]lqsdomcpacsejdzcxw[tpekrtncgabhvirc]nqguzphabzalcgqjbmw
lchsqkntfaymwss[glcnjoqtmlubbldwxb]repxhlvahfruswno
gvwpylwrbvedenl[bsexdkrwujurnrhirju]eskvbigiwdmjthvhrw
uumyugkrepjyfna[clcqpswhmttsgtrnh]wnfqshojhbnuvkblcjh
hcwvxdxtuptlajr[svvedookmmgybok]dgfqpjqcewcjwqcw[rtkptmdbzfeqcyiha]xjnmaukpdrlznfxvfl[phdpcpgmzzlbeplqeyp]xfxopckbwdpteui
mxlmvngjychkbdad[nprwbbiggpyhrgjnox]kkkrpnnokeecsxwtfp[mscljzerlkqzmxsghg]mvwiwebrwurrppqw
bdgrunylqufybegh[hwkqigrllagcnatuzqe]tfooqltcwxznzoaot[hvdskwgtazfkqlbbbk]zlqphymjvcvgybaxo[uvougcsxvyieite]lryismkbwdzxmprwjmu
mtrggduulofkvbdmqj[oijictmaujkaxedjfm]kvriyuoautahkfmt
ljywcelytwxtjojhn[iopmxuupcuvfcgubem]alcwlvcmjgwoksp
ybgcqoheatckeypwgq[szypqmipvcfzxbl]obblmhvzjoiinqd[kvoyilelwmylaezhow]fforcawucbchzbjlrmu
txgcosxcdgywyfhgjm[etzfxsiksioqtrir]czbkwziihsrtlceuaj[ksksgvozuazlcgqcy]tcottzfkvhsmrsyvf
iggzhhbedhayxftelth[qznllaqmnrogfmdtbx]ualmvsfjwntzbzd
dfeuwphubioymbzuwo[tucongmmrqerhidwq]tjzrtrfhgixyspdsl[tygroajgdzxudheh]oumnugqbzgyilbrth[ejcdurppfugoluctx]rtxzchnbmwvfewg
kyzwhtfybawdrjkvoyl[fzrhzpdsmtmmmvuu]fgbiqggdekddtlpzvzh
irtlqtjyzstyynjfjt[zrlqdodytcoqczaib]brhvezqcuycqmta[uaofbaluqnucifngqd]eeprilhhysftrhp[zmdzijhtuxhysuaye]bqokznpdffiubikgf
nsrehcsbptmpdeskqi[rpcpoctimqyccgnpnfp]peakqjqlahqkqfgoc[irckfbpvcdodsmwm]oxnqnxhwmwflazjv
iuanxnzepawwipojp[bzoxbyrugitmuiutg]wtsagitdstugmsssbc[dvxwzoncffczplwcaw]gifhatzuqdvuwnupmja[wncssuyvhyawbmfpbdv]faluhtnnnvuiwbbudh
fpedlxzxifcuqmvxm[vrfcejeyfkhegliplkr]giqaenxejvscrlxbg[qctzkslosctnoamy]qyjmeunfiiuoxsid[xpbjwjejckcavehej]txgqklgnzqdtimmiqwc
iwkrzpmhsunofgrddx[ecssnqrcjyhmsfh]yrmuqswzgcbxnaa
lacpahmmufjghzen[zkbpbownspfqxnclzk]yjnyyjnabyhsrggji
vgxbpddjqotuvzbakan[vnagjxrcehlhbxwdw]kxuenaclhrihntgwjq[bgqywyrrhjzjqdnu]eirujssxedivdmvlsby
tsqxgzovbjzlwpcbv[rgaywjaothmsswcdrtp]owwnjohtsgegsgtah
xzxejmuyfhjmgoxfl[hyafuepnewepjpy]lbdbsoxevfzdpnwpfk
moucalsxxvhjiyoceol[gwxofnqdrtxzusk]qjosxisditclyvucbm
bjgdyrlrhtkbqrjohwj[gcmcelqjvjadxqnj]tlupekhzidsrscrf[oqadjqqatohbjwxrneo]ykhccsunlyamcmmk
vgihvcltopalggrjzsv[hmrksbhlxuzvtbnuss]yqpcbwauqeduyse[oojtsldylgtokmdwsy]intpovuqazkybvjim[qbqspjlovnizurecdj]fkxluehqgdogxdofnq
mhwhttcwzcntsbufi[afretswhwxhwkptb]srrajfoeahmhecarmu[wgjragqlbpfbfpd]epytkbjxmblfnkwhlhe
dgpphmjzkoobitcjyoo[nzkzbsfktzftpmgwdcd]nbezurwvzkhwskfq
epuokjzxtxphttxtkz[xcyaposdqcfkcxhncz]hcupnojktsvxrfwlyv
xfoshshomwdgssxla[uhshvhbfofuhdsqk]zbzynuiyfagqpemuplr
hycladrjbjuyieejeg[ajsfbpoakutelvhdak]hjejfrmmzslupsepozu
ksputfunecibpffwovl[xteycruesicuhzai]sqpunyzatnromjeq[xlzamstzzisboayh]gzlnqcjacsbkkmgzi[aonbwutxuesczgwnr]aflrcbdkkgoyumfakb
gjgmaueywnbqdvgf[tpheftnkpnlyujv]tvnqzdugoyjybxfpx[lnhefqkhesyicqqgvai]dvdgtlsayhtscupgikg[fyjgjzcrucldwdd]ohlycgvvdatuyvduhuo
emkefdmyurledfdd[dxzytfxcsdxgjcwxjzb]rqwwzvnosuhkcplv
fpmhvozxaaxsyxcpx[yohzimahvewgvzucn]ztkenzkvcryyrmo[drnglpsvnlefqhx]clawabytpjiwgqflfbv[xvqqglnkzkxlevq]dhpydxfqbclvcjtdcn
itvuciuufdkcgdqgo[mgwnpeydayczlvjegm]jyrwfakomakilgvhd[mslududkqwtcsojaosn]dssdnwxzapuchnxz
twopcscmaiqhzsepel[qhydrqfqwvjjvinlq]tfmaoxgmccymtrbecjk[zkuwqiccdgoubccjoc]pepwccwqlxzlvuhb
dingttjebuuxtxrxt[jmgffmivzzxvgvefk]bqxyaoqiukfungsvu[sidxinaokekzqpqz]hekuuswyvznavhuvk[lnmhqeaujpofmdzub]vcufrufbmgwvdwksqn
mlgkvlqtkpwzcjbrr[yzhdcawedycuwdw]ncjgthabbqmeuji
oqybrhgapxiiaxihexa[gerjxleappelousidd]dblyflqmoarwpne[enariawxfzzpeqdvj]lgjzpkhkrumhvap[rtcetzkiztcmyyjzs]adjuxkqsxrlyjgf
hqxmuovloocgcgjlajv[hjbhghstuvarcwhfy]wldxggmqrrhiwdc
yelxlqwqeiqqwwaitp[uservmlohjixnqtl]cocskteueenenkfmy[ehpleyhokmlzslrdlh]lyvwccjeqrqiofplw[pcsjxogpwmbhrpvvn]ncmxjsoxflyiderh
znmujbypnozpjpkqii[iydnrowiwhgazihmxxp]lvehdleutcqbwwan
lympkckqyhgbaumc[oodkeqjyhckceptyqui]ejkkqbitfscazcx
sxvzcdelbmcqawvour[jgrjmuzvknqddwawl]cfdxxgxsviiyckx
nrsjamicxprsigw[iywcxzvebsemowpdmn]tbmisagklgwliuuin[ztbbbdtyfonwumpl]cjmddkvsaxzaszisyy
tllvdxtvmesnmauwk[qaomhmguwvmsjbwrwz]gvzyhjymfhmheexe
jqiffwykdbqbfcz[nzzfstvzsrtshctbwt]uazcksxgiyuwlkbde[nvsnfriumhwznjfdual]beqjfgyanriagjl[mkwaqdkmtnrzfpszb]mrqgyvqvyqabnugoc
kyvjsbdoorblnmy[wxackciwbnwvsggfoxe]pbufyorljghrayitwnf[orktaokqgpeenjyk]xdldvupmoyqwylb[aljdjuvxqagigdbti]erzojwkjcoxvuztbqw
zuceocflmwjxczrua[gpdqtptmhzmrumm]lvmswwevpotdyrrztzl[pkzxcpcqxpbfmznn]zoaxhfddhvfzxmdreww[roilsmnfdmogsvyyr]inqfvvkesrzgzwsnwya
lihowzmdtujxkokt[czwvzrilryxqxqm]appqwnbyvtxjysxkh[wpjuzvceldxgvsx]hkyptytryliycwhpbkk
ccyquivxwnsmzvurzl[gatwkzfmiuzvlxqqyy]twruqhcerhppziydvey
kfmpvuwkfbczuahpr[uhtwcsydtbjjfcyu]mltkvudoyovjipwmptv
yzuinluayrwqgezu[qbeujtuehlcqhbz]qwvclzkjxuficbgqv[qrzlculckkjhunba]gemnanesaovxzxatvm
ytnrkypitsppgols[boldlbadecdiaeyp]miwxcsnjabbmlfz[nmfvanenygvwqmgpiei]dqwnubvfbwzdptj[ormimocwondmsyrk]eptdchejhezxzpqimj
bpvimxocqygiyfak[kocimiojschpxlmlbh]oeohxkrlnaramquwz[mvodjkrtgwsyshboxo]jmxqxvydlieugen[qsqvwfzcowdvxzeflfz]eoysyaomzucvprpm
uhanxfxnxmoedczj[pjqlsouqdhqhforcuk]wgqlbagmjmtimaewh[qlnvfdicashjzjjmmwe]wrtbmpniixypmei[hnikhifbzacymvga]cueedmtiokuuauro
rmwtcdtidmhhqvlooj[ibfeikfmamtpxld]tvqxdwcislwdijaa[znpzxccexnnkerzseb]cvyteeonwbckvkmw
xtrkdnwsvlqfpzb[fyqeealbxbpjxohdssv]eomkcxpzhdzzchmg[rszbjedcqvxmotecne]arebcunvopesercpsif
wpmgxfiikbeczkih[cjfseyjqbnprrzrc]vmofgvrwxiitjsy[cdbplfeqqrpvyoguuqp]gicntinbexxdcom[bhrrykkursqvyepyy]lhpnuchjkxczxxvqp
qnaldysjxpygshfd[ggbsrjqdcbppktpfk]rfapyzecbxeoluhop[njlupwxmsxpopefrwl]xhmjoasimqrdlgjwm
acajjiclnscuxdsyxv[axykpgkepnjhrhfgqvr]slbbdyluiqetchbrhrm
ryolywtcfhaxzpu[cihbqzqvoqwayjwqtx]cpnraqtbqozlcrvoxn[ippcsfxvbyrodbacgmg]gfmqhdjmgnfisex
etevnoklfebubfa[kjvpcomfcdacfhthi]nfqsxiilqrwqianlsex[ugqfrpggyrmumjf]utvcyluzwmzjygnta
tvqkpekrujjfpzlot[kgoaglxyitdkwjmf]mlihujxyrtwfmzup
ktqkqvqxohypotivf[nsytklzqsdqgtjsrved]beidsrlrqlaaykv[bhalrlzjhvbdtjcmig]awjesirwjnmfjdslc
axgwliaxadkosbsp[hpschybkdbrmhmm]sslipdgrubjiifxzze[sptnagunoyiasvcunvg]fywdxjoeyzvwrpinmf
rhpxrkwvbmiuoks[ynxkvorcjpyldmigt]juvdfreyownzxciopxa
qlmnvnzbswfkadrm[gvgyozcjgthimuxze]ewpsviwopsrqszjq[odmqbtcagnixpgasn]cywfvmbtfcixzjmyue[ekxllezjdqxkqfxkflf]smxhvcoojkrwvuiv
mrjroyadyadcyppfliq[xunpwmmutvwiewlkyye]ppcjwembftkaakdig[fycllhoijmljdas]ghnbcqzccvagpgplb[eafwmpftuwwwoln]qbxjdgsbyahqkxqzrlv
fzfcqlltfzjujqeym[jeaiiecptdpgfsfccuc]sfsekysmcjtdxjc
jjynfbiotihgcbrojww[vrxthptqnzbjegjxzru]yethaiycpixaqfb[bplbbjoveuznxlgvooa]izorgiwsvfgporxo[lnktkblkgpenjuqu]hsizqsxbuadccikdw
qgqbnxfvfobowmipa[pgiycstlgkcvsbi]nuvfvhbouoykamjuttp
evroxuhzulkndbn[lfllzavhyovpvvcvg]kihcrzllseowjwezs[vpvpwqtlbykudupl]qrmhrwziizlifhb
zgnewkpulzskmghubbx[matncbjczcjofajeilk]gimvlsfgxcdovxelxsu
zgznxyobzrrgfnipxlx[gsazrixylwsicyquamn]isxlagxgkbtgrbjknn[qxjewpiicycnpta]tghqdldoiwdennnuha[wpwsawddkuxonmxv]bmkekmujdpmibjrg
geeoheswegiuwrrmii[hbthbiwayyxkftmbayn]olgnlfwlixhqjgjvgsr
crxkwxwfcdjitekzrdm[duvbsycafjsvivy]ysrnkudiueyakhpydv[totferyeflbkxuz]nyrvffrgktfpmwsmaig
shfruolertwzhwvfv[oaeslwnysponjvpne]lzvqqieleintnev[jdhnbbkdwzksbijpsle]svtrwqftbwtkzzixrlf[wzxzoplqpcybbhhfz]klsezcnzpvgvbxqeedp
rodljmmftzgdnxxcufa[jgqmtuwqkermnrimyb]uouynscrkxdkjhrz[hpihpdzqgzcmawkdsw]dlvcgdmdmupcmuduu[xyjvfzjaypcbbeettvr]pnqhcmdgguswinpxmqo
yrcxqglagiyyhpt[fudlgwwllpsimkfp]esvhuezhtkwulzmut
qwiwjsxdiblovdjx[evezbqlggluydkth]xtoftegxpmgjsgn[dygxbbfgcnrlaebugya]jvcmiigduerloizkyzq[oyfqcvstibjtqcknk]sdykrdksunkdurm
mlublposwxvdmcasb[mmvoctlqinqyogj]lblnmvdegbddxjuuij[vlkyfhcwrywyksv]epprdwoppwnazhbfxs
xidpschespoxuwka[lifyliiagwhtynahwr]mophvutwbflkblhzp[ngfdfvwwlfuyujsy]pqgdfdrrwonjcsxyb[txlrkdplwmwanoxhveq]sirdziimdysnzdrzt
khglmzmqqlgtsoyuyk[ckwowqtfatmitmx]cqsnmpgwitnlycvr[hcjwrehoqrluifbx]dvorwhvznwutwctl
lsjtzcpwlhruhcyvu[ppankbohskraacy]xriyjykeufmypvpcg[khfkqffqnnzsskbvi]exldjyjnsnxqgfxg
cwilddndcerivvgcot[pwnjzedgzbwjhwdngiv]budzscutbkzehgi[swgapyqpuwuqitke]aihrettehkbulnndniz[ladvxuqplmfxnwm]zovkncitewbtnxao
nwkbypvbwxrhjccd[tzjkzmgvioaqorgsan]bghmwniqqnnugulkcq[devmzttwdxjayueapxz]pigrhvuthflwfvyghl
zxoysnouzggrhhygrn[wvovlnwttrpgnub]tflqcvvfrhwiikpfp[fmvlpmktaybiodqon]sawjgpmqugnvancar
sfhshdpjhpscqgmcx[elzcuconpnmipksf]qebfhzrzjddpkrwy[mtpfmfwynqlzlcavdjx]olgxbalbprtdnjl
ribazjlrsqqorxkipi[rkwdafpcbgzcvveipl]jtutooefoewtkwcolek[pddkdpvzyumbkuci]qyeuvqqxiqrwuzygf
eobvoofynuxzuaudo[icwrahzvyvejahwlbq]ewwnptijkewsppx[bmqxtgqmosyeyhcbsvv]ojsamjjroupnfxbygrm[yqqusonrkvfmwpiwo]nueolsbydgeyemas
vdmbxyiptwawwgfxzh[kmxqzdwjfyspqkptz]hkkuurdkmfzivckdwp[ncwldxetviygsqga]oxlfsqrbntyltzp
gewjydarttmsjtqn[zxbhrkxlalwtmmrgfag]ouqpvnvhrcsyaepju
iogmaqbbnpknpihgdzr[xddekzhpwasgjya]qvqeqqyfgmcjqlljhn[yqwhbjjgtlspllovxu]yzvhuxwuqjnqqwu[mnqqonpvybsaxob]emyjayuxxbvtumvsc
ompsdhuyibxinkeelcw[vcyphnznqaeqzcdm]iqpgmmktiakqfpiejnm
ciowlwsiatdaewieita[sjaasprpfvlolpah]bpeqtpttkceukaef[rprweenazfnwtmfqh]wedhtjlhyntjrqw[hyrqbnvfdzilazmclcl]cnzbapdwalrxcbd
duvtrfezztrbcbrpkwm[vtrqvfcxuueqcpbx]xmjukrhgfutvtcyd[ptqlpgejdqamrwxxbl]aavkmmqbqdkxyuwpllb[cvtooqdwzcluidljfni]pohomwwnjxhohmv
ieozeqgyrtjpfix[opyearfnbegqcgjqve]ljeerzciyhyvukdifu
awjmnojyjmqatcnnr[hdggsjlyjznqadyuwg]gvkbbwfvbtwwfjjnpa
dvtdsunzfozfzmgbost[cvhhdpznusqmedy]ayllrpvroikxhxetks
jyyboehdjvkufzixpf[ijsadnufldjduipx]zmcubrihovbjtdych[vtmkafgmqunhknoqttz]amdwppzqbnylhsi
gblfvnsmtqowxewqrzx[kzyxibskmbrkunl]nqajypwcmviecsn[fvewudrwzvqashspitb]docgbflbdpnxxtin
evhfjidivoswuxhsbd[wmxbybthkqklvtfekms]xnnifuivlakbrvkfaau[upixryknmsroqfh]tfaezdhmvigabvwfgt
dvdsnwpipghloop[diwimibgyehecqflqtd]tnfzbffdhkvhfsbhq[rtmprhoebqdxppae]gczergujhbzsgdxupd[ezswzkaawaqhjcdgfl]jgwotzkgibphpas
oyuvlfvippqkkfxsgsi[jkfszneoxbhkxlorzz]rmotcrnupuzltlqurcv
olonicnsustzovmd[kkmgnznlwjgwkkytz]usukziqukpwigcfvxw[uveqyxukqkusxuz]aqojtdccmpwlluelsyf[clqnppgmfzwrtlfh]obgkzmtyhlcounaf
bgntejhmisbzfrblik[nitcxhpegfmqugmlw]rcwxgxofqbishzhq[jyzbrgwyikdrbof]gdxdwgpsfmmqejfyodp
suumjpqhafxvgmgdokb[lmpsinjodlukkfk]jhehvjrbweyoeivfzt[ricjsiwyhcomnsgltrs]iysygfjrdfebsny[irlxudmuuykkcxj]wndlninlcnixabgs
xusauuaaldibtqcyn[hvjidaemmzaurmyyk]qxooscxoynakekchbj
xilzzdiyoqrwzcnwklx[jzmgqccfobvufhdfgha]lzkfzklxafmroamh[xxdzjoeflrhqibidync]kuodqrpntknogybhh
zfogxhqdfspdmvxtuwp[fshligclkdavscty]tkvaozljxenzeoj[txujxbzywfgqkyfrjh]fwwjvdiaceuyumeqscq
iqqislvjgveszvnb[qbfceykxhcelnwes]mgbeubhjgaydsrrps
unvvlzfszuuztae[ytbzbzacrvxlksvk]aeaoeugpmkydbixbmv[nzznffshspwmlkqig]hwamlnoeyfmzhrxmbi
eyrqyerdzuptlwfz[pgehfansstewngd]vdlfglsqchelite
irwhlxxczsizolo[mgrotoelpfspnben]xuboaosbbqvskeooh
mvvsstnbgtaripcmiv[lqhlubezzcqsqoh]ofqbajkawszexqw[pytqrosnsskcgmno]ceyhqvutvgwawrao
aehuceoazqppxdvj[fekwbrgjolkkssozjr]ovwtwkvvxtwlatlhc[anrzzudeipqtlgvtibj]djkyozdjetkxaxrg
qdkosvyshtjamlw[nvupkgnksmlfyivlaqz]vzjxmxzwetvndab[rjtknjbarestnsqar]emeeqkvpkwwwbpbyho[fxsxkmlskjyvniynt]yxdwuxqranfmwae
mpkajmbuiqyysjiqxg[gmhxmogelodamttt]aboupdcqcaggrmjwo[uqmzyshqeruzquxxez]agzfrbsajxlgzgfueb[dxxqiqrjkpgalcp]qcqyeyosztojwikdqo
cwzcxuvjuongdoellki[pqzhljdqxosuhdgqc]qqxxrckatnjwvmdjvty[qdlnrwhhbeldxrirock]kzsfmkvvjexhibpjfpv
xqxcttuxwhriomnnarc[hrkxvrjviqxxeih]ofnkwkzmwkwfbflu[bsjloysawmfoigzrsa]kjajcjknclhkjofvh[jtocrkwufebomaervq]hawuelpfzimwdnxens
axhzhgcgbqdeauomnjz[hbuvuiuidkykmvbd]yjddakntyygztrc[mgxbjwjbkzwnkybcgch]orbyhhpqxylsrzu[mygxsbzjoicfneimx]jddqvyyavgguqlqk
sstrdkfdyahmpmolvuh[nuhocbdkubnidqy]fnhfqdyorbtzefo
youjjtvznztbjozve[vcsiywlpdylxwpg]saiwvtogtdayorhni[bcbwjvcnlvrcqbeexf]cxmaphpnniedclqd[ilghtvdoebmgoykzmjc]gqxcmtfqougbpixu
jypsrripwfsirlizywh[qwqvrrfaltcifzgrzk]urwxtgxsivdxexc[hxqqrmnggugvdgdcle]sirkwolflgudrrwfvnr
jczbvdpvkmrklaxdh[iqwzvnjtjhmulvo]amkhoscjxrxkvtrlm[nlvnfnszosucrhvafm]dpkerwgcehqnmxmny[xabxqyrisiuhudad]egbjvaumucthookv
shephwsolmshfqhuslh[iqeoxejhscbjknjkgk]ytigxjcdexjgptz[mdcfmxfkyxnaaoixuv]ltysxdcxashhzrhfzcg[jrjzihjbmjzwwikgrj]zkrlixaauhydpmvpggc
hdwtqxvelsuakiujcgb[vrzoeqcoqwpdvdxrly]fieebtoboyeztrohbz[unoqhtonsyzptmpgo]bxsxkyquwwdwyhpxcan
wbxdrndbjpmgdewnt[hnmfgladivxjjrhgx]hhwhdeyhnhtngzasnm[eanqualmsluacqejow]wtycyvqujeitvrvtkhk[vfabcjjiloownkmsa]xqjgahkglpsjfcryzv
psxpjyoleoctcjgpwvw[qkiussudbvamcbw]hbauvxvnrwhyupg[jbuclksbbwmdnddkn]phqrldjcwlixcghiau
oeiqnisrrknnuqczk[qhtdnexhjbgdaplymaj]fqqywiecdftfcpfnkrd[lvlesddgirngtuo]mfvvfvlufkoqwpwl[hljsgiuexvjatvztcp]ixguvozijkebslzjaco
dktnilosvtkmvltdwd[vznigqxsgvlquhbquk]uinsbypzarhkgsgce
ljjdiiuiikwufjnnvjm[xjbujiikgaghrijcbsc]escofoimfyedoist[ltrrqmdcekykivhaz]xdiijidhpxdgqbtxue
lfwumqctskgwsfvhl[sgtnklskhazwypsys]bvjxbzrabgfrvyvyv[rlityjbenmcoigrfmfh]wczyjwqulaqxapozcnz[uqbunpfwhfrvgqcozw]ktvibesxhbrooqt
ammvknbggljpkwpr[vnrtrxiwcitskywiw]ubyickjafcfifgupssy[cbkzhebhjtdbsgct]cgefqdgpdpcjlzrz
wzpaqedqkmltsuij[jjuasmpwngjrynzettu]dtmgfvwtyxdfqce[usljscrncmnvrbb]tnevcveidnyskzs[ttmnmxqodycaikjio]qfhvrqvqpgjhkaaicj
apdywyijusgxzfj[sgbhrwbwywwisyg]ssiiosnfconncgiy
grownnednjxvuew[iniatygttcdaelocols]iyzwgdboxuadbrbooe[tojrecocburpdzi]oelyopkilwnsejur
hfdpohrtqqyfntpfk[trpnstnxymqupxjri]lheljryczqxgvqip
iielceqagqfksuqpzr[ollobpkbzanfxcjuhrz]jnxizyaoygzbzciu
njpftdmpmkjwcngeot[mocqjgcycgznvcqjv]aixpwfggjyqyemoz[fmklzletfvqdyvvg]mznoxpgwowvjjmus[prrehzdyfwwuxvhl]hqppujbqaizlzvv
vbjenrifdqsyzlwga[wmjenjnqufhqohvgc]uhrzouilmqjnjigwpa
vwooqueyzrusban[gjwcwiagfwpvrct]vfqlgxbhucjhvobi[bkbtechiapvschnh]vjzryzyisyzyzewdy
udumujkujngtkcfv[klinhdudyghspdsga]gxavvcsxqxvaziqrmsm[htseffbehxafyhoars]ghilivgeuuzjlmih[vtjpcrmvldjluqdazun]mebwzbxywmrfhet
cwkfdzyxoayxukcgdv[wamyytyfmfaucrko]dchdvtpdkeonmdqc
zklwcknfrvlblaamoo[ndrnobufquyjknl]dnxgeqvqwezfwky
zbqgtpvsqcteltrs[uwrmlyjkcidsfdpx]cgaobtbuuntwyuhxmjx
lbbyafbvhsilwmjivv[fkftqvaahnrokuhu]dvgaejsxgjuwiemu[yqopsyejqtvmlfxm]gzuulybydsrzhigldh
ficlcqjefsddeds[kfkmusacvnqualtppxh]drbsbqefpdoossbkyng[uvpyqnoidjnssjobt]gsheeufqtzrdsil[jbvevjzeugpmopo]nrgxwajuatycddzwr
xnhrhgadoziectoigmf[jwudbvxzwdfuubhjlt]lupnypmntyrvwqzlb[vvfvttkizuxshnhhw]lfdrjokdrbrcldjfs[wawjpqzozodmnmah]vdbjaoofkmhkjbphx
fsymutmdbqyguwut[qvxhywjtposhjgwuhxg]ftwhtxqxeicsrlfye
fglgkrjwulmkxbzolgn[vurpqcvuydmympiyofl]nbzudjasxeknjid
nbtrkgsywnudokk[vurfuvkjdvnsukh]vkmqsmcrotppqorkah
iqccpqvhiesnaohkhao[xykqfbmojjnscqhdv]aqlxkvudzlrncmpy
dtlwnznjqsixssrsaii[vkikcmtsepgtyqhica]ovcpoaucnwravbozsg
nobwzchgrycgkxc[tqoxhzxeorivdtdkde]ctdtkwzsvuxfgjtjg
zsknnbedctklyuxngn[jjzvkixpfmskcagh]fkvhsfuckghltyqk[hmygppkjpcdicxw]mnurqampwwoiiynr[jbkvqeqrhnksizlssff]xhkxiwlzgvjdfakjg
gqbxrvghncjdllxtge[bjuwjsvewzvrgcujf]tkrdrbempmwqujk[pmbtbgbrgzpxeoqsxw]nfvaaumgpjysgtvk
clfcvnwzcbfaqaj[prmpnpjwklodeukzznp]zukpytpqzgmlbvidv[qhfrkjlsbsqufgnet]pfhfcxzeiowmgiyksj
vogrpuzrevmatdbqqx[qolpybjnetsxcqfcvbc]ixxogojluwsdsldl[bztslfanuylwdld]xanhrzxetowrgift
dqrkbymiudzhkgf[spvsqvyntikovrefqc]bzltachhfylbrzl[znefllzixypjdkmfcxn]mtpikjxqsppxlal[oeyhdcnpxvhawqbmkzy]nxhshzdshsiercr
xmgedfiblpeazvgkss[cwbtqqjoaqbrgbptah]clzsinbtqsrkudymf
puwqcxmsuxnmneuzrhj[dbljkganxzmjvtxgr]ekmomoccimbpbieaf[khezmkkqdwkouzb]cpkfuyzfdfxhhhuhk
thfdbnkmqrektilpc[weshzvpsyofygysio]bffomelkkwvfsdxa[owhidyrjieeietzn]kmeqgnvyclngrcgquc[ieikyuuoliuiczq]nnqhogvlhwqipvpiao
zsdcvcbtwlzlzlmteky[nrqtpxoefofrjeaf]myjmnezlzkfcpmik
afyxnybelqewnebaai[ddjgeajpzswwdrg]qfwfqryofesysiuznz[ouajwvymsxmxzvgdx]ryuvawdhfmfvikye[kuovduidpcdyepuoq]didoelcmjebmytdyke
oopihddimztsopfcia[udmncuvhkvvbcmxzey]fpehwxjiczzhqcxxi[onmizmkoyhadrxpsemf]htycdbotvmomguwbttt[gjsdzuveiuvudbyakzw]ramxommwjmpkihl
bwlccfsaovlozdqpsv[dniiqfcldfhjiex]cdzbfrecwehrluxzprd[xpyzvlqwekcyglksq]dncoqoaakpgnbagf
uxoopzavjdqdkaz[exsbnpbaeuvusypih]qgojfhbprpoavcbxysa
mailxensjcsuodzpd[ftitdguigzeundytyp]fgoitzvujhkjynr[hnpcvussglqshxn]debsveizfcuroqrm[yeageekyjhilfwr]ozgpzusfpbyanxnzuak
vxjnjaguqlrwoxlhfbq[zlqpitkigwihrikvr]dysutdfrbljdzjgcw[eslbaxzslwoxscpgoy]sudodfmlfyuczzf[vsthktidtghtmazbip]jfyoxxiaowptvosevi
lgxmivlggzfdpductjg[qxgoioxsurcwayndy]uwlgoodqsjoxsjqqln
qognhfgzowjikeqz[nkwezojneylzwfdm]omduvysmcovvpvse[bwxvkzoqsykfils]jwgfmwxajhmggos
pvuwgxmpcrqknzpbkg[qbpmfthtmbkmljnsqs]zmplrxnulurhzvijupv[tgsommhtbbujbjpf]qaxqxdxmpqwduwwxpgg
lzlrgghqmetsmcxd[fjffxsqjqctkxnw]zlzlpvksrpnatxmh
ayirfkbsdyssjjpqmi[vpkvhbtreetyxstwcqp]rjbuxsgsrlqrdnpyg
ukqefgljywjmlce[nqjcndjjdwohtizoed]njfgjjqkdenohbwqm
kdwzhrslryuexdgbcr[hmbcvmrrmbsvyaii]bqprdkrgdlwjvoiyb[mqbaokwptkfmxzqr]wcauinrezkhduhcktrd
hbtuzqvyldtvwgyumzw[dibedlwdcjyfngungt]towfeyxyxixyxee[libuilcfsdkejjl]wzzxfhwcgawuhskreyh
oxjkoqahhqqcxcoxksg[bouywtiajyfmanxcx]xgqpjxtkaejvmqckkuf
prhqbaccndsoscdm[cuayhbnfywztddbvww]psgyhytgosopvbbp
dxdtcskiowtdomepjp[islofsowtuyqvcqwb]pjhyaudkqxxlwfoo
vdatepedgnvgpah[jbooucwxtveomnpmyx]ixgsuidbemgmahtlt
oncdjplunkvqphbyb[uvivlundxhdiwjncfq]dvhypguriulrangqwr
vipebvitwbccsnahjhu[kpwtbwddwqgyhnkjsv]acfaqhywmwbkmgh[nryplosnxtbkpwxtkfp]njzhnytzwlprvfcv
csvlzvkinldedsxt[dbxoceaaismltmspg]yomriudrxzmlbbbm[qilkpyxcxlvtfzqmw]rhwekeawwpyngqxzc[akqljrphobjicoco]utlunpkuptawrtfcccv
acfepkrkhnviixe[cvksybusnhacmfoy]tmqqmgfdharutrqvdpm
hjehtfbextjkaxilhaw[qvavsivlumfavaafhqz]ahdjvprlhlmuneewyxi[rzeuqtjkiuacirxsw]ucmfkrotfprypzuyqe[rutydtgtkppegdgjn]hmvzjyquxtydoujq
ntosjqtunrqfoboek[aogjyqyzxpdgopkpbx]sdvftoxtcjefotm[jivgsxjogxklwkhm]cahcjmgzepqebtn
omkznbrlrodmtmnhwsu[ysoinknpnzrjqkf]ybiqtlzoiohtldgoaud[fbzfiajeahzmiplcih]qimubctnnrmtwro
drdygweayxraomiblsc[oglpuxzweqpofwi]mbipxabkjqcdscltkh[axbvkumlaforzbqy]ircpsgstqyzpwnv
jefmuplsptisjqguywe[lkgtuysseapteszy]wzcehypttzjhjfp[nkwvzebjrydcwfkqne]tnmaxtrhvwvdnrhpxne
elfqfvbjutssktxpdo[paguttthfghhyktkjjy]wkpqdurcibsvviqfqpu
suzpbjqdiebctwhb[gwnbzgajwrorqcx]qoqdgemwbkdpsqgjds[qgozargzosdgbgo]hbsmqrwnlqsdans[vhppwpwwamtuurulc]ylczevsobuxtdhvyg
qfixarbnawmgjcga[dhgdmxcpwpvycmwl]mkqfghairqabhmokxk
srjvnnbutjaeikkbsd[flieajbdmghmuzp]ieimmehrnixqjynp[rjxiepmrhwrmrpi]yfrfmlgakaehvqm[hucfgczbwdpxxuhk]bvgmehildjqbjdu
qcmjtgmmgybxhde[fvpxdzdmzkhxdzjfkf]qfnaclxnryinmvpgr[pcsmctnmmrpxtfgi]oszbhmhynpzqvtxso[qhpljywydqpnksmwzdi]yqwxnvgcwsdwuluiouo
vhvuumgtzbrbgazpo[epktoekzvomswsqq]bbkntocwjpaxaoc[rnlzbqxqcuyltjxepz]iaelcpyexpoqavcbepy[azyksbvkvgmgimw]kvknvptkveiacqnzll
pkkcmeinlwpoupwpu[qtoyfabmibfrubvepwx]atgpzcehuidgikzn
srwntduyxjkpivzkgvl[hmenzrmnnisxgodof]lpuawirahbvibfki[gazzozitxhvxixvc]knbuydfpbjzupju[emzrzykcaeukvec]grtwlnuzmqivnvknug
vzlbpuiceftddittp[srespcesbfprkwuku]bslyxxcynfqywwu
icolypvmrgrhuvj[fgpeakrskxaljnakz]bqxravyjmdodsvhf[cjyehkcrdetiknsttv]dhoghrdxmmzxbjtbql
nowswrulawbgqkmcee[qsktncayiihoxiu]wtsjxnvcxdriviyn[tebqonpavhbfnwxvjc]tvpwgpgrozhtqtiy[lhagntjbctcsdejajh]aedpfftlvvtmaqneaxd
phiopnkoxulhkaddkxv[ueqfevwkcjwpcmsfspz]zkcoexersqysbtqdpc[nmcsonrswjxvdtuk]xdrsvfxrrdrfdbny
aosrkxvljnapvnux[ldzgwtxmjbynmlp]yrxxllppgosniqv[prtvqenfqapocxdrlst]gypcighnnppaytp[azueqhhtymzpujx]lsgvwvvgctkiyvlc
rketxmupdbmrircajep[xfmnkumekemjnwki]zurvxfxnrrvkmkrhbxh[lsrwyjtfjairiuwbaw]dyvmozkzkcvmunw
crxtvtdwdxejpebbv[xthcfmihpjqbhrvqfkd]hztqefpqdtgyhfzqsi[nlaeacaqscestvv]ylbteskdlwjfwru[morvntwyebnmswguff]othonakykxxajuj
zclhqcnlmxsurcrqaty[stohpulyrzcbabnydyp]veajkekzuxjmecdzym[ysujzinvkawzoqi]hfkcorxooelnfididyu
oejzfesyaxeittrdh[yziovimnkfkadiplm]arzmtikoiveyvlsdkwd
wvdwkqqmnretidj[smwnemzwzqhclpkud]yzguktkwahnuabs[bbyhgwmhhbpbwij]qstxwyfjjagyqvdaexg[nkerjbdjlikfgdv]qortpkyhpqvvebjdzw
apdkznwjfxwdrsm[fddlqepbyrbrfgmyeiy]fvymcxblcjkcvpcyup[szsfswjdzmcabwuz]hmutpmhknvwrlwbvs[vpfcztrelzjnqzq]gqbpttcrakuedsp
sujqaghlxszzfxf[jqybozaufdtanwa]rthiqanlennnowvdkm[elvfekcowitcout]ntjaqinnbwtqsctwrz[axpnqwfjmkocafoeadn]aplpjbnhkrcrbebmo
hzkbvadkdojwmdmdxq[ohmqkaainyaufipcso]zojzxelggufdascjz[zlxncckagxntpzqa]kindyikavjkmhopcnek
yjcsnegfsmmnfce[ueladqjdaqflfas]wcifctlledgnvodtlzw[zqswolvsfhpyrcivk]vemkuyjebqxyahb[ydjhmgjxmruwwmq]cufuqsyyytlgbpwrj
jkkrynqxqlgxukyfv[fugivxklerausdl]shcuiixkbmzymoxv[thtakgbdzvjsjsera]lmpwzqhthoottxvp
ncmijtczixmeyfuhspt[ixlxgrsyxrebpupt]sdoinvpfizdezpc[xckbxvncmseucrzjo]rzxfgqlionzaeocj
xmqnycsovydhyaqiv[iuvymmaguzbrtgs]zhvxodssnpnhajwzy
rqqzaaswdepcnnmqfif[pzkyyjprisjybnnjcq]kqpjhykszghcripq[vgdhuqujrkqljuc]qhtxqkqygazsvuh
qynvobsdeutfrvb[fddgwzhlhryauxzb]etznfbueibykerqfugr[rviezfaehsvigssm]nwhvctxhqvfdmgqe
ihonnjncwrkvglabk[pnjachlnpyonivmjtc]uoxellmcbixrdsisuhb[nkwsdmhisjdqurn]bowvauofupqfmxf[liiytxrcuwwnimdurys]acluoarkxopwppv
ipqsfckjkqxkxyuvxje[arswyomsnfueuwmcbev]mmlwwcviicdmllylq[jnqpolrlwmmccsd]nfobgtdlxveuuldt[uebjwwikiebtttgqss]ikdxnjdmzbrpqqvw
zhjywcsrtcadzdrby[ynasiklerbnlgidest]xhzwkwypktpkqgfyh[fuuxtaekwjpobdjfvdh]jcsrxmtbrqkerkrc
osahjtbzrqukvphpe[guutbgosbfkaurvuf]baiwluaouikebnlgf[cgssqcbscupvvadpbt]lxwmvxorsfcaorccxp[jcqzcrfdkncuoqj]gbgdolqdrauivfnsyti
vvqcdtcodesyomh[efjjzleahiejvczmsd]naeosnsaltqgjrk
yucpovujdwslgdczxzo[fbnfueoeatnphvv]gwegeafilsbwgor
thfmmzylspbxupt[asfhmdmkqwnqppnmu]awoxkgkgtrkdjzz
ghbifboivgelqxkfeo[gtpozhzqfntyyoodc]yjqcvpimanwiunamfh[aglylsuuakjkmqx]edfukuqcchtbhtblcf
qzonwqxjkpwqier[qmrnrkkwruteiijirkf]xhnrnahamaegfla[fzshmzjiczdyzqhwx]acjlrknukkbewao[afpeaepzoljqxcwvs]dlvdxhsoljmqgmvzf
mzibkpddgkilmcwcshm[sgpxutpcqniuckl]kqiwkwdgydpnjcj[exyhorurvawneziiy]njznkaphsmgisqyujms
xgzabblockmothpuxc[mhiwwhtpmtbxowbnp]aucpfqmnquiggenklcx
rnhfshqrlxczmrcz[agxxpteadztvdfeo]zogmjfpebldprrmqg[zppblhkevlkqlyie]mgovaojjsutbwtpzsm
kjgtqizmvuqerhb[dmhtzazyzqwjhpn]knmrbytrwrcsonmshb[oiazannnreojooa]hkhackgpdqgyqsgnb
orhnenfhsjyibqacq[tznvydkguvcwayiwmi]hejujxsitqcaabjwskl[qhpfmxgjdfgtgmy]ahilwlhjkfytezctsj[ewxepeeisacexgtc]paxwwhhpaukgjnafuwl
mhmfziehhppfqoocvju[hmfnlywpplffsxwzg]bkhkauhasnuoglve[oytxewvmknoqchvy]fyodxbpsytyeltnfsl[wojcbkfsswlcuqcz]izcrkyxzjclhkfuv
slabudcjhktddar[cvkvaakjffjjovgus]ahgxzdctihvboiarn
degyynefmxidnbw[zcfgkvupltxmbhroi]dbnaezqekcegyki[tjrnhpsmfftiscppybi]qgyifwlhvccshdiqfx
sxszfjmiathxoqnxg[smizlxpwmelqjlf]etoglecoddmflqma[hsggyxsxkhhshucgtnw]oqzadjxenphyexaqrb
kqwjndajvawmwxs[fskyhhktkilzwjtkt]ufpvkdnhygmuzfsfiso
iqdscwzpnnwehtqmwrd[fqbmsfrezrkhqcw]gqkpkiqhtrjpusoefg
bhwbuaqjofxcbuxrqub[aaanhuielrhxhlzscv]fkgimzkootysfzwcan[svktoznaqxkkibhigju]fmqhtjgxbrovymq
pjybsukpzvvyouum[rzeunjnideaseer]ltquzytuezonpowuhdn[wzwlbeegsgtwpzo]hqivrviswwfsdmpgnz[fhabjemewetsjrjhy]lgbwcozirgljoudhng
ampiucjqxwrzbdtcjnr[ufubjvykdfixyzqq]mcxabdvjzhohlcmcu[xihctxapmjpmrev]mggwuizzzxymhypmcw
pprbxhbjbnlqecvmu[ewuffgnuylwmrcvkbku]bntyrptthpmexiakh[lswyqkuxrfzokacp]rvkhcgbfnjivaagp[mnpbbcgrakjlmdqt]bujykhlbutiiqyke
xtcidzkptvkjakxl[kwjzzydtkvjmqdz]httbqtbiyxwryblrfd[cyjwthdmalqkqvso]knfncfebbbueoqze[zuruluaalfysbnmf]vodfiptptwqpnllvbdf
wtjthnkscjzzqrbpc[eirytrqekucxajz]ghycghnyntrthzkechc[eiylrukgxsqpetjfnv]xuiymnuzydlawjygi
rjrldatkdhvzvgcux[iuhectextisybzvz]vycerefkzhnmdyg
lqftkkvpvepilrmyty[uptcsbeqtmcljaziisb]himkwiqkrogoyhjpru[wxocqzrdgaclbeefd]mtytxwskqznxgpfex[whqbcssppfhqedhv]cbtiuzgbvptcticlbcg
pbotpqbiqdjzsmpbki[zqcshqinikcszjm]xjxijypculvuoavvg[nltkubwokrppvzifi]dmedgmkonytjzzk[obonilwwerhchueuf]mlfqiwmaicuecljj
exlndpqjplyfdbmvlji[fzzvnaszvmpwpdcovj]ymothxghgfddmzqtglj[wyfqyqwrhanponsr]ydpntagauckmdqpjb[icumanaybbefssdjnqz]owhsbdpufodsqezginf
ukfirftsouqdsgbgmht[nrkpwksebkijlha]zfkumnifusjysuzt
uyzxwkcgjfsekdhktx[qhgrmuyjmfmunghm]mgjbupndudwultdnnt[oczntpgnyanxxgdqx]oryrlqkmroilyca[xbevednhpnvzzwmrorm]bdozfrabvamfxae
toqvrteazudmppbrxct[cyiebroauwofshvceeo]fhoxdufwnvmlwhhp[xykvdatsfccxlfmn]zpqqflqttorrmjs
ltkcveeqyawjrryerqa[zxoihtpkswzjrhnbvz]cfpirvnjowhsnnbehd
gdiyzvnydjwhfzrimq[lvieihnyxtdrgrbs]kpotvolpjgjtfiqf[koloumkhoyktylql]cxgmdumzkygpppqe[aywuzxkrvrevgnnihh]uplcpitzxbcqkmfgsy
tskqojnfadpujfxym[xomwfoclpvyejczgyy]lkmawlhwgnpccotaetj[fvhbgpqqvasfykn]xfxmjfyoygcsbxl[ldveqjhkzxczzgxhbxh]tfpibohzhgrythjgqor
xkduagbswofivadpo[mxlqngyjwbqfsszj]xoxngqbxwsttknmtcyk
zvmlodxbacmwvdti[itdxiimzuvluomfxq]ymrkoyojdnsjqvl[dihqibcaznldgoteyx]thrrpohvatzogxrz
soetmauqgsswblf[hlkchnarzzrgjawosj]zsghpkoexwcujpakaou[wvfxggiskbpgntosh]zbohdymojoxhndfr[qhyzatgvedhoibktw]iggjhmravyoswvu
mwjmmmeiclpjmvishbx[dbmbrjcjcmbnqxq]mvhzexhgdmmnduc[yiccjcrvmzjvygs]uyvqfjmiyccasgzlz
dsfwjqahjoozkpei[olrrkslvxvijsyopa]jmzojmvqtzvkhaxukkv
kudhszsgsrenjqcrbp[ipvxqnbradyxoline]srcnihnhywqlietbgqv
eklfpuufieqqdfrgouk[ycxgdyairggpehtkim]sdfhxncpiqxguzlqw[ysjhhepmruqaegxp]wklvpveoxxfyizmf
apdypwjfmxhjgojtb[zojzoufhucunvjr]zjpuqiciaujfbjta[wlusnbuvcffrnac]ecaccicpvcmbomsvf
wenmnejyihmxaxdqwqw[rckytszqrgaxmjpbqh]pngxudjgdtbshebyv
ieyarudhbjrrevfodgm[grmjubbiqdodhae]mhzexlzijmzpltsxjfa
byfyxjxqlcpjxbpd[pdqkhutluqjoelb]pberlwpeqxmovie[zkholwknvgbfxcyymye]askmwovcktpqhcg
ccjcygsnanyvdss[frpxggwvfjuugdysypg]tuqczwtmobkusalqusm[ignjrlsysasfmzasa]nfpomrlygzjyylhvypi[lahpgasntfymdoub]rlvsrtudkvhtwhycf
omuyrkrubieiduzegr[gcigoszvylmdrlrc]jtlrlsgqxiqtciehh
hqeghunlieoqhetnh[unjtmdurovonejpsjtq]xtatdniykzzxpufps[ysaytzqvcxkvimhql]tyfkttaoythcttexrp
ciyuspkrywyyplmlro[myfyzvlzntivldrquq]eighmudngyiwlsme[eukgbrmtghntxpacth]pmvxbxswfexsnkxmm
gdbeqewbrhyfbfpeti[yvyiclmkwzelbqi]sktocytuvyvpcia
gnfkqxrtauwnkhfoyc[msfhopavdyhpvpttg]ewuyaxehxbyziwmxd[iyqrfiudsalpmpk]smpmubdejyevdggead
rqvcsivlxhfyboxj[flvvsnglektzosreb]yrfdzdgvkzgrxqoyv[rygmqeiccgtqqmni]frypfnzvhkzvlabrr
idyqowifirnwhkk[vloivxhtkdzjrbuuzmi]beozwodgehayklyr[cptxwcsgsapmprrp]hfrdeefhyehwwvghgdq[prcadfsulvamytpsfo]tyodjlxziwyqtqmi
tdwoqxlhhaqkdmv[cxayaazioswycmwj]pkenayaygxyrtqrqugi
vtqeqlrohgalpwrqig[bewbjgeryrvhzwetm]hpccsjcgunkysntpwp[yefsyqedopuhssgo]jjkkuwoyvhzzcmdlvv[uqczrglqumshdhkdkut]dlfilxdlomkvtjhv
fezgzsmmxdvhtmy[rrmbxexyopsrhxag]ezltorfyxclstzhp
ytcnqprainktcjei[phwarjaicrgistkt]qdtijjhbywixrie[llwwjrzrxhaqhie]ufaezqgmmdhhzjzrza
uyvaorvuqwbbexmafbj[tnpwadyyakeawtdextg]tiqechjccyyczpvbf[vaqfvvcbrowtjxyu]oqswjgtolyixytoj[ismczyxhizrzbbpscus]rtlaqgqrcxpjgmih
jzamkswiztvnelaqnqb[iptcqxmvbgyaeiwob]xnhehagwcwdgsvpomgt[jsasqvgectyfdja]dgjdtjlzbkyyckvy[fobafodakfhhiem]thozlpiakivgzzvemu
owfgxupnufaiuovcesw[jeskiymcmexnjbxrbp]obganlgvlqdczqrvwad
chsvqakwmnabitpotyv[eqeyowfftbjxdkpyf]cflqouimlafrxuqvh[vgjbvqafqyzexrzhr]mnywvcxtgsaifufkcu[rtjuztroxgmpkbnim]xsqyofncdrvdpin
kufzqdykjclolpveo[fopvuhisayecxlainzx]wvrhymidhtoldhb[vylhmdjqsdhokif]megnkxywjthliwepc
cqjpttuijfdzott[wubeiefulpuuhweqv]cqxbaudhnmrvrigogf
hkzaqueemmhessqjq[xofafbaefryhwyzzuoc]yyzaekuutvjrwnhonpk
zsgyhvutvjmrgnmar[kbxkhssdsmefafntsr]ocjxtkpqmugcvkopvsu[dsdwezhcblqssurfmlx]veiioiyfnncyfrdwyv
nsqgaufitxefakffd[brdfctppxqczvlohw]ntxmfmrsajxuqmo[pbalhistyzwnbfs]inapnupdvnwtlvvu
krtwywfktmbdobnq[msnsspogynsnwdb]efcftgrjdyygncnqdks
rrasplhwovftrffuw[txyylwsjezcxalx]voncsevbgofoiiolvk[axcouuspjtfzsekglc]qoutiffuqnorbpnlp
etyvjsjqwelcdzpnjxm[eetihszvjrmccshr]uskafocfyjorzhdx
rqfzvsuredndurz[ebgtddsixmgsugd]ilczpjzsukpyekhobu[eeciaduigoflustith]ohmscfdomzprzjncno
jjjarldpnxgwvlxve[yjoqlmnvtslexafgvbd]yngfttqfsebrcwtctf[bwevtymxqlrpqqaage]wdcaqtgkvmzesrjex[svnkfzogwcsyfxoxh]hvrsvxcpdxqmlfhb
ldwuplbjkimdskui[flisuphwbiqphsddaxk]eelzsgjnvecwedneyb
busmmdpbgxvdiytw[kwlhqlohknjgwfh]xgmkafonkyzffqtj
ngtpdikbtooilycy[dwpneelecozfzwwseg]kwkwssbtktxenqbnyfs[lekbaoqzpvjbnuvq]vhlbuorxxxxztocuiq[rscjyzvyznunxnun]jhipkmizwfpoxeuktk
leghszcprzadwpwlakv[cauvyhahnjycqgmslqr]pisyfnajcsrgnvkhcmj[ozrbuuodecumxzbsr]gtqbofuoteafyjk[sodglraziyxhcpm]lbzccqgejtsczvj
aiqnofheehbiqxqlg[wojpqldgrsrkqqpywb]dyxygexggvertuktz[iolnpmkijfefcsebi]okwjyjatnoyvlhe[zbfipzfoszigysxpwu]jitbvwjmknigdnlt
tvxhyndcnfrobfrdvo[vwbjbbozwjpolbmlkwd]kzsgbhkshipoxtfp[sylshvahmztsbngdl]emwcmnpjzydlvvknrhn[aarrocnhsmnzqgozo]uswudvvjntlhqjc
adbrrsdjlpyizfgvuc[qoimvkfjruwpheezeuk]gyjjepfgjpnyajypq
xgkzhzjlkwacqnihyns[bmprkvdabnasxzqzwg]hxwyywhnuntidvpg[mvqpemdfnvvdlpul]ttqocuncdebtomizabo
zztkzvwguaggryld[fgkabjmksknxlfhzpc]iysntrtaaweknzbxemc
ocwsupvhvpcgwehx[vnmhfmgubwbhhrmkp]hqpkkwxwwefzojltpph[bvsvcgwsztazzzjoxi]iasiueagvwjgmcugh
tkxywinosybkrutpu[eluxrinxkarduffy]brxgvdsoguiggjfemb[paaawmhcmdxneql]qtvmkmlldspsheyac
vzcnrbtoegbsuglk[rqhhdwpschucsvlnq]hzjzijxkcoxpwhi[glryptoeiosdosoj]fhduvpzlbptbehtt[yigihwrodvsulsrsh]numkgigkznkushjc
oexrobvxlwbqkrigz[nnbfhaheuublajo]pvlstoxdjdlbroezlbj[ykvlcsvqstxycpp]rxxgokhffgyioltc
cstzrhymnqxwtwpnvh[dzbyzhzvaooswlkdrof]dzxgsohzaxvkiwho
hftmeaqbiiefqtwklr[bmqfhgvsfrywauxq]brzoeoncrvljpjqxpjd
vbnuypzeryxltunvcb[ldnuxdvgfcbbysibhop]ejgwhaxwgnnbfide[okhykghpvystpufnxqr]umdmoixuvfqgecr[rkwsaizjzxjgmmftw]czzteyolfgwkrnkxid
nvflxkucsnbsltnp[iqhnmiyolnoxjzjzjvl]ctdsnjzjaflstsy
glmwwqvembkbsnvs[skbkkvnoycklltrnyrd]irlewhaeagdiojbr
gmzbjlrhyoqkiyrb[nezqwphjfpghjubnw]lflopkhihhamygznxv[zuecanynqmvceqxyy]kddyqjerkeuhuamjxcu
kwneigdpqhtznqaide[ncindqlugpdagtfzf]ctutcducslvhztsii
vhjlncnrshwikfm[amlxjsoevzrlkgoxnml]lztearcwiosrcmhfi[gkdbcfroyrgwylu]mwhzhimfdrflqqihaq
wlswesjcluvzurgrnul[iehnkjghqwvennpj]znqbjbnszpnklctx[pkxxihelrhfkiqizi]dlmwkrxyjxaumvtlbc[icgjedlkxpjwmauu]cpbstqjtdebbywkf
yxjwddyrzrzhqrarheo[dcayrrmkvazrzzlpqh]gkvbwuimfochtndis
cmqdgywvwqpfkixkga[zkcmkmqoxmpzued]iaerrfcfhcaidkkvwvm
uhwbwhbgkrzntdxrw[pchhzpiwclaasygyqn]oalmglktkidoijgyg[yugfmrxigwwqldfsfb]otdsjvxzdlsdhnyk
ctjuabhainyjydm[axxsgakjkreoeifx]qaphofrkpiflusbeecj
hdfthabpjjuxgoh[zskhkbvmwkfmqct]vmqfixzmyefzvza
wnihepbftegtdrtndsc[wtmfxwvxzxorhbj]oqlfpicrqpjgvmo[zyvhvkalgcwwjucnxq]ppatiiiatwbpyiwjr
ojaqpoarskgzmtrj[blfchukdercwzqa]anfsoaopkutqfqltry
ofijvkbfofbyadh[xmlicvxwtnufzpn]jetnmprdolywrbmjes
fosypykuipsqxaud[tbfwtcrdgvidqsg]tvmvfhrepppxxwme[qpmrvterftfxchiv]flnooydpykdzrtfck[omhwxcdomygkbaeqrfg]cwztbmysqwpqfuig
lvojllusjibvayrr[izfttqfhjethscsrghs]egzyjonmwdatznvzjw[mfxjaelqslyvkaqir]ckbkobhykxhocczot[oezwabicsuchjia]ivolkjcvilnlsdnk
acytktosnzjatmwue[medgjpfpvbiqgld]rjsbxcwqhrrklyfuu[xclxdxjcgjwkervy]mspnrnsznpccgcke[ptntxmnzdrorgoexbsg]bovvgignwezlpgoy
wdefvabtqsgstwhdxm[otahaybdinlnszsaan]xgjagsgrnziuqxjasw
cqkpuofhsousjfnlfxu[syvkhshtiyisqmrdp]vtvtzgdxigpsxcpdkt
qwagfdeyxorxoaphzt[kijseqropygskgre]tnpsgfihigocogn
nvppsgsgegzthtmpt[dsjjswqmzkoqtihud]toeoabpfknrnwqxk[hgyvhoktbvmdvwauue]pniilifxxtotvypye
noijjdbzbeowhtut[tlfprbqoqtftqnjjs]fwqyyfzzbzjeykhoje
rewfvmohscszlog[dwgnxketzlgefgf]fmvoxbzpxywaicq
pvtakzfeeithcogo[mbktbqqelkzddsmn]nuydimwmhdyhrls
qfzdrtjoipdlwkd[fsymmkclzvcdvqexr]yrhwcyjdzgwhmuijhth[zgturekjlobpmcje]eywzpwpfahsrwpwl[bgyprfkbmyaixrqj]fvhhmcltucokvqba
vbpnikyhvhqnemdo[lnyocyrozyteoxalil]phhqtzpbgpzrusr[yygaktzkmithtegl]cskivnspoecsaoi
obaxlisumjgehbkpea[ehzysfspgzssttpebuy]vwceybunjzvlqevd
fpanvbmzhlkcazo[wfnkxffkzmxnslov]gtifhhnlnnxkeaolr[pwkmfvowikzjctrje]anfzfrtlihlyutaq[vbujdswyelmwoudg]lckbqqgkglpkfnhu
ubsustsojocdyjv[obkxihfxtkbaeusurk]zmlqtgokothiokq
fpgjwchgmuuwpzquwf[xtluejeypvgynbsdgip]nyztcugwqufjpakuxkb[yanyavbmpeqlalnk]tknqteuqrnnorhcm[eshuljurljirasr]supqastijujykowxxhz
solyplfhwchyjtchjuk[wuwirpjuevkxulrs]axqqiqzteislutclbzo
oktlpryceitvhqqjqxq[ufupbpapoxovifhqp]xgrwutvfooowfaxs[yxoxzdoqyhxsiwcxrgm]swmalhlzrknfxgnamr
kmmguldgktbolgarsp[lxrqjtqbuhuthezfcfm]nhyafiyealodqrmagqq
jfowosecwpywmrwka[rlvhxlrwehljixaggho]tadphuxhvtyxkgvyru[kdwmctblkvpkral]ufydjpceosbxpcy[qkiwffygsjragvq]zlvqihgbbhdojkgjgj
fjnehklshlckrcdhxk[umipduxaengqrizo]obuxhxbrybwifedma
dzeftgulomkuwyrrm[aphjorxpuphqsqmp]nnslfcfiblaexsbftwi
eypbooqqyvqucqvyys[rcijvtatnyzpafpqhwi]jrpwrlhuiihzfwt
zikyfwsyxwrtrgdkjh[netvaemiverwhfctosi]xwdoncumksuzsryj
jxtpnxhjudmsotudd[lgvfscyjpngmela]wumifhvbwbmmticp[dvxmvcccimvvcrvpist]czyqdmwoqjgnfvjuxul
fvmjytywcfdqfmfvj[nhufehmupvzkcrtewz]hyxlzunwnjccnnphrsg[hrfqmrewnweuyulb]hmqxiwaqfebkvxhv
peqyzkuviznbwojhtys[svfilvdawzpmtygynd]fpfggygzketpcrrqx
ttcupspyysrbukznk[rpewzuewspsqthbqb]yszbsclsnmbgoazsfl
vwoufilgfhpaqfxt[dmlwugzgaywwzqb]rkwtuggupfsffridmux
faibpioziimdefafugx[unrfywlgqlxqmwtxrb]owzarstubtqbwwjlh
mvgbokjnhpcnsgcpm[vznublzcbsgzahkjprq]qdhqdlpftbetdzckvs
dgpkamepjkfizyaknmw[ctdimkbvwctjqcbl]euwsfdqpvfkrxuwr
rjcdwjzbrqqqqljqj[vsrppwgvlsokgpn]rxpddxouefplfnctudb
lhbnntitpjdtprbd[cctbkujpuoegzrijpus]xbkzdntmvzbzfxljvt[brlovkywclhnnoyrz]rhixzndklgudnxkr
byahaivirlqxulwdoe[otyasqivnfuwxmpn]vzsqfapigdecsmaqd
myozxxksdnucpxq[jgpjjngigboxsoy]tidzlszxsdbqxba[lctczcenpuntfjnf]hzdlcamkehorgpz
uoylyvyljpnzqimzgh[umieqlmcsmhnnxle]zvxwqjbaemhtoexyzr[gjyxtenkxacukadvhfh]kwagkgvaqklyfurjnar
rqzfgsolwpyfzeg[fqbhyjayacblhmm]egufazwxlncxundcyyw
eexntdgtjwjtizhlc[havetzocjnmfnpgzl]rmeusmuumcpbzodie[efuqzkuscnrbxwef]ehxrajahcfdggjyq
ozakiysvzkycefw[dcjsobqhxqyxnvwz]yuoszalpobgzxqk
pterhsdeyetokcbtzn[cdooadgsexdxfzjmo]xdxrkcynckoeirmjnlj[matsfmymdliwcqlqf]llnuahmiztvbbpise[egvzoittbupbbqrvd]bantcrmtkbvvbxi
tqpfhtrunndzpsd[zjzqvvckxscqzavcig]zquncdjejdyzegvcm[sxxdynlbdymictrfspg]smgkjimutkedknlppsa
byjykuzyigqofolpgf[cybrboapdfgimjwjm]oczicilrowczdlcy[tyaduotkhfvyatb]iklhgcjvfdyypdrdbz[dqkfqaadlcnxfofsvw]syuiaqaemufewlijxk
flbmovywhikcuedd[xyzunixgypmuhyj]loihlyylswpxtenh[jadvlnlzdpmoghiir]xbiwlfkwxtthlimngnl[vgtvhphgxfsshkgkb]vttcixaajhdcjnqx
xxxluypjxxutqoozzn[gufawigbmnhtmwhcgry]yaldvqcedheoocj
seczijwqqpigqcchnz[snihttcoqeotvsvxtsh]zzgbjkslldiespjeejy[dxpgxigvppgnnddyd]hcwgvtogqdyllyhkqj[hbkamssyyusrgbg]dnnseuhlwkwnycktlu
xeupsswdnrpzqvl[tmaszjcshsavymzuog]svjeaxmdkgbimlv
dktkcbqwdeomyrp[fqaiihosklfctvufhw]kscgwrylrgbrxjzogj[hqvwmstcpchcqkowtxp]xfooorpnwwfrqstxft[zclwozroattjxczqx]uwnclgxymympirm
yohglmwqjxpcgozvfc[ojnlrvpzwcwgnfbvf]uwjufnumsvqwxpg[wrfczzmahjdxdzhifs]psipfjeacaysvubcqqb[paeelhpmpjlvbal]buinqeedxmiijkxpcpk
ficdlwimcpzelkxcb[kyizgumxqprpckyyh]lcwwypjwqbzhtozovh
bycnifysnrtdseez[xombfbujijpsrccccl]tbvuubyduxnascxjkds[gteskflapsthkzigcet]otggllmgcgfgqloehf
wvrrowjovflnwpjhhrj[dqfmznuqmmttqtdqnp]wevjmhhfmorcrvxvw[cnjtxcdcketvdidcbu]icghhdkudxptbdcdhik
wquydkoyevtyfwqyimg[bhbhiqnxwfrcvqcsdq]hvcjbihyziwvmqr[phnejggzeulkkbdxb]uzpvcrhqhfkdkwvxcku[piqegxvplepyfjff]xqgfyfmlqqgcsnngmli
aiufvoznehafclsi[ynuiezokzxlhzsnlnmw]buhvbbmikiczqjlfhg[qfqcudscoobzjdwfyu]dcqxfcrpnhywlcabobo[piypuleecpciydz]xiendyljklimrwaexac
bmcenbqijebgornj[kskdxdmdlojqtjtw]kqpwfyitjbkfubsh
wjivpitbdiigvkhfpjf[ijhxqgwkoctfiyf]ezeuczihdpeegpnppj[rdcsrurelstudtzqv]afvyxjglfxybwff
rypyyznanxetdychyd[srdvpypvsmzquaeec]qzehxnsvvccjqbjres
disgynuubaeuiwg[qhmjwkqbmmjhjze]zgunyyctwtucdho[xljnbisahxahllyiob]astxdjwqultlphiijvh[zmhdobafwbzdndlrm]hwcwvfxwjynbaxidj
cdhvflnylxmmlsgo[oollmpblrqislxgmvvp]nivfytkylfpufcdxun[bocnmaazerwhgtzt]txxystvwvrsyoym[iafzkvskmhqjdtk]pgdgojbemypqbkofwf
sjtahdwpdhuosbqyss[lopwkbhedbpxtcw]bvtrmrjxtncfnrw
tdofrfbhpawcjokb[ynloiqgijuwanfekxsz]fdpwynqofzqumlrelfr[orxakqzzdjfnzlgywae]udzboibfngqztfguv
huwdaehvnyhbowsp[kbskeavlxslbvco]sekeunfcfnrsjqgqpcd[xrfzxupwqfrobegw]ndphbckizbunwqmykse[qyoqnkrhdydzuir]romctjjzwxjbxyqm
eyutpqnxiqygxwt[wxsiplbaidmlgph]vhlavtrefmbfpdfbju[owuuvbqjuailmgynkqa]setuzkegazwdjyzskty[oaqtnegjwglqnyw]pyizfgyjbebfacjexkh
bxpzupefyifcfhkv[fyllboalhcmvoctf]bvfifvthhaovzixpx[vtppcxdmlfbfgvgolil]gtyweatzcejbwtse[prplzrovjaeczsyxc]jkylsdulnhfilbsqh
eedtujnpvzzzdpgfrm[uopptnavfamhccc]qdnckczikmbwkxfmst
hzpjojvdukrnakxzkdv[gychyosqibeedkj]efhirtkgyzjnrqn[egmuiotfolnlyjg]nbleytvfmuvypkpabt
xadnnqlykhisnky[hvfudohkwpthdtyxe]xumogpuzbvdpbnapcw[gaavnafcpfbycdpvz]xlgtfefhzyskqazl
ohnpejtztddevoitaw[hoixesaghtpruyayyzu]ksyuxpootryqgsfctcx[yoazsorvwpkcrjqq]allrvqctxxhldwwzil[rxxioewpnqttrzaevnw]tjgvhfbpninpzwvxtl
qhapfqjbpzieybx[iobyolfvekomzeelsd]ygcprxtqzmwotja[pheachmbpziycyhykp]yhlmlzbdngqpvfcjt
egcxwspabytsgsbam[hewsugjwdvnywgjhrsb]gbxbpxonzzllmmkags[jylmvbwwjvmvkkgvusd]fxckijyjjwfrmlzp[eiohquiromkekgsbp]bpimyywlklqwdpfasc
iypuotjzbcsafzclwb[mudgawqgospvlepaexc]bsqftdoatnacbnpqk[bxaxwphnmcxlptaz]yhbsqduzzzkviyxmv[cfeyjhtefuxjqndg]rknngkyxrldxnqxfil
epqhofdmbeblgqjcpan[tuffplppwdkoimwbu]yiyfzqemymmtzevrvtb[vzuuiqvvudpedkbdgq]qzkbzuuvgzujipvh[etjfbbzkhkhvlslkjg]sqkdjmgjilbpvmr
cukbhochuhppwcuwwh[ziuieaxmtjrcovi]egmfefvbqztrinknvh[tcrdwnuqobusvhhhuw]llwltqrtuzujeuatp
uegokkxxfybcozva[hwnrfpsyzbclsubdc]kxssypkvfyghukcsted[uvtzwttuxxztqwwyjx]lhlyeezyttvgxgtz
vgriivdekqhhyzgmc[lkzxlushgdqezkwkbv]aqtzbkzcfxrkuwkw[aeubxxnhyhlolauhnu]qphfpphyptbmbvcyutk[xscabrjhmsfredzulrm]torgsvodiuuxkgcp
blygklicgpngtpgcldl[melaiuchcudinutcx]fldhqlhwyjqhgthjsrb[qnvfdzzszgaedjqky]amhauyjuhdistfgbipm[irrhdtrtvlhanuhfb]cszydrvyiahzwegkdiv
yrncnxrkuamoung[vteffidkspotxmwhna]lohvncugddeuevq[ueuixhkoouhzzfucs]xgwgddhczhiovgacg
gowzwidadczncgofqsa[gzkezmlagbaetlf]oochwgecelkuokyunem[slzawxgblqhorfpezd]chugkzdgaukccbeoi[apmckbkkvlblsel]tokgjnxyppksnep
zyqnagblhgoyiqihy[oisqkkmqfxdtvfx]qrpxcdxvmtlqbgvm[rsoqvutimhujjhbwaf]xtdayhoscopmejfxz[sqcpfrehprvngyagm]ecwgbravfceaajqg
nntkrxodbypdodgtj[lnlglurkrynztgae]twtxdcskknbsbinlnnu
meztofjunuxbkfx[cthbsibrfgxjyjawtv]ujhnboyhpoyjprrheg[qmjwvltvyjgntydrmeb]dsbnlksebapwyfrtr[aoyswieertsyvbfijuw]wfzftnldrfdpnmnn
aanwuubqnptyoryyrw[izbhposjoffhknmia]pmpudrwiwouwspqnozk[sojpnvluazibqcqkw]veawduaoceyxmzwbgd
aenjhairjysyrfylli[ksygiscororwmpcbpl]mdggayipjsxxfhz[zrovsdxuwyxjjbfm]vpmedxtfdporoono[zfnnenxocrbtapmnezl]odykztbwvuvlngxkwm
aetllelassgaxxhspd[knioznfojvtrwjtnvfj]zmdmmmgudgcrchsuufw[qowcvxqgjaoptskz]qyrfhavolkmidaul
gkevcmsegjotmpa[yjvykufplocymkaq]yhewirtmatswhjud
kaerzsgqzwhdrlzk[fgmfnhjaylhdvepgdr]smkwpurhnnhaqccuho[cznwafhuvozqolaruqx]ktiyadiryeclynr
qnfeguqpvoiadeipxs[tuodvfpmqdlndroq]ruumxxencwatfiv[otgvbhlyuhtbtyfews]swsjtpcysedmpsgwao
mpxuvhlsahhdmtwlhz[saxrupcdkcfpmpvzk]rctxchvmeqnqsxqizr[isqtziiuucctgioof]vdlchnruvtuupzvukfx
czxihwpinbwjaatnmx[quuiszmtsnqdsugbr]fhhhwhvrnenwekmyi[phwhrltyjkmdffqyu]woxrbiznmygdqbptf
qwqniztrmqkkiyg[yvknzntvwmikawjlgh]izdzijciztugcknoi[mqpjeordqprhefbbsdj]rtwjvqdagpycdsxtd
pyslrefucxvqpgtnfd[guaqdwpjlwhfmmyzxln]unlgsygdedtpfrpz[uxytlfxsaeouxxdpdb]ufpwpasnaiqyqnex[kiulyoykitwlllexti]cvxikzspuywpgaud
rbzuremuvpunjopiw[evldkwtjsfwgvdl]unsafmnksqehiore[ipvgyeheeuobibga]ohwjoehyibiihubwuo
zlxdszmzwikrjfjfh[rmzbjspugrnhysidi]impguvxjhbhtirmdihz[wlpaqqnimsearxzka]fftirrvfdqzoyusjucj
yvzxaecltitusbcfqv[witiggtqtgarfrq]bhnbijcfbhoqpojeuqw
peyeydbwowzleyebpqs[abxvydhobwmlksefjy]hntuuskjfvsfwnmh
gxdajcawzfzzhjbzpxm[nxdsexkhsbaviwzw]kojsiljoybqxuvi[razmescyfxecbmzc]fdayjgkrzsmzngiszt[sdqgfgolavfqmuzqag]uzbbbcwcizcmhntiom
gssllxegqicytbgko[imezntkypaaclprdo]hojadqftyszdiohirac[wcpiroednqmsrywvxsh]gkfmxwfuaykpwmdukm
iwdziuryoqkhqzukcbq[qdoppjrevjmjuod]jewewfyupjnuydkn[ysbuocvxflmhbdhlb]ggjdqbzqfekjbbf[ubywismzabwewsrl]fufmyromzqrxtxsijkl
tbmlgasrsqjxwto[mvoqzbghnwpunzvxu]wxnwrrzdalxjlflva
hlalpnzdmwlhuwewel[uqawlldafxwhejwbxj]vkktsmliwswarsq[isoseemfosjusoo]bjbjwogehxaqhasloxq[oktpqmpxmsnvbnsubz]ekgpiztxkkuvpszb
xfxkkivnffdwrqecja[lvgeafomwyqhlfd]uyvvthewoyqjyoo[dcoayhnhnhakcuv]sfucrodbqeqcqhpmc
iqfduwigwfxgkhbge[qojiewaocberonshm]toxtpcpkallieefn[swenxuejqehdfutw]oaiceeyuhhzpazuyaiw[gqbyuetdmvtttffowv]neqopgkvwqemnrmauc
bbwxyipchypnmsk[lefobpxeokqvfglny]rwdgvzdupkxjhppcqp[onrpulkcgonndkfq]eegboakcdoqrmdgfta
yxeegoeubfjhijn[pmdjdggehnbtvfqkdk]ofdoklopgeznrvssgdc[jidbyndormgpitjsl]ucucnufigpzjuuxdq[phajlefstzyysdkdrh]vziqmjzpeeqnqholz
pnlllqydepsbgkrhm[ltoscinqrrvkdyusds]qwwtxmmexgsfqgoh[uucslmiboquvlso]xmbeigfpdmodrodwbp
jatdtuzlcxvgwpryf[dvyuqxhxkurrpblehq]vowbsishfgkjtvicd[krvikdxyqlwdjjnd]mujppmtqzmeviflf[ihqppwgfywzrqyx]aobhudzykvgwwhirfiy
thmdermwtxojztany[xcohmubhlagpuew]lnlsiczemaohvjhhknx[spnegzrtgilojpnoxs]spnvmefqqzpdfzset
jccjsrpjiyokryde[gfwdanjjnbycygt]iqiuzghicmveelbxp[tzugzompmkteyydyeb]bkvntycebtvjlgour
rzskdzdoxsdqinbmjlv[fnwbduvtemtogsfi]oayebzmwazggkoo
hzpsgtucyxemkvmfxy[duxikzpqdgcmkbl]bluegvpkqmjiyzibglc[qruyknjgybyboyvmrsk]pqyrdevwrpeatgkyo
uubdyuzvtcfrrdl[stntntweakppdrbqk]yoiwxzsdefzihdnilx[vvvsontntjvgcvanni]sqdbtjoziwfolwbby
tdpetsinuufpbezbgpt[hpklzrbaryhnibm]ucetauqranqexnfdstk[sadfrrjazeweeec]jaozzdmvmylzatlon[gyrmfjwewarvlpsh]wfojorkgrvraihwpaf
sarrhlzjldgzhyuvefm[braqtukjacxtcbrgtx]rpfporiksxcacot[zezcjaonoyzxnbgd]jmrjkrugljonkzb
hclqtamrzmzkhhwcd[hcxqnplterhqgbude]kduskujldxotldizi[ashjjijtmbppyhgxo]ozdvjfhxmojeqagmoa[dppzupkveblwydh]qonltaesyzvczgyng
urvfscylyvpyvpqwl[akngblyladvcuwa]pauygcletxnisgriad[ovsqsgvuccmdzqcwn]jjugrvjyydebzrjghae
ohvihbfwdsvpzohtu[qsxghcyyscnxwgnspni]kxlgrkvsbjeomgckk
gzywjgljugwxnrv[mssfmontfbahkya]gfmnxglcggnbrpvuxv[poejydksxougrcw]tiqmbdmjniaqnqgptk
hillvlrgjsewmjkoha[iighatessfoqwexqdc]iqwztbnauifcazihogj[xgovsowyvdafqch]qfjgljkcgkdmrnlrrmv[hnjcrfgkftyitryole]muemrwwikauccsregut
vmdrttktgqkyovr[myycrednrrhozjdhiog]qrrfvxcqpthdfcls[nipthbalwkyqrmqy]xaprggoudqizdkqu
ofmohzqodnueziyemx[njkghrspckzhduwsrg]fxxnmxloclzfmlkebpl
naurkqfrkpbbfkmbe[cpttgjergcoemawxjtl]cdkngakkemsmtgtwyzn
xtwigprawkooqitoy[dzapkodeyqhkixy]zrtxkzjqgqeuagdie[vnieacbchbgexzaf]ezbpshpznqosvuk[mcmcfwuzlyodiqez]bojvjhtatwvmxsxhkbs
muiyjlnqtepriyly[cnrfxiwdlkrqsarpc]hdlysxsdtpqxquhnz
clmaeawlvsluxfrhl[rayxcpbervctzew]syqcakahftovtzcdl
ljjlywtzejfslouih[hmsyjqsqljnppyv]bxdissuzzauueguk[xhyiqeotzpbtzsrd]wapoxmkfmxhbykdv
duvdnbsaqzqemzc[kfefbyefuptincfaw]jhuvhgdqrnjwmlfrmr[niprevfcbwagwvewhj]hdhrwocbqysjstefldo[uelmkdqczcnlmaefjms]bwszcueianjsjhiywwh
yrfewhgpkihnhct[pxzsdirhdakahwdxteq]ygayoyiuikakdqo
wjrmypbsxqajzbtwl[pvltruknhkznchej]ypobvzyforzyiihvzq
pdchmvgzmxaspkcwkpp[kekolrkqgqcekeitv]xwpjbdcxgoelowm[wxdhdpqotthaeay]ovvuawitaqelckg
fcqvgochyglldipl[ryndsmjdhqvikwnexf]smwbuebgfzzmfftrdck[ynaegesquznhgmisvri]hwbktncquitjaqs
hcbbiznmlcfgdfjtgc[xqnepuustubktgck]jspcsloqtblxprd[mudjqeoagjqcfato]vgguzyxablhnrlye[rvzjejrpykdzzqcpgmc]okcylioamjhremephbh
ihlcdgalqwvznxl[afsqmxduvmdjftmrjeq]ekvaovqjvajxfdutwhv[zolonpiqednbtfpsrh]vurkbqdeglqdsml[jivoaiwnfpbgbzzc]neycassstykebswqao
bsgrhhzfgwsgzowrbj[mvkzjwkxsuwxnioolfq]yobngzosyzkmgrphxc
edoabezjjyzijqbgxup[lcxkqejwnnslgykokx]wihvmpynxyyhaysxvrq
wmbgvnekkdivugwirt[yuioeaoerarbpcmbwk]bdlohxkfgdbthtxlc[zqpipkuumpyyioewz]xssqnavbegcidoenex[xvcirztjwasastitiy]mmcxttawlbzdztesk
fmfwtjsguazrodvdy[uuzglafbhjlwujwr]rjttgtqakbrloqs
mjtlntwhjqjoxsbhk[adswsdpwqnvqtuj]uwzfdezklxcvhvhb[rzmgufbrcamkvsl]imtazflkqvdgqvfthc[pvktfhdynocqbhqb]qjtlmgsjspdfgoazn
hfeiexxrkdehqttaam[uinfvckvhatgmlblj]rhksgzqfcizyqqx[ofgjnqhqhveobpzva]qaxdjvvaibeenyuzpzl[ktwkynazrcnewdnb]yzmotgipaelgbsahicf
djhinybbfbbvidnyest[zougucdzxpenqpoi]vvxbocdotanwdrjks
poulgwkphlvqfjplgw[enhvwdoftxrnowdy]jfepitixnyjgvvl
agbtjztsonrgwzivf[igqgvjqttujviljk]pmqphqrfzfdiinxhy[hjpgkjjwxgfsiki]fqgfwrylhecwcoowxsi[fygonoznhkmzcjcpm]nwouwxzbpqmsxnfhedh
fnukiqycmrzcije[optroggxrsbsokabplj]vlepcfzbmvrqptyx
pdteouejbrhsicugggj[dipcyddhrktybch]rsynpfyiklwyhvlzoxz
yuxxurstojjfnoft[obornuhvvdtcyzj]kivbosojivpliva[twgyjecwqsxjmgi]hbphkpnfffzpbwjgf
iuauoxmsalkxobrgb[blehxxupivauaxkahxf]torbqoddhsksgtnps
sjgwxpuwloyujust[psqoquaifhrgmah]vpaddscloldhahh[hditsfewhihijrpf]ofjdasdbjvfrwefs
arpvdepqyadnevyphg[kbpdnghrphvogmn]wrzcskupnydzepdmxkp[beeaeyelchimtyrq]yppeqczzpjsntfytp[aofegesxpscjbehmcr]wkhyeeykbgemqgcynxs
ouluccjlcbcurdpkzg[flulmqooipvjzhip]qkxrrgvodksuivbspr
zfmcvmwchidwtgjmpoh[ecthaqwuytzvxcfk]pwvwrbzdjqdtxlq[fwbcqsvdosnolronvef]sbroultaoabvbtvh[ziihpfydzrkdqsz]uydoxylhbdlicydahf
wyvxswplnabvdoeshds[zhrpmmoiilsleemryd]pgkwuzialwbqkiw
ehkebgpllhheumhf[pfovxzqmiqoxdmywhc]qpzsvhisrjgjfqnliw
bzizropqhokoukoxz[ahvweuhqlrysrwu]sdmyzgqcevcixtomzch
kfyocamgrbgzslp[bclztdzvmbyetlgjk]llzxtjeauatwnnpkrvp[pxshjlevsleipkfkmf]xblovddfkfhviqulap[zhqfznscbngsaej]rjfncwzuuqwowdhfk
biaunelzsqaxohte[zyqygmhjmwigxsfi]lmdfmblocglcxaszya
ngxgqwjnobiygnm[jnhtcpyfpwpwkxapib]lyhgjgvcuwgbxgxwn[rovvgibkfcahiyn]dyojmojklujquiqfsj
tqdbdrqgfyumjwktbg[weesraucasfagyailb]ilhskphxtzaqesynmi[stfgxrouxicascniwpo]yfkxnhvrwkielncq
twgbfgwbpygvbfnyy[xhwmhyacxxleyadli]wffogpkjkmysxzlmpuv[qnjizoqydldcwubtux]askyjzovxsalrrgo
yunqqhjmfpqqycv[vamwyuzotttqgdzgj]lmuivwjmlbeqkay
qhquozlhiohsyzwv[utxfaionxyjgcnpulf]nkmfgjxfobxmrydyic
wehhwiznslzkyncnkc[dzxeftrnxfhrwprllke]imknddjnfrzanslzdz[dfqldjhkxhowubxs]ojzmgmludytadwespep
rbkqkcqoxrfczfwte[poemreldxewfaif]vehqkzgxcwmvocban[ffpechryektpzbdaivy]emfkcgsqpqkqxiitol
eidbkaxexnexudiembn[xyiztwlbqvoavomnlwv]rrfwfdixzpzvwkhwlw[kjinrqheqjsynha]pilasnmhghvvgaxor[nrgzhlsetahyskduscq]uazoholzvqjdaovgjr
ynlcechniybypvzubo[fupezmnrswguyjysfj]ckmilshpttvobgoux[hybhkdzvvhelhyvoynm]amrybybroexntrlcmvy
qpmlcmgstzjfincjh[axvarrnhwnkyucrz]wbbpucxtqbdjxsug[tutypessbhpshlyt]wwlkakvsggtbzcz[rypxpzrrmmohyowkja]aeuhylvosccpatslhp
hrdlnpgexbirsepd[waphktwkfccnylxg]hgukjgxutuzfovpazhx[jzgspycuftkivlpx]bhfazqqagtfpljr
ciyqjrkwqlwtuhh[lknvhwchhuntllyvjb]ontiepkrlphiydhyir[pdcojzrccoatarrqj]rwmyqonvfiexmbnjy[nhknsnxkwatatfhwa]qzlqiiovmuukmwypy
tjxbenxjlgozxrtqdp[fqimqatlktqjwjdzuoc]fedjvxnqivqaxkvcw[lskccrwcsxulkabzp]orszzlxhimwlzfawjw
yufbensvlqaxthui[vplidvdhajkxfkledbz]uposqezqxglywtlxgg
wacgjknueqomqccqnkf[erdhexyxtcmmvhums]bnywbavxkfzbqwlppv[bwdbqoqfxejqnsgjd]eafoepuyabzlznxw[etyfwvldfchsrdsjyec]apzomripffavakswd
conwdmtawpjnzrjlkrs[lfssaruafijkmgdp]izwehdqwarvfgxi[stkwrpsrwwucxlrpvd]sucqudlqvvklrfdgac[gelbgtycawlilemxamk]zmdjppqtsdlqfbhmm
ufwwjiajxhcorfa[hrdobejvqrdojftlnj]vamxyyehcgnupky
eonddfixsvjssautqun[kktlnrsxhmhwisd]drpflrvwelqqmdrcleu[vefzppqxcrtevyv]yeayirahatkufcjvax
gipuuaoxlxfkqld[kytubcrnjxvhdxjto]kwpqrvvtjopyigmq[urijeznvkopxtgkd]infdbnklnolvaqwwvo
bdqprkxthvsgqlp[qtcbdifrlnjdpxrb]xqmtwugptmssrivqb[zlkwptpsqnljxxod]esxomobcnfjuxxdmsmc[tifraqareavetzrpw]dlpsxjssqzyqwhd
ylwhvgowletbcqjgr[tnhoxqhrnytlbnwifx]pyzwjmotosezztkqd[ejfcslurfhiompqindp]kvbfdwfmwkiswfm
bqlhxpzchtvwcqc[jhpqckkyntskugvua]ylakfwmlerklrxq[wjrmeexzlljednrxho]rdobmdgxkucmdrk
ehtqwbiyigxjvkp[qujbspkhxogjrzskfm]qebesubhovwonqudy
sjqrkysnnbgtkhwe[ibgrjvqztrkknsr]mnbkbbxvfhsihzkbsqz[hxxhvxonqzrgcant]kbkvnbphoymseakbxjf[yjkdvhsscxggtyyk]tofzfukarcsahrmvs
ndepmgjnsgfsttp[rgrcqahcpnsyknjkd]uablhivltavxssnx[uwjmrokgisrjukeoh]wollclyotaektyjg[tzbziofnztlojbros]qvbgoapfzbecqwjsq
lspiukvizecamzh[vgaxbxgipyodtbxb]qpnkwuqxsgnihgd
khdzfhioeykvnvxuhic[lhfxiidbrwldhvfav]rwxsfwhshazzaxvk
coaljuoxfhvirzhedxp[femqrflktuakhveiiye]iabhkrebiawlktxmbr[pzvgzzcfzhswxitunrj]kqpbmoluwjetvhdcr[tyqdtrnkdmvdpuf]skrdeadiylehnbiyvws
qimxmesehwdrqskwitd[nvgxgwksihjcplpl]bxnyyafyzxludvyehd[hswtrhxmggpcpcvew]cucgudrfxfbietibgv
moiyvifvvucewfqu[wuzvazqcictmsbtq]nktfnkfjbsejorafo[vfreizeqljwshfafwdx]xrtbsdzcfkdmskiiuwj
kchuwlbokzivzlzvib[izbibinxysyjrvtapis]vugjoxtigdmbdqjn
xbclcahcqnbzwpvshao[qkamrpzzmssylpxb]tjsufvzaorutvdu
hraytavipeznkuoi[jmllyjddfakuxwfsx]ofoxhbhnucmiztrtcji[vebzprplbxwqnzllu]peaegqqeqbjikxff[jxzebruqgpoqmklz]liakpsmvutnpufovqlq
omtbdjlfagkxdlntz[mhwuaqvyldixapgoaec]aghmtjapinrxlvem
kbvvqlrdswbturvx[qpkrbbaxhpljnhlytou]xsogoxibyznqcpqgygn
orqcxbycauryvjxq[ijorpddboqkyznnnm]rvildjpthqvtdrzcq
hvttzyckbqjbyfdn[lzeulxlidymszjl]wbbmixifmqzkvypqola
eizqnqqixewedcvcit[ohtuntptfbovbsnl]uuswevyvyulevsfnw[etmfugdbznyzikdtx]euprxmmhcrdoefvfjg
pvxjhbwdlshqkth[gwmtamzhtucvbkmwacs]uyephbahzeptqmif
zitdlkpouvntzndz[iluwraejfdnwafe]fuevzmqlsflfcht[suumoqktussjsze]dawzltubgawnahpd
krskxctpuowviqiqxu[xunkhvqyyqiqhyx]rcdhdjoqrutobnjpimv
frsjlbcvuwydaobhii[bdatbysbolkcpzcxoyf]lwsfakbmjilithjrls[fhozecjhruquesmkca]oorqtbaamburjorhy[occzlzfhekgspeep]lilnnsqheytwakzah
ragajrztetigfkm[egetcjedsnrseahrxr]cblhtdmtcnoaank[fzhqephlcyygbwt]uyqlhhlhmnfyfcts
nklzxesmrrdlzyakdk[pfexuhulnvbmndvyat]xjvspjnesqugmkngn[vmzvdrheaknqmzyrc]xfncycggjiaqvirfvnn[aqeinzmbaijlafd]pjojbnvismokshrs
urteecaminrqiohs[rskgnsdfpksfznqpphc]yaxixbacbtysdrnwixf
ibvmhqpmnpzmghdtdpo[djdzntakacvezlr]jtdoweayvyiaskblc[qhwimwixemjmqsu]rzekezftftlqqovnq[hzeyrnhbrrducxz]ceiqewhcqqmqluro
joqwthpcrccoovxrvq[qjlcrltwaxkjenbbql]ovebjdqfnfkomjpswn[qhwrxhvbaattcrkvff]nmytfcchpqktagojhtf
jeeuutsrxjlqegcdlrm[chrtabpzdcoetzoopc]axdhgbwmwhhlrvc
djcujdyidkcgwygy[zfpuoobkfdetgiifrpf]uxzlkhxzqgiuyvuc[gboovijloiwizfuuye]wimticbreszjcpsls
ylpbdnvjaavulnhg[novahskycjcruokxbrc]gzsmxnvpupgxwhx
qdarjsoimlwxduyp[nghlzeghibocgcbhqb]vuoixghxxsxftuztlxs
ikdnbajyzpzbtzjdey[fiygpvlyluerdjvcdc]hheswtvpmtvjochdsih[kmjnhhmbpokaxsrf]byzdcdlvgyorjvkujyl[ttxlhbnifbfgmvs]onytmkodkklacgel
rcpgwlbaskiorvxhgsb[xikxwyiageqvilea]rhkkzuqtuxbhuygcxya[prteqotsqfyypus]mpdedamsijgmdktn[ptlcxgtlxfnvychnwe]mdjujbmrytfbzpslad
edjzqlaktolcrbwboup[bvmtkmfmidimoohq]kpsgyntrgidclnq[ohqjnvirkjlmztem]smtywugfaobbpvmzj[aksdrqczxftjrzuylmm]ffyrsvfwtqlmwbw
rkgutyhaonmyick[udryocpupaohqhrmmsk]lmusznhxbkbagotha
ebtiyamyxtfcakoku[tfggedpatfzjvirou]iwbguywvekoline
vjyzycrsfycfrookru[iszkkyvwngsskic]bnnqauaqcfxctnyofoi[tlegfofrqiuqlgkld]biryppugzufezftpjra
neipbfcjvrnrmpijwhq[eppjsmrnolpscnfowe]crsmezklwmkbysajb
quwdpyfsllgkwtj[ercxwsjcfkbpohokuc]isdjfklflnudrjetf[fuxsclqmfyplxxvao]xflfujjqnglxzxlxz
vfxrgmnvontljaodk[pwtwiqibbceehlnhf]lwzkbshrmagzhwqyq
ecfthornfevsngitzhb[pblbvztbbsbsxxuwec]jtjnnhwkekrgjanoxbe[osbstvuwyjietzx]xiordmxphcsjnzfnrwe
tcnlllsrvzoxupp[ficwiahpzqtauuk]whxfguillhkpxitoqq[ovsdwbddmfojvkqrxb]bfagfcimddodrtb[lghczsmdqufswoayezk]ctkmauzrnhgotbibbb
qahnaxgypnpjftgu[bghbgwqxwfnfrcybzd]qinmtddfxbpkhqnna[rheeshzhyxfbcfxkd]awwsrosrkyfqcvtx
siffwvlfljwbcndns[cawuqwatfhgwsphjn]twfwwneebgzxmqyrhbr[awxuvozbhlohuaxim]dykizkumcmmnwiwdx[dikxuxtmacvaxiwih]mscklmepmcgjemwtvv
nwnwxbeggraucwj[ygdjhwgskclfginltdy]ngfxeqsonadvobrnwne
ceulusceecbvzesfpia[etyucdrmmbsstudbfo]jjzwvaqsiovrgro[msadpldzcxurzije]mjrrrqwmyqxpdgmp
aiwctbwfathsnst[ymcmlyeojcaokgf]hchdxsyquapjjgncfq[adzpesdwzpvcksioys]rbfqvkxsicnkphd
hnbounecoxhinavuro[tdytxmzudgjmyxmm]fovpxazijvtvirqfrup[qbfsslqkpyioabrzhlz]htlcbtysbfxurnuqgs[nybjnpqgugmtfculk]zxdfwtbtbvhxyrtcodd
ecszlqenzswzeujn[aymhmhqkvzbuabtr]qasueshfbfducoit
bmvypnceplfbhhsko[eypvaebyvggpcmzum]ycwgnjvrjmdrkiao[hdkledypozrgbkexls]isuydppzigzqtfo[onvsgjzwozxcvgkukez]uhjisxtizfjiaebue
ljvtminczzipicxg[eqfvilzenlbztef]hpdptelqvvscyfqjbk
kofmsmvngqzdobeg[atcxvdptaufgfpec]rbyvvgagylqgryjmdz
qrqirixxxpivzyxidp[vanhxwefpeffrphvwm]awiajngjmxhscxctxt[hnmowanymdizdow]lqjbxcvbswqatxyp
baeknzdxlkxorrfi[tiqhvwvqoyavllfk]uqqdkslrjsueklu
usgfgiqvoudfsdyov[unqciexsmnreobavmoq]kcboezrfdmoqrgg
xrqjdugnwddstnr[gbnpzkldpjyfady]edvtrvipwheribydmaq[mwzdiuqdstogfjy]owanzbjqvaqgsgf
oumjseobbaxvipit[ukwqpfaqohsabpd]twomizennyccksgi[hszmrfksmdcycyda]connwmiollbtvgh
skyizttcnisqncq[lcxdhawnbdbcptj]ocvhdptvtfnwqcdmjff[sqbbfcaufseolqwcjt]xlnlzmuciirvedlni
nwlhzupppktailtktkb[bzdpulmwswdaqrv]kncfgfqmxoohevsxfp[vgabgahytpqzalhap]bbubtzxxzeysqyqp[nhpmkotpzfifrfpmk]fruxnzwuvonfoxc
yedymyfylbzvjfwst[woezxcgsurflqnrmvt]qsiblcwatgywwbktdmh
gnbeeaxxlvupyacdpl[dhgikxwvtnhllqs]dzsbgvmgvhcbygjkxz[qmayyikkpsqdoukt]kdfbifunpwlbhsh[qrqskqnysxtloxs]zudxossasajrdeanct
rhftgsygepdspzqbewd[lcmdbukbzwdesfroixj]oblwwxyfconxmhefjow[fvutwgcvuaemgzqanrz]xtiuegikggcimaobg[uhqwmtpowirexexim]txoyjvcawbfxprxf
viebpcquqeagmuavf[kxfkxsoijrjklkgtahh]gdxrwirjrvzjcykax
uptdisvspkluwgzkti[omvlmaxnyxyzwuian]pmieocovsvpfcveurx
ejmnzzuuduhzoze[xrdlxozvhgiofrc]sxtycslunhjmvejtkd[pakbfwkagujukiybe]adudpcxmlamtkwak
lqyqdhuldmtwbvydji[okhzffzbmlvqiko]wdcicvzpzkaowwqnztt
imnhospjiqsxihx[utoykmsvdetrkdxvzti]zgdfvtmfjggwyjef
lwsirsmcseswkfxh[izotdhmoodsvpsp]jivuksxahorpwcgxnn[plncjtzvyamfyxzst]nnpdtmoozfzuemdcenb
puavooykfwvhwzmkglt[xutftanpuhgsdznc]rvzdveoxydbctczqu[hetpqpdgohitmgtgyp]koiwybsyijhmmqxesqk
puivygxavmlrxwkst[qvtxsgezqcquyae]brdptsxbxnobkvcqclm[ibxfeuecufosgtzhxg]vziaqziqriftdfrpnll[bjfubyvxxrbsjbqvi]nnlbiuncvdtnnarm
tlzooyjugzfsomi[robsmcwkpeprtatddr]taktjvhztdlygkj[vbjvzeeznvmamus]sformulcgeirdihntt
zbcyicsjcmpicotmt[tbrfctpfnqspmvnv]edzcoymhzfqwbuyuyu[jhauxxgwnguurrviws]rfkagjqfdvhjiavoxtf[zdejarfvfodyslh]pzjedvtgzwflpduq
dhbhmlhsizoeldofqs[qcypvphfozxibpjdo]idntecorhucvlufrwu[naoixcxuqlgsytnt]ehsyusyugbmahyrn[djtckrolqitsztwtuq]urantneyeodhvorgsx
cnsrdanbfjubsdd[nwynwjxiyygvgdlx]gyyuqjjvumvquvzib
otivcdfzmsjivefwujc[yiveblxrayrkmfjwd]mbwaroznwihbnbmjp
fwanqgdmtlsezhtvat[bhxmmztvspchqvhovae]cnjyjntrcijkmnjwnlp[rziosbsufkiamqmqnmt]mvxhzoxxibbkezhzlks[hfessxjoefqfbgxhc]kdgmlomxtdfgdgku
ygxiiehdqiqtqjzj[cwbddmmlczrgdgpibge]tartaeajmndarksakye[qnurjchyeijxcsdpc]uguxoncwdrojsyszsib[mlwwasmjacumzfqr]sguglzsozcdjzlooexl
ytyzugjtaxtnwxkns[aclewmcdbbbwyyu]hlfhrgrigvwsdmdethb[osohbeuazmmffxyeq]ygmbsfwcmyqowdvh[pqpwyutdqwwunfqt]ppkundibovmqwjwyll
vcrftmfliijtpaqsoy[zcpypxlyshsruwbclj]mnwgypyvzdxnnie
fmfdmvxkdupjadbxh[tauggdjujfbeogtsgzs]pygzoyudakrlrlba
ysxiybmwpoygkyle[xaaughrlqulsertp]iukezabalczvwieegzj[wlycqpkbqptraajl]mjevizxosnolkxnfwxc[veialybabbpytrf]tpgpqighdqgphcwoysw
cnxnptbcjhgrxrtremt[tjguyerqizvuobq]honeukqpcsoiapswdgs[hcroutdslvvzypfklj]owxcxqehkqqyeflgi
ypgeqbggpntconrgr[fmsyjvaninmkfqekne]ykrmyjpfwlhnsvgehop[gvltviftpcixosamy]xlsyzevtwaokuvneo[nbfcynlfsbmmweiml]nxuzmhrwlucgvfy
zagsvkbkhcrkvnukl[pyfiiavqjgonrarga]antgzbmtohtndzgf[gkvovvdgppcnyjifrc]lxdhpometcwlkofze[fpxwacqdussynpwd]mymrmftjovoqtkuae
xrtjipuirgczdlrrlnu[xdczaqvzsfgavmzq]luocuzuztdgsyxbcy[agpcmbiyqxfntvnmzn]atjschwzmauidumzxru[gvmmftvwtfsvudtd]vhmononuocptbuvorau
fzozmcmcymohndlq[rnrgxsywctnmxxd]unfjafhfgeexfykym[xnldroqvnecyhhcwel]wagagwcqljxduzebjeb
efvejswssxdrqggx[iqwwyhgngmwzwsw]dlkdcjxurmpsoceomp[scbledaqpgsgynjo]rsdxazcyjgcubfxlbb
rlkrgjrxefztgtho[tphpsircgzsauqfew]ridnbmerksozxzwx[lcqwhfgiihdzgtgudp]whskzgdpjubkztb
qbtcopfgkbhzhhglhh[ostebaqylyggiyfptkw]bbuaatfqlpxstpgwg[nydgrdgyazzfwlagrz]fiiddplgxeyyntyeb
bogowskdtwkyhtdpzw[uxvrferconwfnnj]eukencoekwwahhefvs[xtrpjeahwpxbwgogfmh]axqvtgibzojnfcku[zhkpmdtwlogmypeqc]jzqywlhocshrdrlgd
rdmpdlidbkplejoikjc[iqzadghltpndooanzp]ltizdvolnhagtlvr[rqcrkoaqwfwjpsrj]rtlcwqisvkznpvrjrbi
ndbtkvzkgjsuyfibsn[gbfhvruiotbnbtvuxaa]xihrrhcnbnowthpdge
vxtgjsiuodbsuhg[updgogkqrntiedefvh]xwgrhmgmpzsxyen[tbhogopfepprmtewkm]fmrtnudhysikudz[rrdmqrctpwlcykzr]lpbvstnhcmvnfcpngja
eoaqeiqpsqdqkdvia[pdyuqgwuhxfiukmpvw]wsjyvdabhrdsxij[puikfklqhrmvfrwomu]zvbbuuromxgpnmpviw[fvfilnspmeoxozaba]yaouxfprxpkvkit
qpaksrcracxnyuozqc[evqvzzqomyzwufkvxx]vmbkqqkzjskcxbmbbp[alqaapbcvzuxchmaa]pzxrooiyfqprfaucxue
jmjvvyxljzznmaarmau[piytxuyakxaropkfnfb]txaaoeuvlqiwynhqlt
yrgxyekmldicpvo[wqcvsbptigcqvzoet]jjwvbjbshgmwttac[ymvjkuxxoojchqomnj]tsapoddljyrehrxrke[ajspkmvbrzxrxlpzw]hwymrguaqnefpsza
dmlshfvkrzncuuoo[fddyurlzqbpqdidtkrs]kcewmacglikdszapy[fltgxlltlvysvylrl]rgovwrvccixdullrof[bqkrpxjupbbrdnahf]ebmiiwmxkutltuxwrds
lzklscqfbovjmjbo[rhwheqhkaseohohelh]msyobgeiybsbyucus
olbjozztfeowxftbsx[oefyqpxsebyfawerwwb]uyfpnsvujqenwouagc
hwhbihujnzgayah[euifzicfxexpxir]lpgjmexgfyseevwjpqo[nniwslmnmrgybuelwb]khkudtujoigkyyjipu
okiwsdqqwbijptpjzl[ktibxjcdrjvsgxzlgg]cimquzswgbhabcf[gictypilnrboctfwls]oiofteanmgnauid
hdwokqbmfofrujxvf[gcrxxfsxmycedcfr]xwcmtasmlcvfmezvtk
gcxgyjgbqhtcqznfuoh[yitqnwqdcpkgwzayq]oqbiabducwietmxira[kuxdaeohprtnmpfniab]wddlljbeofkomijydzt
gnxobceomvkecom[oedsyavphnrvulwlqfk]klkcrpigniietqecrc
bgzhntrrxvjvhyqhf[tnyvbggtjvjfgratfo]hltqszvzgcutrdcvddq
sgzcemtrlzdjijht[wtvzogdoomtmhxcwckm]nmvftmtbucjnczm[hkqmnugntbrrsphbmn]yfvwwzebdqjkryhm[ydcjwepsqqrwnhkpup]tyssdovqgkhvvstvd
buhlborygnuuklh[haftitnpydnilqbqabe]gemzbfstwlhejmjoox[awjrajspxybgdkbl]nrkncxgvjhuwukw
suckcafpmeixlavp[ehmqotytcsxzagjq]vfwmytywcapfwlljl
vblctxriewmbbpxo[xsgdnvmcmfnuejlrtz]iltofzajbcezlpy[wnfixwfqqgseisa]buystfqzokvletbzv[woumxjkmiqqstnt]ciarbpnsahayntnv
cjsgiueunqlisps[zurvijydsqsdtktm]xhlpspwgqlwqfvx
bobcmszgphpejiwlwdm[wwjrxebfctqobojw]hyrcpguihwihhpmr
jlyvxnexbisiiwyjjf[pxpqjtfgwysrewmrv]xcfaninzgmdidqswt[spnysxcfdiwijvfqitl]wigmjtxvsmwlquxew
qqtluuthgrubwpqzr[kgebpbdpqekehnnuyuh]onnyuyxeqstunzueapk
sizavpqzmcfexfocoxn[dwcfbufvxxousaeah]hymczucocssffcj
ldupymvmttlywlxbbs[vsttjksdhwfdxclitx]hfvkvgmtmaxtifvo
tbgqiatbujypfbjha[catabtthtrydcjbt]aujolgbocqymyeqfr[apsuwlktuaukokmldw]qllsjhthoqdlpykgwz
zqtpkzchpnnmyzygsaf[zuokmkcncefsioenp]ynympbineurlgzkdys[nhrjzpmbwhwcsuowx]hzawgwukxrerbljm
navcmnriavzmexm[xdvtpfcjdxlbsyenvtx]byqzubujbhvpwfcme
kookhqsmbrpgpsbctfp[wlbmttbadvipoyrojd]cqmhhdfaunlqkre[gqmltgpxfyljdyo]zvzerdpqmktqmezf[npidrfvvtdeqgzhojn]hzehtqonmwoahdakvve
tanngpmswmpddgfpph[egmymqydmigpnpr]bymycsueiolsfyfey
uddmrzbeefaxbulsm[ieevtshivgygbvsiwpd]lbxhzadyduakugey[sqywcrjzoxbbgadoqne]xngapfdfzbwcrkd[gurtymibbzvsbxtpypw]elpexxrljomuxnybuxk
diqvdzizaoprrpzrovy[cbayiwiifklhjkw]somecbyhptpmhjvkrba[gczcezgzlsyowteraem]xkjkakyvwxbgmybzj[htxdiogfsahudae]hhbdrescqujtyeyo
kzrqpxxtetqkqqfxild[tenlubsvlvxwjgokm]zxfixurqybohvhfa
pjhbxnktknirbwjp[arlmosnekoqwtpysn]hexsbuespjgsrzbvpf[vaacxsepjnqxegwqq]owuxuohhzxqnoqepvha
pumaevegtbjlzsijtf[cjpsnszjnvoexufcgxy]dxngvevsnjzsbuask
azhhrcrptkuqsvxa[hwxldisbvxutspea]tiqwqugkmslokmixx[wzqlcgyfzacbyoguk]klpprvhtplelelsmx
dumehssexnwcppac[gucpccbmtrdgoee]zpcpjjuztjtgxxhzroz[iizviarbucshvccj]xlypepsxxhxphttgc
deujoayipwnugheu[nnyjneomcvpfrvfu]sfspbwylbnzbyqh[innsmlncnbxrbfuhu]tldwbficslnxpkzlrtw[kyfmnucfyrwlvbb]wedvxsifdxaysaw
lcvkjzckpkeyzyjgtwy[osncmhyofupofwscd]rysnhkmiqoqulyu[lqwjsxrgpkpkgxnvhf]ftmywmwfpckoadd
pixbxvhtlxjxzpm[nvmqocftgaxxgejke]npibmenishbqrxtavc[jzceumsoxcyqbfv]qcdqqbwcueyyqptc[egixgueerjonkmigr]teecwbxvwhgavdfjxi
vhtgslxovrpmlojcyiu[pngyxboltgfaskge]eawigmpxrezdxtau[osjcsdhppmqtqxixkg]gkxhhsphrnkjyxgmp[khnpkxghpkaxnvgxqe]zpedrsevlishcdbd
ixnbejxsfmcjmqh[pagzggnbjxxwktstf]hcjdsogfetpzoucuxg[gsnpjjdmrqzojcozi]csxsgebagjjgxqjx
mekdjtrwhgafduvnmwn[aaphpbnxrwwkhzxn]jqzcqvefysuegreqcw
wbpogjbyzelmxqeaazu[djdqdlmpfmezzehvjl]qdquppvgjweftqvph[equcifktaceuqwoakk]uxemheczqpboerwq
objhlxsujoqunmhip[bxpjvcdqedgvqrv]rvycwulyrrllbrxlbty
ckxcgnosnlskecyq[lcbisjdelotgldlea]edcebpmpxvvgktuxq[pewmfvnkiiulfehy]electgrfvkbxiic[emqhtmrsqfbebmykzv]jfdpefifxcptpfzvovc
leyueicungygchlce[fbclcyopnajqvxey]jcwvhehawbpflgddtn[xlozeiujqbiinjlvrt]ljmnnzlebbjbccao
mblrhofhihdiotvy[nfatavuoewnlsvc]gtuqdhyxielngaci
eyzlvgyolwwobcg[vaeslqvdrjthzho]zdakaychskakuufan
ukqgdhxdohzgrdfc[vfxeqopkydlzdehao]cormknsmtbidhgml[ceialgwruscjsapfc]erjsjeuxzxjokxct
szronkojjdgnfzkpqzq[xpzmblnarrtycgglkw]cixtddybdschdshenjl[gflkqtgzlxeesrfvx]erpfhhlwbsdasjljnqh
crndgetyvbvxhujqtu[svhcpjoxbaacvpqf]ohhkqbbwhtbcatwopz[nzfqzdbjhixrtpw]dpyfzrpxayfoglzji[aynmktzgxtegbucrw]igvfejgptghxddj
efswwtohurobgbpvlhr[sbgfgmsrjsrjblwr]xkswzbsgmboecxc[odmohossczkqjwtrdi]gvdjrovgilpgrdgt
qihgnzozzcedhgivz[wfzerbwlgrjbwolsz]ehnxlqolcgghtdfkeus[isyrflbjdelvbgz]eblyrmmkbobefzo[baowrnzmyctfmoylu]bzhtmcwxpcqhubyws
tjgkgtykbfdogfa[tixjoqenpxjbetz]oybvzsgugsucpvid[qukesagikwrrpuesq]xodwkyngdrxadgqz[sigwgfluzksbqqpvueq]rlgcptipyfrgihzn
tbilszajwwosrhs[rewcahkzssatddmv]wtusvesduewjvissr[efusbpnhwnrdjwgjthd]dunuqtpzocqwyqbysak
spvqcisucqxihmincf[csjfurernawvtia]vzarehconlkvnhbpsaa[mttsrsqoluowbizxrbk]pewqfgipuxqzsfj[qznswrhnuvmmqtbq]mbjqscwfpmkejjowy
eqeycwhpzzryclb[mvthqzizihyfvtdgon]maeannxtfakrfmg[xlxbqdqlglfspvyqrx]chjokbtqngjjsidqdyf[nnmqygvepumttyp]zipyquwulqtblevg
etutgnamoiukjadrf[phwftwicxcpgdegzkr]lafqcmydwbvsxlegc
kbwfmffiylhmwisrb[wvoulhoyvagzmgxmp]heupruovkypjtzkilqm
hjgmjhzizaeqewp[fepsjuqdjujbjpnooe]rnovsbmzwqtukgy
rlxvqkugtcovejm[vqlkivalxqfohnwz]afmwxjnymstqmem[ynyidmrgyujdkmjq]cliodisdvotckoatva[ysfxjtwokboitvhi]xfxomfghbnfnkobval
oxsmqxhljzdjqtx[eavkvuusdpcbrlwmr]kkpbxnnmuqigfvbrf[qrfzadqfcladouu]irmuceccvwsazcydh[kvkeafmibmbgpjoc]kgmkohjtzjqnfwxkv
hvvzujphepxjyypzp[isabpxdneywzpzr]rjbcrfhnidqlywbgvxf
ezfeilvlhanyhfvd[wgbqirhrycdzzbu]wpwvyghpwpfykgdt[drvcvbpndcvrcirig]qzcdvhfcxqdxubat
hjkktoruvvqmuauitf[dmygsosigufbzkm]rjbwsccifhzyhqk
zazrvwupbrzlepfcc[nzlsrlgeovdbndxwqv]yhjwjlnravqgraen
fqjubgphparanlll[avwevtaigfdxgjet]mgftlttzuhaqlvwqn[cnxupkaxahrlnjelty]yqgaieunjkxlhrha[xexqcuvkacjayozydc]blhjzcfcoyiozuajqxw
nacvyqozsyqgnvkvw[urqhhtybjqfpqqcrex]pxfufqzfghzxinnnlq[vbxhmpntjgivfgzgmq]vgsmxbkpphhjvzqdirx[mrnmmtbamdhoved]zziaxsjdqjfvqzq
hdrdsknkwrtejdgeqg[wbvycsdyecvuclhi]owhsjsujsqjachyh
jwfxtraepnpxwmziud[qhwoewcswwusdqcvfh]czaiemhwpbkflzqi[yntelahhkwcytedvpe]kpkuxgqygwicxoh[vuifmbkhbycxqiv]cfyzggvhpveafhduk
ngiytctkauehibctccr[coszigxgcttxzoqrhvn]hfrpsylypetiwrggzg[xwnfgwaxrjabzmsqquj]gxdqtprloqdojdthh
rhhicddiuxdobco[ihkmummwydkeoqp]seubufqphohblrkn
sgslfpeleveakroo[kgpoljsrrcfwlwyzb]zeacrfqqaortgdv[yoipuknesgpwoscvguw]ubrzxeqpijxuflgsgpt[allsdtgmdlnupofjb]brnjhlzxmijpicty
vbcaptabloujxkqwnsc[iujlwsczjefkoewao]yqwmtuetinhedenovhm
fcswktnxobrvovrjg[qsaxxwxgrenkdcpfvx]bmivhngglvcwxwgjz
nhmxhadaretplflb[eaaitxsycuqarue]zzdsqhjjnebzptm[znupjbepvjzujwj]djueiauiobywmclemio
lzgmurmbxidxqofgvy[nhpkiprmeusixtqhfid]zlpmcgmvjfsqhddfzu
aziympesgvakqhltci[qdofqedxvlvpyqat]txvwrspujxyuqsn
ezewtaywtinlcbrn[idtmhvforhdxgcdy]ohpcvnchsamehoewc
ayzzozmdklbhitpd[xwlznwdbvtciozoykoy]ainwvvxkreuvsgdatbm
kvacickhqbjjwkk[fryxetyntagtppzorb]gkqgbqhjykyewipbcj[zdaanxpihogooeeqby]lxdkkpostipynvh
nzngguddxyeihkkyt[wamdyvzgrnofprps]znzgitnmvvvrrzsb
vnbogcvphumewlx[cboxtlpwdmfbtfegkai]zlxznqxwahbghxz
stwxjgiqglghaaot[gdxpnepcgstafgt]psljddrwgewawdc[snbjvfbagexsbpyh]wqqhsxerdjilgln[jyqcqbxxikzmrguo]sophymnkilydvivcdk
kihnifnjfzhvlinqrqi[bcgxtjpdyxtgejzrdi]avzbrcqlbmaadrrvazb[ntmnrjhiklfwujlg]pifpvzbirqokamrmd[rbanfbdlrtmtkxca]udilckezqvrehkz
liradbqjmqeaifibll[yrfnryjrscfrxgazpzc]vxmlibidbmcwgoygn[ojkunzztsdudqhma]dvmtamzfaanvyivxqrq[yqypfcmwnezorcnbzy]wytsaklpzfftqat
fhaxbfjherqxbzbrtg[nabthakgwjarjsfhj]iokwyfrrjtwulhwi
asundudwctdvninxpag[opdvadcnjnbxptahj]scynlgwnmzdtmudu[bupcfcyqmmcwsqfffb]rjargbcgxvonfgjco
zwzcwjnudozdektxh[wesqhjkthgohlufhrf]mwqrvudkqiysxokugz[lcjiemidwqbdnohpd]psvhnbkuptpjicdmb[vfoerfpkymcjmhzicwm]pwykcpzewskfmho
zbhxhhqfeurqurm[buuctguwokorlkfq]extdceaqdkokhdaxzqj
qcrnmtdrftlnyciul[qvtjesglscjradq]tcoobnfosubnnrps[qafsnrpijrnjkemz]urgzkcxptagwndzug[olhgasghsicjvswx]higdtidzwjfzlfkmxbf
ymvlttwormrtliwoy[wrcafamahrcipugxxgy]mjzzpdkuowbrbqtmr
swwktdvpgkbbntq[jujwbyzbmzktmpag]uinhisqwpyszittfqe
qrlfgtcrpyanzwfeuhl[sstllbrafqeobsocmsc]gmfmnisxdoqqctof
znfoqfwiwmxdiixycul[tsxegdjmxscgpfllqvi]fhwwrpconfwceqv[gqpboszvyuduzehsun]hmydskzdmmifotkn[jurqmnkixknhmwj]vcjomeocgzfhftqq
wukfxspnkhedqdbtfti[cjcrwokxqxfqbvfatie]eaohmttcidinhxqtcu
usgxfhglhuknqauzic[jlhntqhcyjuoywthv]hbskrwccmtzgyby[pijipgraqquvxhso]hehkqohxirecivlxnvo[lawgvpbmozisammvpcx]vuchsyinsehynzm
dgnciyptfimtrbmfbcd[tedeoxadobgoobffh]iucidwknmfofwia[bbtbzcwjwiphlcruw]ukwczycabezutqdcc
huxitbsdoqaffnlyxyn[vzcnvdddtezaeymzrr]bmovgbcqswsdmjacezx[jjdtfpukrwhiafcy]fwlhrymiaolokojdkx[ftqdrarkfhfbelc]yfonqpoegjmmxkwhz
ldedcblvfbdacsy[rksxibwzdatluua]agxedenvctglzyvpu[qkwulxegyokwljso]akjfktolnkzwsnn[lfhdwjomyhroqkkzk]mtkhpnffxrrwipsrqet
ajwscynjeiagnubeew[ftyzkgsmsevmdkpyv]ufeszcwnhqpwsep[rinrtwoninoxbqvlgy]mzacylokxrhxtbyut
rdlragvdebqlteu[kitphkhhnrssleu]chisqrsnofxmmbegi
sjzglwvefnntfgofuax[htbkuezcjsfgohzynlp]wquzxtqerwxlperau[kqnbhymijqtvtzxbra]tcwbvbockcilgvn
bdqyqodloytjtcylu[xgwgnadrhxshcyhd]qshqmfdqpzbruygmmzc
pnwkymgknqqdwzmymmh[vcnetknxxjvihfrlvq]cujdvtwltkpkzwkc[owjyboqcsymigajgish]bdklpwzslsjvadacm[mmimdikciuetfjeece]dxwoxjenzguercr
vxgoxslogbrjaxbjg[qyyckvarfyidktepi]odfkcgodqdusnjs
nmumnqunfnuhvtucy[voatnmasscuvwjth]grckxjhdzzoqtpgwm[qwmgudaltzavyrchqy]bmxedeqkwkgoqyrmlx[uqzdpkjekjgfvlnfwh]tpsfewpellmljsakhea
dvvwqujegsgarow[rkjpzfvtrtlpcdlc]kvpqbvyshmoemkhvq[hzbtnbzhmgaufkfvwh]ipdgirduhpdkhcwzfid[jmxetzvqbkrhkices]yzrxhfcakriippr
xyijrstjowvehnp[ylbnnbclmipxjtxtbb]dtynyczfzgqozpa[rmontkapaesmlvuasig]qmuqzwqsoipzutdwz
bdwyvvnsxojfzifhkr[mfdopzhxfakffhoudpz]vqnrhwzqbahbztlynpi
hymeoolncfmkblqrd[ifbyrijjwxsjvmhql]vgybqqlmoilegcrcp
arqsuxhcivbxfiuf[jfqqzwkamooqvyj]awbpyjrtunzulggzmh[iipnlkhwzzmzcdi]ktvdnpdmzmkrqavxsxy[dnoqbxknjvouymfz]brcemvbpovqjdvps
sxhcuagminkkyodlma[zkcpbofatowxfdddhv]iydjxsbzyvvptmrivf[thuzxghsyyrkqbjozw]zicredtdvmavltqgeg
qgvauvsmewyfypvgx[bkzpxdkwztxbpak]ghwmldmcmotjcmun
ivnbdeggumwedodrru[ejwxagdnszmvpyxtsfv]eaabhawecgtctegy
nylnblglukusyetuly[annmbyywmkzxoxcubb]fwslxffcquyfzezst[exsgjgeufpzlscazuw]rebffdvzignmrpriw[qwsiovjdtaimkun]utobenmeyrtxlorxjx
eivxnczlgqbmybivjx[zrbbxnnjprbaknh]gtfbkkxqoowynpt
botxfdjpvcayvpxmf[jysydtitavnzahbeg]zwkgkehpvxtocktco[iodpobnripiqifmexh]zpnrcxntqwwwucz[nwrxbbqtsqmkaiysi]pecfziyavdcfehr
bmfbcrmibywamwmic[npcluivjtbtwmwxmx]mxyepxnjdabcuiexhwi
kezzmzrmfsmhwxfhy[euevwjfsullybtlul]edrcskoqqmtwbhhafnl
yywsnxvznbcockrn[fnmwrszfamgerfhocoa]uxfgnvtphthtmeuyy[houdomoboxleqhrf]zznqyqwslypolnqef[ttbcfuirmlnwevhzw]dmohemntzpwivaab
xfrmjbgozdwamlqe[rdrfdfobgryckvow]gzbnazpqaqxcjdro
vdxepylmqqekuqe[hagzuweczkaioxyz]sndgjumcegndnuwwukz[ymkpvinydrrvfare]oplwhupwenqwloy
paikbyhegnbvcqa[kawvebmxrhzszrncq]noltxgnszsqxfbxbrk
hwifnlppmjawmyb[gulsfllyemlqkcws]wfopsunpcakhzkz[fcpmxchdgicqido]tlvnxgdsecuxsux
yogujlygnpdyhkxpdf[bawcwagtpbuwaorpa]noyoqlkcbsytnzywva[zvdbrjsxhozvyrugdnr]yyehxcwcnepivtjntex
ukkuxsacdvwqkgwu[qfhnxatswcchleqaeg]qynrnkuwuynramm
srvnvdghsmgtyvvli[gujzqjtjtrdfeandy]rypduscceqqfodndh[bssbtbzcdoiygtdse]klhkfnjidkombeom
hrxpcidpccertdnde[iubpwxhlmbnofumjnk]tzjinnaqvzhuqmjgzqs[tbpdksrgbhbhscpnns]kgaslrsilgklgukanif
xhrwvvblyiyyjithaqj[nxzhuqjrftquwsq]juvsrstyudnsyjxqpko
qjjtuuqdjaovcgs[klwmohvmeyujgvauez]faqyixqvshgpkrgvac[hzjbtsvreecwygo]vluysvnbqjuroaondag[qqaysmxakrfjdrpvj]lteebmjrrlysmwocpg
fkemhtixlciygti[babpytzqdpoovfy]ptjooannebsdcfrs[ismooacbkqjciwrfw]wsawvmoxxzwzloxunq[wrjhadcbmeslujxk]zckevlidqnpsdordy
ikapdixlczlrtpab[xyfywwygclrvxmc]tugwitpyopgfhucrrp[zjnmpndgvwlqnsfnemv]xeahjahtuyjwjwxfdv
wjbljlhlkfhhkhrz[kfhvlihkiqprhjno]mhceaicjbnvajugy[rvkrsptmdupaylqsbv]nptyjetdstrwmqjav
nqcmyiscwhuiafdyg[njnrwedfdsnzkyg]rsxrirfayriqxvyqthn[alkdpteuyfothxvyeow]smfyaybytdibkus
msvwpibrptekclckgdd[gdowictxfvmjmdtyimm]nlrlpatlusnrqcydh[zqiivotvmzapjjdzhx]eqxxguxozcbzlfkktk[amsfzydattcuqolcoaw]exjpttscqgketzhe
uqiaugsvrqenozqcnry[hcmsmwdqjcoohwlu]morsyizcifxpoyzes[tdnfcmzkcxkltvom]jbkvbwcolkcpkxdlhy[joounotcqahwjvx]teeotmpwnuvnrgdxscb
xsejzfhwsziaedxovv[accbrvbghrsomiv]glmkioydimjfcneh[xejzphhekszjpec]qfetmjhsfagbzjurrr
qwmyiuonuwttopaz[esdvdnqxftkihzblcc]xxfxmkdxigfxfwadl
gnvhardsrapmlpmlg[gmliinpyvjenkrnnh]kovjprgbyfdknmnbfme[nhzmroniytmwwfp]falokmiuiibxhheszok
zcczeqrlhunbfsxu[ifzbbveczjlfwppp]pvtsdxzdoxrrlukmqmh
rbgkskquxcvswaf[xihgvfvaxkptizohvn]tbntgfbhclvkdael[zuxdeparbafjpwqvg]cpfuexhjmkrdurlbnis[vfmoasavisksmltggm]hsnrpmdkogfxnprmvxu
abttallvhutezhtr[beucmccowruviwqjxlo]slskvryjaodaowc[vqtmaqykahuvoqc]valnulizvgiciruetx[rbhcdafdupnswhn]bppfeuexkximknecfq
hlnjhkjucpmxmguhb[gtoyutdhjwfudqnra]pipjkprnypqtglf[phovsbawbyxsuwsyopo]phkewndekgucmrrbw
bikqggafubkrtyskep[eugvetcxkbfuajpuz]drgqdldmenwxyldlwd[klwzyogvokknfwdqw]ffojmxeeurqxasxgf[qdjndihaiuwjqie]uaatdignzrdeyjddxzg
ddjhxhnkcrmnaztvps[crzhufiibsjerulkslh]snirbjgmmerlrucjlv
ckxphmsmljtplee[mbrperwqumwnitb]aikxmbbxmgsmsfgeni
zwmouppnlfbatcigqkh[kahnxdhbhongbfgmtxy]kfictxvtzrwlzvxees
gfrgqbgweickiocqas[urgmzzgkrwpkfhpf]aazsfnctfvvdrrf
sgndtkclbxdovlte[ylbolooanippjrmyi]lfydwbjkfsgdrecxzn
gfypysbhqsgyoxrtxxp[vdfjphnhrphzphdia]ekhgpckheqjkjinexuu
tagvhpldzimodoca[odnlmmdinuwyazwif]hsresddnysmuldvv[zpnjyvabzrktghfvtfx]jbzsfhvzaglqkstj[leniqywipplvkues]zumzesiphmejqufbn
qhkrsmlwyoxfawk[egspgdlxbrdcwvoeje]pxuytqzjiabwebbmu
wsxvnbuosiwcutjct[nzthycbqcazrnqppb]keasqheprjcqwac
jyiifehztqkdshfuj[cddnloevonuheydyle]tftddpechuzfagnww
zyicuknwqxtzzzy[mqgzslkciigsugirbcu]vadteaxyvnpyhwbec[waifsdqtrcbdnvrl]dygogwgquwnouhc
jltdbxzvwoxlherhs[vuuwuslxdkthbcs]ujzniwntplzaaldguqb[zdcnhufvintzrxm]cunexbzfbuzomrv
huikyoqqhcabtgosej[tqbxkfxeqyclgcqqsu]thtunfddczjfocqmr[vddedigjifexfqgp]otvsknxemvtrpbxw
sgukpjkupqmgtmj[qmvzpbebkypfmje]howlgwptfegdnqp
wnomkfqdtyobjkmd[goockdzswfoumhiavf]noshgjhgufjxgxiro
ivzlyzlnqpslrbldxqw[qmlmhingxmcporfx]bccugkqyzoqaqbv[msgojkckxyuihysrhp]hdmzempetgwwycoy
xzyacqjyialgkmmcj[aqenwwtnrupdsmitna]bhbicwoaervlixo[cggrwmpqsyxfoidjm]yawyxhdkscodboohvvo
aoywrlzjkqkzcmmicvi[lhwojrkhqdearhac]zwhrxrrrmfpkjvrnd[zwdpqkomjgjvkcndhi]cxpctyvgnthrsarfhx[clnierazieohvgsy]eydbsvaautujuqqsr
zfozpdjsfxmbwyb[ignvlhfnrdhybkwhxq]qfxolqnfiyokzcbdy[ohvvpuipajnqwml]rybjvumgzqgzfveqjvy
gkvxesvhovzoekxbmgh[hjnizppxqxtlkdj]mqvvrcdepnalllarg[urffyistzzqlhimfhi]yhndztrezwcapskbkz
qbuqvobipnbazji[qypkenwigkvsjhfdhd]pafhisczyaozydialh
dkocroswvahrephwueh[qtiawejyhzlhsnlaxz]yyelniorfgcpgfxtle
uyuylzyqivmpinpi[nxooflqcmtftzosn]vwxiscnnmmujalwegzl
ewyjffqwxipurwkejav[yxcfacgyuuqpjqxgn]bsxufukndbljizkbo
lglancnskvgdozzuuy[eossyfcrfjnpqtim]mvjbtylaisjdcgyn
lxrbvlmepaibubsqlc[pnndwclekhualwxbpg]cxaynaselbcbisw[evtpqzovucquqbgg]lsscjpanobjuqlpkhtu
wqcqpnmdhfupmmaa[qawfetitfsotgsibhg]vanugoxziwlnbda[apowiuucwbqxkcxry]kithnvgmjbuevopx[okzohlobuxbbjxeul]wrcnqenrhpvmxzp
qwmlncrpjifxmtyxjil[evgtbhnhavfwyih]ganxbqprffolbtg[pxidrhwgdqsycynecqe]sukgwvxkhbzolomvx
vmgykxaeppaasupwolg[pqkilujgqcoxpzys]vtmypzwtqecvidu[nolweceicrhwtvov]uevlxruhysbiedfibc[ytdalspbuzpagzjr]yrkwrgdaptnoxcqqr
fgwnpezirnabdiwcknh[qnwczufxpwtomgr]umwdzmivstlmecryoh[ogyfrrqklslzcqoo]yohswnizpisqpvpyu[bmwnspsfofxvrvqkc]itdkhtuqsybuiom
ynbnpjgaoammxaoagp[xkivkmwwiejjbbgk]ongbnbtqtcxqipe
gxuxnshdgyttcjzvk[lsxpwpvsoquxuazidye]mfihmxgxumzfhnm
ngwlkbdsfkoopeugbf[zkcrhoyehnzszjl]jwkxolilixmiake[kcoazkmvlmmlxhlip]urmeqvldopqdrvrdd
hnlkmhqgkitizzp[dgtnogdyumxjgnh]gazsmgjzighgwpided[vaxfshfsqkmebtkceye]ndxcvfbzddvksncrr[clhmftvehwzwljbp]tooichznleiqlksnv
jgnvwreomaddorfbnna[oedwzjkpxolayry]wdkdtjlmdviveeog[tkbjzabxaqxvbnasst]lqttnyqfnirsajb
yiuwebgrrtctqhvq[dmddhqpukxspoiaua]egktbjgjcfzhltkjtyu
sbfvjniiethddwbjx[guajrdwgcphepysv]qntvmggllbcquzfu[qtlrmikwlmlzfpqufgk]tjwivdcycoacfcwwfyl
mxbvlmxjhiorcnni[ubvkvylqtxbchszgp]kzxkzbjtogzujapfq
aezkzdgfurigqcdxt[kkjkjuyowyhylcxzs]maogxmmqteaectjv[aocufmtewquabwa]wlidntwbxueqzbql
gngwphszdvmcnjj[qvbontopydlzjywvaiq]jbrgkevvbwzvkcpz
qtdsnkqlmcwenkzxodb[wqmskmdllfarzicsce]dmubpplnmipygwqjim[yejatlbffcwmlyrek]gsvwxfaeblczgpdvhhm
ktshrikjzljpacyux[omqqrcsqtbtdqsupfvm]bggungenwwenmztg[kacviemyqpqmwmiivp]petgeydeoygoknl
lvvozapyfvdohboxrt[sqedcfculzdrbsafvg]ioohxzwwppkserbkim[bytwtckhnlhtxgmes]uzwrmuczkofyfgv
ocskfzkwwmnkize[wnjrhvmcynlydnbvn]qbykllzinrgwfvod
eqnrivojtcjljsfcj[rlxxybjowtdptsg]rnnvkyrsxzytscf[mbykscjmwlryaiictd]gmfcxwtjljrpihljll[gxrwqhtelbnpguyvw]lpbbvcxyokowlqfih
sujejaymvqavyvhwpe[vzobezygmsxvqwnnu]dmuyhdixfuqfbnehqve[gwdapthzmbpwtui]hxhsorcfmtmrdqqrzf[dqrxkbkttpsjkqpbnl]qsmueuwxsrnejednm
vmqbwehpqesssnps[jkyzwrfofkfqkse]glwxlfrqaamjejrievu[jhbggigitejevdzgqsm]sqxbxgyvfpqtxrlbca
mlbhjbelhzgprdshat[zcytqxmfhuyriabyr]yzhvmpjfzkhgxavltdz
ctdohoakygysybf[loxbfdhctlnhggxpoq]bimosyslpbihbwqp[fahhvvdfkiiucdf]bbgugrcsmoasoxyymgz[wjhbkirawxanrqf]palckvdfnlhficazmwm
qoetptacgfcrdrstl[gpcfptpchpeiicbmfd]vsjqqgbwiqlndgmop
dmlzhkeleeqkgqvriu[qxzssbjfthbzhdf]inuernrmyomwyre
pcezyuyfhpyebmvanp[jccebfvhvicqksgwyqy]nssvudrlhkckath
mrpkkivxuuozfbxejfm[bkwbwzhwwkfqqlupltj]ngrlyucvbmdilkke[qlzntmxfkeapmlbumu]ynjqdpmonwypyjpalvh
tkqhdmjsbnhbvkdgo[jufmjoypjidudkbcvy]olrsjedkqdbeijypjp
brnhsqltbrizrohj[dlzumegwwcbonaa]llqtbxfulkgjeqw
vxjgwcccalsesmngkbk[owvdclfjsyhgchpt]zgqonnjsnsqxxvqzmqs[wsmtnxjpvzcdpobat]rkgwlaecswhucndgv
wkjmaneymsjdyjd[uvgaxovnqgsvamsbz]naumvynxlnbgksk[mmjeguwrwppdwmdjlm]puiytitjsyskwomrfqj
fquaiztteofhvsbcba[hvstcffflwbvchn]ntvqaedorhoikidi[cpypurqddikmaynmxzx]qkrvwfsppcglqejkn
cpjplvpmbumvgsduald[sowmjselnjpjwhav]flufpydujtzuzusyrr
jfhplkijkstxymvwgz[kbsytlilpsegzanvlee]ywcxnydvgcxzuibxvu[ayieqmzukhoxmcli]rsyubeqkgvobehe
ocsbswhjtvywugym[twhemgyfgdfegogpj]xamojomgxvyedia[rukhjizwdryazdtdsb]fdiecwglfmtfjqxocw
vywxxiyjfwsjhvjmk[mwjsyhoifeimjqtmx]ribwktjvuvxakqqznf[izcdtybzxfbyubfbckt]aocntguubagirsgvz
ursnbtivqkjfkcbls[ckjjoszuogsdnficmhy]wwzjkspwdvilshnzg[gzuoexgingreqktak]ywmfxtqooxdgqaa[bmucdllxdktiifoqp]pvxrfcknwxdjivyym
ebtozyepluaazxsuoi[mocwxdgmeyxmoulo]grazonsbnsnczptl[rusiwrrcbqpybtjfxt]ewazwwjculbvwjgc[jmoyjpbznvzlvnzu]ghwsmgrsqjgragu
cmbehdhyvukkufctwpl[toklbggcxvjerfqozbj]wqbacnegquxmszdul[ggzaznwywpswuxmlmg]swowxuqlmlfvxmznm
qbebmodvutfozxt[macysosjlpjhykkb]qdewwbokbiqofejcsj[ddzpouyuxgogajwmuk]iukkhkmjmrrkefycw
adaobhuodvmkfzrbk[ucroxtaavsmpvfd]nvrnzhxozidrgvf
yytzgmmuqrfqegalpow[eyefbjmsyximixd]sgxjxpfncigzmft[zuwduxnhjiidywvsm]qmdvambkreelttqmv[mqhlvabyxnmnjfpkigl]vuxmnunvxclyhkxi
qdgaknszcwxvyhlrfsr[kbbxnitytjopwtruar]ucanrksrycnoqlcvrd
nqwjdcnwfxkdglllft[gbawkxvzhyiprfenf]ysybkzwywpqwerm[cwsthmeytiuialllzxx]plcctxffnigyhdfmndc[kyyvjcfkxfofxfsrw]cwynasabqneione
kqthcqbvfsncuenmqx[rpokleyrpkohzefrw]txvckiapuezhimt[rrfglfzarznwgchlej]vpnrufinbaqrbjtu[hypcxgeuiotonfxvuf]cfpjwonfyqddtogr
aaxuojwascuilsqjt[aqpfsummtaolqpdi]qoqnuhfpinypgxiex[peasbtrzdkneuriyt]dbhohenosanaxkqqxq[fwvbczhithdxtbdpd]bmncqvxnaijxuexu
mgiepbqfrprbaqd[swsyfijoncrtrigly]bzdkfgrsmwamezhp[minqrxxklutrtrfxps]dacjpwxdrbxhumh
shdjdexuhgauroqwtmd[jpvifgjpgzmjlrnuyj]svvjpufybafcjsoppia[albycpxsvxdykattdos]ewhcfugwuovgnepvovv
ldwjwyzaqxwfrelh[rzkhymugnnpmowx]xufycgvikehdxxggp[mykgpsmatnpimovscqe]cpdwiemofukofnauyh[iicxbleijoxlvml]dxzlvafklkbfhqke
cqdtbwoinxghfrwulij[wwuuffpfxzcckuf]zeayaofaskxfueiq
odegrvwiwncavmxd[smgtzidklnmlnltytx]psknhjsrxwqdqlw[kmejoinwatytdkz]dfziwicdcmfwawwf
jzioqoutlwitjdcb[furuyivyebozkvcny]gfhakdfpfouliybsvk[vfrykghujsittpcxjnj]vjekmvdvwkaffrhhr
rclnyybawbizurp[cptbsqptpvcuchcyncy]rlqjeblagqogxwy[mwexxfjhkiyoihog]slgmmhvjhpomcvgabu[xgipgcmbydzmayywci]tptdbfqkemdnuzvuz
junsrcleteqbngabdh[loajbjvuielphzeel]yquxjlecdumepsr[lktbtwjmyeqrurys]ralurzrcthwtkenjtet
zgykbezaearyhzuxhta[pqtjhajbyttwqzfozi]dzodljvnchwsytat[wrdvidyboznzzbgvxc]fnpmjaiocpucgucwh[kiqymnngzdrlcncpw]xkjzheobflinqcxu
kbaghyebhrmquslcfc[ukdaffinqagmwhvhl]ruyaqrvavvfrzwiyit[jdhkzojqtxymxoaval]qfxsbqwjtsudcet
obscoqxaeartfjmeue[dtceaealpasuxsdoo]zhtpbqqfonksrcpu
bphcztpaoqfofau[wlhtxjzhyooevsax]pvktnvejsbjwsizugxj[aijfjqhoxneawmq]dlfbjynbvobrkyur[swgyiujwbafngtiql]nepaaduwebbpsrew
fsjxwoamqjhjvyyr[johjhabbsofojaxccga]tqcnhtvkimixbyiqt
lrasfxkclqtptlt[bmwhuwhzvfmwxxwla]xghbszjpdbdykjmfvhx[cerzilbrtilvfptwid]nkzdvndlbgkwkgzwatw[njpjupthwiwffesnct]cipyoqwmxtiugbyfmk
txfqpycfderhwnqtrp[cvtdbizqhlxikkw]nuxymppbyfdpayjxt[sfsnmgqrjqrlfxh]dgwdxoveamltzalgyw
ntfdficysbefpup[fvdhtaqmjosqoxosu]pwrbdoceiweqrfyrx[ftlwubetphczbxhx]jolpetpuszxjkxuupke[mbcbzrxeoqpibuyjsgg]cpdzzdzkwbucybc
pwwzjoakzydrvkyn[xisfgbgguunevtbg]ntzbwgeohmdvitrtdpj[fzkkujhplarmvzckn]whvdpxzietgdyfhok[hlmsjxrxxrdjfrzncyi]xvvkjroullhawqdj
pgazkqglbbjzrofkpy[mkeiyuwlxlmgmeugcbb]oguzgbkaasscxhict[lckibbhqnkatvzlqcw]ulilgiydzfsdwngr[qcrozfdctltxaatyajh]ojyzengehkhylgh
zdatmhxwkinjiumoy[qwhfmokowsvzgcngeax]uqebryzrbawakjz[ltilidihghatuhi]lljxtazlhxbrnvwsrc[updgoblisisvpdqngzo]tjvlrlfopjdoyoisim
tfguxgdgurymskwxk[ngtycndepeqrcif]gttrbjkhsbrfczdwxo[xulqdcmgztpjgiajnkn]pgwsbrzakmvblfsvlsd
lclevdvivjogclcmn[kpxlegarknivgdvfymk]kygexxjbzqppiywvxtz
zadpyjsswjcfimejbc[htbpkbzsmbkfeqww]ydwbivnpofvmzvw[archeurcpsapgylrf]teidjxdxdailsbb[nmoqxuhzymlxxqykol]zbesrnrszqdpsbchg
ykwptdjfydxfdue[svxdapsdzsvmsifz]omdvdqwkswiktcwkma[tprmxhwqpdycftzlsz]dyfcmpaaokppkzvoa
adfqjdussbzlxfvlg[hxktcqjmyqctyjnl]ouyrbuvumwwygdc
rrryoldbjkwnauaz[uarnttzxeuurzokpa]clkjazjocprwqti[krkcdnwldqexavrpo]fdegufvailefzfi[izadiszyerlbhwd]myayzynvrymyobbfdc
krttvoiaszqvnme[hlywolnuxbxjhzmnt]lwcvxyuuugaqribebi
yrznsouskotcing[jnttzbfwdrpszrcqr]dhxidpojntnwrrsjjc[dlvjkiqqyrrougz]bjhjvlhvrefihomycx[veomjtdhecgcvsshcwo]iboybnggfhdhymyukl
qtvgzpyhogqojzi[vtbmgswqkcpdzhxwzo]jsmnjadclhgsofgrq[lltxvswaeqdbvbyqj]gvrdvrgygzhbetbkjq
oqmbdnnrpqmjasc[hzdfeapdznngjzjchow]fdoxpevjbqngxrhhlhj
ujszwtyancoxbcga[qzpevsjkmozdbeqf]bdzegnfxtazxdna[wyinvjijbvudlvkwvg]mrgzfijgyouxyio[qehebkkwomsmozoojy]sqhbhyonrnjocbjzfl
hinhkyqfttbnnou[luuiucbkkrnwiuqbwb]ujfitmunviqwhkiziy[wqbetolmyaceofd]wbwbxudxttgmtuxjeo
schrxkylmxpwphllds[iijplekwtutqrdkmsrt]hvejiqeylhoxdpkxz[gbhczsfvoidbktsgbqu]rtfwgjnvhjhemkkvbm[lxojvsbvcnlbuofvwg]ruakyrabueflgsnict
fvqtupyapfmstztmbe[zxtzrmjxlmgshjlfywb]tdihozcziyvstvdtvd[ifzqxsyyhgstjwlr]xihkbuvismdtqtfm[xtxunrrzvtuhjlzoji]zotmlgbjircyvzgcxkd
shkjoyjuiufvxbluji[saofjqdwpwodltmra]xldohzmyameybbnw[zwaispolnanumhtz]hpobrxhytzqmkrkf
jgaozdtecqmpueg[bnfjhfyhdndzlkxrcb]esbfjomhfrfvzgm[wqvhdvpvrbsazqzgnw]lkmrymdcupndnoktuv
mehlgjudopvrolla[ghqzncojnxbdtupn]vacvkbpzsztmzhz[tcvqbgfvrehiycr]unpokrfctcwqexbgo[hbigocuneutkffaka]dwwclmxsripmvcluve
rkdurapdxvohktm[idaisubzmlljyfbblho]kkkxhnkaiaxxyivjsna
ujdjbvlqoavnuoeeilr[tpiehldutfyewbqv]crvmofwdjdesxrl
ptyvtwbbmoujjbvsf[avhpwnutnjkysjdubd]ysgpwvxugjswjzhw[fvgohaphbuqpbwzr]sqvpubqxxhmfxvlw
sslbaaxswqcqfln[nmdfjxyyrexvtxv]wavnexwpbgnrbrwyrf[deouszhzjkbxxrhvkn]xtfqfjexnqgdiddxh[tphqtpimimjxxkkndng]ncngkkzdnhmbqohupgr
kcowklgmyivdmreahg[nhhhjuxwoafzwur]jokzmfbbnzsobiahlhi[qgzkumabuuxqhki]ubnjasaqscrxdjy
ccofivnvzaxcise[erfolydklxltrildvth]sjprbxbfldbsozha[lrbdfwialwqinprra]wqresduonlpwaamhj[nmlgvtrcuqvsirfhwi]qjtgpekylrqmxxbm
fugomjlqyofxoij[prndifttmowgenapio]jpvcsgonnqmvqrxwo[yuioijkmnwkyiba]gtosuvsrcszwsotg[zvtndiccjofwagevdcb]qpdjgtopkcimpfyqw
zbzstwtngoozwdgtkme[mrcfdmgpywwvikyrto]ktlmqekphuekemo[wenupyuqahrgisu]wjyyqsuatrkzlohmo[judqmuzbdrqamof]qiovruvlcreoircteb
yyclnzxvjfymqgrzup[koyfzianzwtvdjga]jtfmxjxehvwejfl[xbebzfwcbmjrhka]oqnpqgevsokznwo[briagugdtzfswfbq]dmnccxrswiebtkwao
muxweanabaymbamknkz[abtqprtejlmchtpy]nmrtnrjxewbqynvbe[rtxnzbwcjbtmvob]segkftbvlvczkgubgp
hkihivjdrqvywhwt[xpciwwigazxeddp]vkaysmwlighihfka[lcyiuojfjmmhltubrj]spandymlggnmqiact[xizoxzguscxtsut]cmjecsmmjasgpvx
kasrdhbhmrlwiczlyp[sfvdefhihrtmmgele]voszgwzdjlvkejvrkn[ahwvipvknuyzrzbrmkk]yuhtxgfpaipuupqep[hezjazdypaguhxkwud]bsfgurgwdetewwg
mkxpacxlrpbfqio[axwgpntpusujnovkpxp]afzkmjvcysdkbfeli
mspmqxwmjhzxqmbhbj[zniufuwcidklzfpuoxs]uvlrvuhbhjhudvx
nrgtmsqbjxlnpsc[hpbskrvswufaucjmjv]pkuulesksyygynxyku
kmopgjfjwvvrfgvo[qsigvjyusqjqziiuwxf]ewkbjkiqfgdwhkot[tbrynegplyfllxcqaar]cybelgkyrndjodpf
wjzkfwmrsnyjitglauy[jnncpybddtktmehxz]hluaspiawjwywug[ujwjjttoevainaxqmer]gewchllvjclaahplb[haewxwlxjjnfggtg]uxmnawcpzfwhfiefo
jogfshkvmshdacro[anluswkewepuhbemk]rwfxbxtmtfgxatwj[lwqompcrkgqzkajgrqg]ckjftivpzkflgbifzx[autylalyokqqlxgu]chewqmwkwewmwoby
vhqxmrwadjsfoprv[imclvgvrtvqfbcllpr]kmgvgofdlkarrusoo
kwkqhpdsrkdlhuq[njldfvflplvygnihg]hikxtejykexrghupbqz[tanglgtyodyncabh]ennzrvfvgcnlehci
hmibwhrmzhcxvzgt[vrdwkryugziqxxfv]tcgmqhirboxwvyy[mjgojhlpjolsjtcu]tphrqucjxjpsdsi[ahqidqxdgeucevqinms]edzoyewnqweqkla
deizsskvkzcsohdf[plhmdlimpiduxfdyzv]iaodhxioxasudzv
aepgcwcwlpdqric[xyxiplpunvajsjk]dkragqziaqxgbwr
keocoxwzsscocdxcf[lvdnlggndlqzvxjo]cajmnvjxphmfopy[bxfnemakuysdjvhzv]ymuttirruskkndjlpw
rrfoglacqhfucnjkhsf[ejgwoteprdneomyqphi]gtsffeskyegnxzfkssz
awgoetenjdtwnpw[hflbiyqshareqvcc]qxwgczjnzceffwk[eumisjskpmnqfmox]dtsifzhnbdvlfaqdkwe
jezzkwqvkbbcskih[cxqpssjfttcropqrk]eqkohazzfagyqpjt[qveehpentvwwdazsmdc]enufhtsnszihemkf
zqokauntjcoqolc[kfjplmodgrkaeuuvq]fqicoryxfrkubee[fcncbrofqpyxdnejn]yebngpgxcbjnivisgza[bpwzrwupgpmtbhg]ufxyezblslkscovzaqd
vdrhbvkjchpslgpwwdt[cfslokjhwrpogwmf]qkxlvkrswbbbhudgk[ryazzfichahhigijhc]xbxrwruzjhyjlwxf[xlulxjmhxnhmkflqw]xtkuftnstlwxwiirwko
qwbqncrimtxfjspgyyn[ysolszsumngdzijn]stfhvhqwymtjpauip[lnucccqwwzenxlytrb]aumcvdswfuucagbkel[skoaaxgeqadxehwvjt]jrjzozvfrrjrsvmov
akweexwajqyahlpq[pjxilukjsvzjerrcdcb]qsptnuxrshmerfccxhb
xbnsmtgyhitmtounl[msqlrxysydxdydbtyho]varxjhsmmqlilsprkq
udmbexywtscnesd[azofuoboewwundyif]mykxybobvefathvqkfx
gjedwdykwqbxqpsb[nykqvlfsckqcgfhvbd]xdactphykfhbpjollax
tinuplnorykjcuete[qqwstzqrupgcliapi]durprlvdyucmbkhceq
zrfmusbfbogbrsin[gaayijtuqfbfnxb]cgjsibujnswdmuhfez[rhatyymizrxrqud]wpvajerbhxbtrva
tpjpjlmhvuorwnd[vnwdgopuigazzwytzbe]uaplhgdvedfaiboz[rqkafxfjjzjwbzwung]cqwjlakbfpqvxspia[chyrracxefgkuznb]chigmcxzjqnzsdn
badqhtkxeokdbres[wmdthitngyoujdumxfb]lnafdeqakaggcdttnq[acuhhjaemkakovqq]vfvloofttmvvolbpgb
myaunxirrlgywdtyrlp[nxinrircujeyezto]tdzynxmmbhjybgz[sxbjlwhbkhpplbveqk]oplketzgeeoczpadvhj
wtqjkfmtshufwfiux[njjvqujaetzgcihtxvi]fapfzhffwqovrvfpatr[hwjfoqsbiothjtrbg]sfwifkjkimjnyzaui
milzoncxkgtbsgtxgb[zvskfgfsgefelbjckwy]lrdralfxvtlupde[kvvibrstieyneglniu]pfyopkpteyovtkahwby
sjwqwumquvxpwokonnd[wooozqoxtlhwsfhtcic]tgzecomscwuxgazattf[dmaxzgxonbkehxgymq]xbqkxgbziuumwex[csesnsjiexhypqrxjj]dbscxozezqgzexrwci
yqgpqvteubzxsmjb[bntiezjqbiywrsq]nrgpewzpshvjwdx[qifsblzcgkiqfmele]oypyewwjmytlaujp
bxlsaiblatkrxpcr[xxnilxrehixaglra]apwnnbwgatzwgmr
rqsogjhjijafydmr[krhzamyodyfpbdv]jkjdjxgdszznhiv[ywihxdwlgdadayqm]cjvrvelwbegtiqswzqr[toujknandbegjga]wvdikqjnnxpuxtijios
dqlbbhlsllmcdejnme[fchpcehhwkjwkythfc]shnipixrreczdblufyb
pljkshxmvbpvswl[gbuflmmaywvbjwibfud]mexysgjrvoxovxtvici[svuosbkwxjzhvmztiq]cvfjfnisqtyomho[jvrshoymwbzcpgxtxl]ysdystgkeioszdbora
ooyljflrcdoujmfajfu[qvnbylveipljcmgrvl]cjfvbounfvjfpsxmbnj[mohdhwcdrykexihcgvb]gfzxjkkqdnspzbqb[jkoiqbqtbjxgezxvsgn]juvveztzrtcxhyp
ebfbaesgsxjbwhkmpxp[dzkhyyykwhayaztjt]xkxdjdlfvlzpqbb[tjdqvwygsgoldpffs]uwccbahfnjkhbfzcocf
uayfnudukxaldfgdvh[tshkbhbydlzzndsc]wtjmhgayuizllbngcr[tfglywxclqmgpeatsva]riocgxwsethrhbh[xnerbhkafskywvgxbdl]yzubvjedgzbpqqng
iensavdsekzfncu[frepnzfzbolseio]thbtyqsviqjozgq[mqobufwdnxkzqvqtgj]woxdzihysaypdxamitb[llqsjadcqlogalbice]xwrmwjiednucqqfuy
lgmcluvxcilrgacyc[ozvsjikotkgiepo]ximiftuuulbsghmm[ykwtdziaokecacpd]bvhsjkjycywcuitep
eoefpqghlbkskrhdhv[wkzmafhoocaswuz]iyiulabsaueugqys
noklaptafpgtvzb[hocgskfdbisxdlcdbq]sgwqzdhmwapbbjox[yyjutkzwybpoeea]xtnvxgftzjdwqhgh[nqgarhtwigpfriuq]etonjczcgfhclbf
tyqqeyfkxjcnjih[edtgzfrlpapwoyrnccx]fmsegnaucwnvsyrsj[lptzjaxumqhbwhmljyv]rugwpouagbvimws
enpywofbxruqkma[lesuqdferlsfxqis]tqkchirhakakvbgf[ytrxxjwygqwaauwjsg]ncrkbikcmvtbtrabvqb
nticpuumzthsihk[asrmrtlzizgsvnvcxny]wjntjizixwyedcrh
yjkotqgkximxcbpa[ttuenysknomggwwvvhe]htzkgoilhlqrpmbcvh[zucaclqaevmjqfuy]pfkvmsbcslkjxyydhk[obfcguogfxfimowk]eczitrwtnkfqyvxco
nbrsaktghjdxrhul[kmtgawzkmntyypqmw]jggmopgbovomadux[pkwngsqopjftulu]ymmfdmimjpxufntd[hnovhrnfsloivbbueip]oreyglwcjkylphqtwl
ufynjbkocygleqwskw[yuykssufmvmdkdntk]opbcqjxsioqpkzbtuhh
nkxtoheqxycxqbp[nmjgqytppiuscyylrm]ezhiobiihpmhkqjc[bewnvjufjzxgfwhy]hslvggdrixjquaigzp[dkaylzejrwivzcl]mxzgkigdgfhmczixkrq
fgcsqpmignjsbxxzt[zoatnmdxtjwltkazbep]wiadjhqakemepgfh[csuxhgjcqjsztsrwb]wdekgrxgngaaqcequ[kjlsrjjtidezpuitng]lhibpbcwjndstunhfff
ozgymklbikxnhme[bbbbemtxaxyxnnazaxm]jszcoclvxluigfgdlq[bkkxgjapnrpvovq]tdsakecfolgpiynztiu
tytomipjwhuqwshlvho[ewcfspufoolvxmeyodk]wrrxjaexfktctmwrkvc[fwdrputsdfepfvglfq]fqhmqffdtqahfpyelce[elfiaqrgaqxwpjbxcig]jmlxcfxgjkteodsufs
zdfxveufnuenptljiet[bxzgimeczdpygyen]ptmmjlitdsoncpjlwh
yfyzedhbbtpqiwmri[uqxjtkmjcivoqatycbc]etqdfgffuplikkgrug[ezipcwmudtfakrrif]kumvfsiqqyfrbcbvgf[upsfgrzgndzpzxhmx]aewrwjwdquhsagmgwah
tkhbexdnhdkmlogvk[rvuvfkiqrvxwewnhihc]yytysizvrtytoqznokd[cyxenputwxkuesw]qukaxyqfxbjvgdcy[rfvlqyyapixtzghha]sjazfjtokjizlxiim
ynwzzgtnjmfjhbys[enxaumsepjmyaapa]tctribvarqtdaceq[omcmnkckmzjjdhjiwvj]qlkbuktkubixegud[bbvvgpocsbliknv]nivyswbiijvnvvkuw
dwncikgxhzvktwgwa[nwmhqzwlvntxvjv]dmbsieiwdzgwecq[uvutvspxpxwfafv]vauzasizdqputolg[ncsglnqbwjshyxa]dtgwditcpcuncdcxn
kupmpwwjcwmmrhum[aakppoytxqucqfncv]gpuyruwkndprpqjqwup[lrcoaodsmpmlhnhnyq]zathwgfvwmumcjwaa
ivdparkbqlazewoujo[tzfulakdrwfncibtnza]titrajiplrfpbsar[rnjnbtkpwadofahdfvv]uwobxeoluadvnxyxwl
kkoyqwkjdgcvqaufnj[qucvzomguivuynsg]cbhahcwrhchflfuc[czlxnbidfvtovgdl]jmyougddwlejoyrfsfm[kcuqcjogcjrhvjpxx]khnizsdkqwzdzehlpe
wzeknwbkawxgvgtq[wmypojfjlgomvmk]tfwjzxvhrbxpkuyk
ivalkzrbqzhiqmjo[olluyctvwisrwwt]ndrunxditvvundvd
zezjmfpqesoftjufk[tdueprzpghkckpq]fnwlbwrhqmmayee
jpmhszgjuxnpjdsbtk[cpzosccgpfbvzuretl]nfpjzsqdvzkcszid[csygzwucakziegi]laqibhadzxurnulc[otxsegwpopkabmwbxzd]ymmsoiqsjnlnsvlsq
srgtzegqicrsutbpfsh[wfdoodrpmioayoa]kfqtpkwcfgyvjeyhvsj[yzcyshhziwjudxmm]xnmgrqxumondortjbye[nyajdyykzhnmolyv]zbdkvkbjavamxrafhbl
ifwabdpxckluvreesop[dsyliwtgkelyyam]hqwleigpcnogipr
bpaukztdyuwjkjrqj[dnslgwpwsanuxvtyn]fxkjtpifmtqzrlok[vfcgvkrunowkiilyok]ypgxcltrqbuzwiqom[ikzgjcafxhxmtgril]btdnvecxukjskjkndz
nghqjtbvhviyatzaz[guzxivxizjukrxwaf]vtggynfcmuttsnrvm[eqvzxmtlkaigaur]dmfhpohcbyjikjl[kxaapmbxolonwgbw]uektjdecblphouwitdv
fxefzaiaeclqyvka[srznplyazbvctgfdr]xakjubrnnbfykcep
rwlthwstbsaxphlsrz[ihywtcvcfdeczmy]lpxfewmiwnskbnv[ripgyxpgczfvxkzp]iltpwldaivxkwwcb[yiejtwqmnnnzywks]krnbkndouhoakztwzh
mwaxggiakwqnbihaaj[pxslpnutqpgdfvhvwgp]nhhnvftzfwdfnrqisfi[hgroxibwekbugif]btrhjqipvkpfvcf
xmxlpyuuqssmtmzqyb[ybwrbnrgkansaodfap]cihlwrfxgbaxddtja
fahbkbakvcwwazgioub[ouuvcmqsmykbkhfhj]gntumiippgacbcl
hqkuhmrurcqtkzusgu[drwgthikmebvdcjapw]vdxfpjwqlcvwpgsflb[mmaxekmyvkxfxye]nlusofrecbdvhbruu
tjyqhrxlyrubiuwl[voyszxwudonuwiptjoy]xggibveyrclwxsq[aolwexwhfxpwcuavvwr]bwkkcnpvsiynoeikmlb
cxpvpcjhfbokvuh[sdkkaewwgkvniqymkrl]emeetymmtcbrivitvn[bvyzmgaorsfbsmqoka]vodjpeovgjpofkq
nupojuxxbgjvlafg[uhfrugmmacqdsap]nxuunqzbasceyiz[ircwdmgmysazaya]qwsmsdywyhklvniiq
mxujioozxlybxvyjcmj[afimhsdzsmtxszd]fsckiqksntizegvxgz
htyhhcuqdfhhniloe[iqslmejacjbynzkw]nenyirdlormvppyym
jbphnkbvlextsaqnid[xdebmjhugwvnodt]spdqamgmvsuftfx
mpdupjaxozerpkit[pcivcugsbsqynoz]zrxxjvwswbpuylnxi[tjoxsullllulompfxhy]zobcdnaypuabmzfn[inubfyjlhoysdjath]vufswsypjkekcrb
qsbiexorinxuevkoad[tjzedsasyapfnvwa]qbfrkhbfmaxcgmovnif[evrexsygnumrldt]serpxomgczhbzjix
ukqzagjymparwzqvw[lnkduutsjulfxuqug]lvupmgsyiquqeepmgsv[ekenewopqmddlcqc]rhnwektxgccickla
ezrytvzepmzxbjapim[knaxuvqciriixgji]epksyimofrrkgawirz[tewvfyplzorvkyeog]bwnejljtelcigsqfx
fngkrmmwapuutwtn[pjrinpthoymdxemoe]qoxhlklweoscgcagw[pyrevdqrznakburr]fnsowwitbsxsdsdv[hzbrhpemwokvyhpohjw]jppmuxhrsdsmmprl
wfpphsvqgdaostxg[abwxepvuvujjmdbhees]uxitcdrdkyaqgtyrdr[rqdczpmmmisomtmop]lnqpzuqcyrdgzrcc[cvzwdsaeorgdzzklrx]ekwjqzkeolvlkkqtj
qzhiltifnugunsngzg[fxfhjhvijjnhnxkbl]bbaftchmgjrfuanns
isducdmcjzbiacltx[jvkepdvzknnyqegqte]zbuvzcrrsbjsqkf[dowjjsipssfisalqwmk]uzrmibeeevzeuxtb[ajzixsnzrxwpekzpy]weogtsmtsuxvjyhy
dnxhdwkvawccsfvncy[odsmukbcbpfyjqeau]ugusdxmjuxjosasg[ouwrwzplzttepynf]avhgcbmjesyqkzjgms
pwyizorvifedguhjqrg[zsafqttsqlygzwmqv]hxilzjvsuyfnyck[dnovwvccguuzizrjw]qgbluurgbxnollv
meqzvrprpthaebpd[htamsljskphtldx]riagbpmpasjnjefv[cvpfevyvpivbals]tgxiqxmhvqhhmrr[cgeamacqfrlrhaoz]vficakheeoprpbows
okkhpeexympjqvlamxu[mvjvngmxhkbiaygi]pnwoitpqlyqaiwdpf[ryfcbkcyzbvxuyngw]xxgknvjauivacqxr[tqmanixcxxbolxf]orhkvkwpyrwbymux
ipwcjobowzgrgzmnf[uahjinxxnmyyibzp]badwoisgtafnkgnp
bcbwbvyvqpozfig[twwsbwyhvfaddwo]jogvkczzowocmkwwlla[yedsazzkeklftvohfqz]tghtcjemmehumuyxar
bevtohpxkrlrjjen[jxnohlogvkugugmk]nrxomawkgbwlnqwb[rtjoeivssknwelkhv]dihcnpigtbnwfdlxhm
upuufvskhseazwfttq[kkipejrjmxwmqjsh]xquyqplziwgvkkiyv[iirqohxpmcxsjryb]ajblnptlfnukvae
sijztjuwnyftelgytm[mgirqlkcbaigiyx]wgbeoandnwaudhgvd[drhbrumogcajpxnvqov]vwandmoxgzsokgfs[xwgtfizcmyjrfzgejhv]nhckviycimfezwefw
gfgrgtizxajkaicjcc[mftrzuftzrgrwilsv]uckwgxywnamzjglbnts
znbgncjrhyxaxgd[xyyzkorhakwqubjzk]wrsdvjsrsdorwkgr[krrqukxrdobhkzmr]mdebvnlirbtdbavpj[adbczigmaoreudvgns]yqxeoeccdlpuwyvf
ymjcaobrviuqtvxjqq[jwpvalizcmbpfdjk]wmxpzhqvcavedvmhtn[llsefbpkphhetqhbj]qryznzcexwgvxni
ginmrsljkrcminltayt[iarzxlzixokzfxiazwl]aircthhepljgylm[wlorimkebaxcvcwanlh]bihvjtofcsnvuem
zdegfhthlaitfojyj[bltnoljmwcfdvle]gnadpzusiepwthtv[ieuoyrprfkwonhwjt]wwfphscvjchvrab
kdnddjueyrofzhjdzcs[asdqcpbunitvxrwi]usylnhwfapvczeb[ozrrpkegwtbkftyeusg]pncbcdrovovzozcazn
lkksyjqoayppxtvns[csiuzvhklkfijem]xpsmnkdmivkitka[djmnmzweqxrkfomzqhr]wkzmhoiasanmhez[wojpalkldcaopeg]murhvjrgpwxpbveekq
jawznxjorxwvflmkk[gafmrermlounwjqod]nalazknfqhepgnelal
wlszezwacdeehnlnoj[njlzbwkfnvnbwim]fydgpvvovkuardng[gqxvckevjodockykp]qsbtvwpwaaeatbd
bwwttxctuzuezxfdz[apvuanhzemgcupc]qcfxkvevimwvwpu[zhhorxgplrpuyabae]gzabsprhuhwrtkd[sqhumhfqwdgxthu]fyebhdninkahfyy
hhttjuhgvcgkisaqof[obpleewrfrrsgpumz]umcmeaytqjlqkyrawp[rhkhciyzmxciiysv]kszzqcmcylslhlpqjag
fnevugmjjescvvmbmt[bjzdquqohnusozz]fwlevkwzllmptbcelsh
hzqfveaxrqycvuolynx[ztsmaipixbuhbmv]ebvofyoeponbpip
utmnuyowmxipzhde[yuvqwfsuyhonciiepq]ynjvqvvifywnecwzdk[httqooeiilokkjghwjq]znixikpswkpgxcchuyg
goojhvcnizyiukzgmwb[euyvjdmnjjrkjwpu]puidllwqpsddlrhx
ysglduipsofxegb[kzrbdzimejxkyftyuz]aekosjomszyegyy[vpkwocloupebnjeo]ocdaynpnnytwrgkn
anheyoxddpkmqla[isqzqeuwwitvtqy]jnchwevvrgyznqsomum[kribzkkrxawjnfsmiux]mlerrnvwcydnfckydfm[hwouaafteeabtgflb]acwwvgztxwcanzizha
kaqernqhzefzthuc[tiuifctajhxawtoi]kyqdkeudzkihvfsn
vwwekuavrftztxb[aywyoempmajrdkxpsc]eibnjbszsfsapujqn[rxpcsihuzszefcdzl]gsahdvozzgxjhontxk
ymjyffbcgimsalujegr[dnppglortkqlowskj]wxwtxtdaaopcyvp[xfsnsdrlopdotuqx]sprrvphwennltlddiw
lguyxqxdnirprljpkec[gevtjwbiofgesdwil]phnydixjjjcprpxlpj
mgjnnftohavesepu[slwhvezajhvdukghl]hdhtlheqzqqrsqmfqyz
iapqmjgrjnecxylopbo[pnbvgmbhbcmcnpsf]opurzpqoyxdxfkud
efuoofbuyjoaqjd[achnmlslfvovmgt]xcuyvikslsewgqlx[gjxolnhgqhhglojjqhy]iarxidejlgphqwaei
uxpcurtzqgpgtzkvp[mibqtgwackcedfri]otnnsgolldyzdpbew[tmgiijgjuvjykwahml]xxgjgzmnicxmywdubrb[hwhcgbzhuoankdubft]rxqzywfyuliatahn
uhmufcxuptehmuf[sygthxldinztzudvs]bdxukzqaxeavvrbqmuz[wovugtpgwisttusjlet]tpfbcndafwhdnolv
kwknefvhmzbtjezkh[zcvncbptzekirhqo]qvgnyfkmrnxlgxzjjxl[twxzjkybjlrpurfmufa]lclhwuylibekjjxc
mspxottklkidvlomd[rhiachlbqgpdhfnxyc]ekkxgijnueonlkpfkm[dnwcjiihmpjqtmb]dkknlqniolowydd[dyqofryhvgracxeuivp]pbsgttbtgksqqevytrb
pjvdfpsdlampeztecfq[lpqshzeegwiouas]nwxqaoryigyvbby[iiddsczjoxentwv]weexunkmtaaufurjz[meywmosucyrxzlgxi]huqfmfpxdmcmqfk
abbhujqyoaphnruaih[yidrkxgrxeoarph]fvryghhzqrobkbsck[dnokdwmkbktlfoihxl]ttptfiadsswiwsfbvf
djwqivpbexyvdquh[qmmdydhjbmunyjixviv]nradabzesdavhasjbjs[lsabjblhocebvyhfee]hwbyvnzltgezasg
maxofygcnygnwefsb[gdfccusdbseqsqfwva]cxdmwhnjitaazhjftn[kcratndpffdnbopd]wocybndplnotqgctr[ymceqbtulsezvftsi]eggtzhqojksdjapnv
lzihlroqvmeohnun[wskcytlimfagjyd]tnehibbupupuhepqz[hschjdjtzbvavum]zstmglsltkovvckpmqr
syzoikkgzplleoaz[ccpsffhupzpuhjcw]kaswkcoyhlrayhikme[qnjnztjupvbwyns]ggmkqikeziailzpuv[ugqgbpunztgvsxsp]mntxaumliefzkpnia
dxnkgspqhyejogxstsk[jfgckouqypxttst]axtisjbtaviwafh
baxazxlkzlyzvbdvtlc[yhegkwrrluxcnaahyl]nyegiipdjrnjobyjp[ulhbizabyukfvhmdg]hgmxctzxzewckasi[fuvwuolxkcfdkmtcngk]xvmvoydeiuaeawcz
bkomgyefwkmwwpsayb[rozknmkljogphrqywyo]vlpasefojmrzbpox[epogjnrjrntbcnzha]okfkagkfyagcszueu[gjpfnuvnazbnqylfm]busunenasatqeieestf
dwlbzijjdujfhotvj[swplsznswlgnaud]bgedlfxgjbwxekq
ffjhdorivdezjdb[tqkfrzxthlxadqstmqe]ttmrscyvbrresartqnh[rfztsxgbedcdecgv]qxcsxdqhshsqtjtl
zwosebsoogknldkh[mkcucbphbvnaqyxjope]aibznttouadentsy[xfucuvnlnchuawcapcq]jqherkgzqodpzydtgu
xondkuknycfwyenkceu[ugjlxueqtcyhyhni]bbofydvkhtjgxxnyrc[gpnwoarvjltzyhhe]qebolgjnwnstokco
cygilweroxmbmbmx[hopxissehjarmezawol]exywzaffjuhehvmbm
nbndomwcaauiluzbg[qjxqxhccqsvtkwm]oazwbouchccdhtrbnbv[vetwfilwgnxxxrhxar]mrbcnwlpciwpizkxj
xuabbxdwkutpsogcfea[tgetfqpgstsxrokcemk]cbftstsldgcqbxf[vwjejomptmifhdulc]ejeroshnazbwjjzofbe|]
|
rickerbh/AoC
|
AoC2016/src/AoC201607.hs
|
Haskell
|
mit
| 183,702
|
{-# LANGUAGE DeriveFunctor #-}
module Compiler.PreAST.Type.Statement where
import Compiler.Serializable
import Compiler.PreAST.Type.Symbol
import Compiler.PreAST.Type.Expression
--------------------------------------------------------------------------------
-- Statement
data Statement a = Assignment a (Expression a)
| Return (Expression a)
| Invocation a [Expression a]
| Compound [Statement a]
| Branch (Expression a) (Statement a) (Statement a)
| Loop (Expression a) (Statement a)
deriving Functor
instance (Serializable a, Sym a) => Serializable (Statement a) where
serialize (Assignment v e) = serialize v ++ " := " ++ serialize e
serialize (Return e) = "return " ++ serialize e
serialize (Invocation sym []) = serialize sym ++ "()"
serialize (Invocation sym exprs) = serialize sym ++ "(" ++ exprs' ++ ")"
where exprs' = intercalate' ", " exprs
serialize (Compound stmts) = paragraph $ compound stmts
serialize (Branch e s t) = paragraph $
0 >>>> ["if " ++ serialize e]
++ 1 >>>> ["then " ++ serialize s]
++ 1 >>>> ["else " ++ serialize s]
serialize (Loop e s) = paragraph $
0 >>>> ["while " ++ serialize e ++ " do"]
++ 1 >>>> [s]
|
banacorn/mini-pascal
|
src/Compiler/PreAST/Type/Statement.hs
|
Haskell
|
mit
| 1,334
|
-- | This module provides utilities for rendering the 'Ann' type of the
-- API. 'Ann' gives extra structure to textual information provided by
-- the backend, by adding nested annotations atop the text.
--
-- In the current School of Haskell code, 'Ann' is used for source
-- errors and type info. This allows things like links to docs for
-- identifiers, and better styling for source errors.
--
-- This module also provides utilities for getting highlight spans from
-- code, via Ace. This allows the display of annotated info to highlight
-- the involved expressions / types, and pass these 'ClassSpans' into
-- 'renderAnn'.
module View.Annotation
( -- * Annotations
renderAnn
, annText
-- * Rendering IdInfo links
, renderCodeAnn
-- * Highlighting Code
, getHighlightSpans
, getExpHighlightSpans
, getTypeHighlightSpans
-- ** Utilities
, NoNewlines
, unNoNewlines
, mkNoNewlines
, mayMkNoNewlines
) where
import qualified Data.Text as T
import GHCJS.Foreign
import GHCJS.Marshal
import GHCJS.Types
import Import hiding (ix, to)
import Model (switchTab, navigateDoc)
--------------------------------------------------------------------------------
-- Annotations
-- | This renders an 'Ann' type, given a function for rendering the
-- annotations.
--
-- This rendering function takes the annotation, and is given the
-- 'React' rendering of the nested content. This allows it to add
-- parent DOM nodes / attributes, in order to apply the effect of the
-- annotation.
--
-- It also takes a 'ClassSpans' value, which is used at the leaf
-- level, to slice up the spans of text, adding additional class
-- annotations. This is used to add the results of code highlighting
-- to annotated info.
renderAnn
:: forall a.
ClassSpans
-> Ann a
-> (forall b. a -> React b -> React b)
-> React ()
renderAnn spans0 x0 f = void $ go 0 spans0 x0
where
go :: Int -> ClassSpans -> Ann a -> React (Int, ClassSpans)
go ix spans (Ann ann inner) = f ann $ go ix spans inner
go ix spans (AnnGroup []) = return (ix, spans)
go ix spans (AnnGroup (x:xs)) = do
(ix', spans') <- go ix spans x
go ix' spans' (AnnGroup xs)
go ix spans (AnnLeaf txt) = do
forM_ (sliceSpans ix txt spans) $ \(chunk, mclass) -> span_ $ do
forM_ mclass class_
text chunk
return (end, dropWhile (\(_, end', _) -> end' <= end) spans)
where
end = ix + T.length txt
annText :: Ann a -> Text
annText (Ann _ x) = annText x
annText (AnnGroup xs) = T.concat (map annText xs)
annText (AnnLeaf x) = x
--------------------------------------------------------------------------------
-- Rendering IdInfo links
-- | Renders a 'CodeAnn'. This function is intended to be passed in
-- to 'renderAnn', or used to implement a function which is passed
-- into it.
renderCodeAnn :: CodeAnn -> React a -> React a
renderCodeAnn (CodeIdInfo info) inner = span_ $ do
class_ "docs-link"
title_ (displayIdInfo info)
onClick $ \_ state -> do
navigateDoc state (Just info)
switchTab state DocsTab
inner
--------------------------------------------------------------------------------
-- Highlighting code
type ClassSpans = [(Int, Int, Text)]
-- NOTE: prefixing for expressions doesn't seem to make a difference
-- for the current highlighter, but it might in the future.
-- | Get the highlight spans of an expression.
getExpHighlightSpans :: NoNewlines -> IO ClassSpans
getExpHighlightSpans = getHighlightSpansWithPrefix $ mkNoNewlines "x = "
-- | Get the highlight spans of a type.
getTypeHighlightSpans :: NoNewlines -> IO ClassSpans
getTypeHighlightSpans = getHighlightSpansWithPrefix $ mkNoNewlines "x :: "
getHighlightSpansWithPrefix :: NoNewlines -> NoNewlines -> IO ClassSpans
getHighlightSpansWithPrefix prefix codeLine = do
let offset = T.length (unNoNewlines prefix)
spans <- getHighlightSpans "ace/mode/haskell" (prefix <> codeLine)
return $
dropWhile (\(_, to, _) -> to <= 0) $
map (\(fr, to, x) -> (fr - offset, to - offset, x)) spans
getHighlightSpans :: Text -> NoNewlines -> IO ClassSpans
getHighlightSpans mode (NoNewlines codeLine) =
highlightCodeHTML (toJSString mode) (toJSString codeLine) >>=
indexArray 0 >>=
fromJSRef >>=
maybe (fail "Failed to access highlighted line html") return >>=
divFromInnerHTML >>=
spanContainerToSpans >>=
fromJSRef >>=
maybe (fail "Failed to marshal highlight spans") return
foreign import javascript "function() { var node = document.createElement('div'); node.innerHTML = $1; return node; }()"
divFromInnerHTML :: JSString -> IO (JSRef Element)
foreign import javascript "highlightCodeHTML"
highlightCodeHTML :: JSString -> JSString -> IO (JSArray JSString)
foreign import javascript "spanContainerToSpans"
spanContainerToSpans :: JSRef Element -> IO (JSRef ClassSpans)
--------------------------------------------------------------------------------
-- NoNewlines: utility for code highlighting
-- TODO: should probably use source spans / allow new lines instead
-- of having this newtype...
-- | This newtype enforces the invariant that the stored 'Text' doesn't
-- have the character \"\\n\".
newtype NoNewlines = NoNewlines Text
deriving (Eq, Show, Monoid)
unNoNewlines :: NoNewlines -> Text
unNoNewlines (NoNewlines x) = x
mkNoNewlines :: Text -> NoNewlines
mkNoNewlines = fromMaybe (error "mkNoNewlines failed") . mayMkNoNewlines
mayMkNoNewlines :: Text -> Maybe NoNewlines
mayMkNoNewlines x | "\n" `T.isInfixOf` x = Nothing
mayMkNoNewlines x = Just (NoNewlines x)
|
fpco/schoolofhaskell
|
soh-client/src/View/Annotation.hs
|
Haskell
|
mit
| 5,613
|
{-# htermination elemIndex :: (Eq a, Eq k) => (a, k) -> [(a, k)] -> Maybe Int #-}
import List
|
ComputationWithBoundedResources/ara-inference
|
doc/tpdb_trs/Haskell/full_haskell/List_elemIndex_12.hs
|
Haskell
|
mit
| 94
|
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE RecordWildCards #-}
module Main where
import qualified Data.ByteString.Char8 as B8
import Data.Char (toLower)
import Data.Monoid
import qualified Data.Text as T
import Myracloud
import Myracloud.Types hiding (value)
import Options.Applicative
import Servant.Common.BaseUrl
import System.Exit
data Options = Options
{ optGlobalCredentials :: Credentials
, optGlobalBaseUrl :: BaseUrl
, optCommand :: Command
} deriving (Show, Eq)
data DnsListOptions = DnsListOptions
{ dnsListSite :: Site
, dnsListPage :: Int
} deriving (Show, Eq)
data Command = Create T.Text DnsRecordCreate
| List DnsListOptions
deriving (Show, Eq)
credentialsOption :: Parser Credentials
credentialsOption = (,)
<$> byteStringOption
( long "access-key"
<> metavar "ACCESS"
<> help "API access key")
<*> byteStringOption
( long "secret-key"
<> metavar "SECRET"
<> help "API secret key")
schemeOption :: Parser Scheme
schemeOption = option schemeReadM
( long "scheme"
<> metavar "SCHEME"
<> help "scheme to use, either http or https"
<> value Https
<> showDefaultWith (map toLower . show))
where
schemeReadM :: ReadM Scheme
schemeReadM = str >>= \s -> case toLower <$> s of
"http" -> return Http
"https" -> return Https
_ -> readerError $
"‘" ++ s ++ "’ is not a valid scheme, use http or https instead"
baseUrlOption :: Parser BaseUrl
baseUrlOption = BaseUrl
<$> schemeOption
<*> strOption
( long "host"
<> metavar "HOST"
<> help "API server address"
<> value "api.myracloud.com"
<> showDefaultWith Prelude.id)
<*> option auto
( long "port"
<> metavar "PORT"
<> help "port to use for the server"
<> value 443
<> showDefault)
byteStringOption :: Mod OptionFields String -> Parser B8.ByteString
byteStringOption x = B8.pack <$> strOption x
textOption :: Mod OptionFields String -> Parser T.Text
textOption x = T.pack <$> strOption x
siteOption :: Mod OptionFields String -> Parser Site
siteOption x = Site <$> textOption x
dnsListOptions :: Parser DnsListOptions
dnsListOptions = (<*>) helper $ DnsListOptions
<$> siteOption
( long "domain"
<> metavar "DOMAIN"
<> help "domain to query the records for" )
<*> option auto
( long "page"
<> metavar "PAGE"
<> help "page number of the list of records"
<> value 1
<> showDefault)
dnsCreateOptions :: Parser DnsRecordCreate
dnsCreateOptions = (<*>) helper $ DnsRecordCreate
<$> textOption
( long "subdomain"
<> metavar "SUBDOMAIN"
<> help "name to create a record for, e.g. sub.example.com" )
<*> textOption
( long "value"
<> metavar "VALUE"
<> help "value for the record, e.g. 127.0.0.1")
<*> option auto
( long "ttl"
<> metavar "TTL"
<> help "TTL for the record, e.g. 300")
<*> textOption
( long "type"
<> metavar "TYPE"
<> help "record type, e.g. A")
<*> switch
( long "active"
<> help "whether the record should be made active")
domainOption :: Parser T.Text
domainOption = textOption
( long "domain"
<> metavar "DOMAIN"
<> help "domain name we're querying")
commandOptions :: Parser Command
commandOptions = subparser $
(command "create" (info (Create <$> domainOption <*> dnsCreateOptions)
(progDesc "Create a record for a domain")))
<>
(command "list" (info (List <$> dnsListOptions)
(progDesc "List records for a domain")))
globalOptions :: Parser Options
globalOptions = Options
<$> credentialsOption
<*> baseUrlOption
<*> commandOptions
opts :: ParserInfo Options
opts = info (helper <*> globalOptions)
(fullDesc <> progDesc "Command line interface to MYRACLOUD")
exit :: (Show a, Show b) => Either a b -> IO ()
exit (Left x) = putStrLn ("ERROR: Failed with " <> show x) >> exitFailure
exit (Right x) = print x >> exitSuccess
main :: IO ()
main = execParser opts >>= \case
Options creds baseUrl com -> case com of
Create s r -> runCreate creds r (Site s) baseUrl >>= exit
List (DnsListOptions {..}) ->
runList creds dnsListSite dnsListPage baseUrl >>= exit
|
zalora/myrapi
|
src/Main.hs
|
Haskell
|
mit
| 4,358
|
{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE UndecidableInstances #-}
module Betfair.APING.Types.InstructionReportStatus
( InstructionReportStatus(..)
) where
import Data.Aeson.TH (Options (omitNothingFields),
defaultOptions, deriveJSON)
import Protolude
import Text.PrettyPrint.GenericPretty
data InstructionReportStatus
= SUCCESS
| FAILURE
| TIMEOUT
deriving (Eq, Show, Generic, Pretty)
$(deriveJSON defaultOptions {omitNothingFields = True} ''InstructionReportStatus)
|
joe9/betfair-api
|
src/Betfair/APING/Types/InstructionReportStatus.hs
|
Haskell
|
mit
| 739
|
module Main where
import Base
import Simple
import Infeasible
import Clustering
import Stupid
main :: IO ()
main
= do putStrLn "Simple"
simple
putStrLn "Infeasible"
infeasible
putStrLn "Clustering"
clustering
putStrLn "Stupid"
stupid
|
amosr/limp-cbc
|
examples/Test.hs
|
Haskell
|
mit
| 296
|
module Handler.Github where
import Import
import Blaze.ByteString.Builder (copyByteString, toByteString)
getGithubR :: Handler ()
getGithubR = do
_ <- requireProfile
mdest <- lookupGetParam "dest"
dest <-
case mdest of
Nothing -> fmap ($ ProfileR) getUrlRender
Just dest -> return dest
getGithubDest dest >>= redirect
getGithubDest :: Text -> Handler Text
getGithubDest redirectUrl = do
y <- getYesod
render <- getUrlRender
return $ decodeUtf8 $ toByteString $
copyByteString "https://github.com/login/oauth/authorize" ++
renderQueryBuilder True
[ ("client_id", Just $ githubClientId y)
, ("redirect_uri", Just $ encodeUtf8 $ render (GithubCallbackR redirectUrl))
, ("scope", Just "repo user admin:public_key")
] ++ copyByteString "#github"
deleteGithubR :: Handler ()
deleteGithubR = do
Entity pid _ <- requireProfile
$runDB $ update pid [ProfileGithubAccessKey =. Nothing]
setMessage
[shamlet|
Github access revoked.
For your security, you should revoke the authentication token and SSH keys on the
<a href=https://github.com/settings/applications>GitHub application settings page#
\.
|]
render <- getUrlRender
redirect $ render ProfileR ++ "#github"
|
fpco/schoolofhaskell.com
|
src/Handler/Github.hs
|
Haskell
|
mit
| 1,365
|
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
module SyntheticWeb.Observer
( service
) where
import Control.Applicative ((<|>))
import Control.Monad (forM_)
import Control.Monad.IO.Class (liftIO)
import qualified Data.ByteString.Char8 as BS
import Data.Time (NominalDiffTime)
import Snap.Core ( Snap
, ifTop
, emptyResponse
, putResponse
, setContentType
, setResponseCode
, writeBS )
import Snap.Http.Server ( defaultConfig
, httpServe
, setPort )
import SyntheticWeb.Counter ( ByteCounter (..)
, CounterSet
, FrozenSet (..)
, GlobalCounter (..)
, PatternCounter (..)
, freeze
, toThroughput )
import Text.Printf (printf)
service :: Int -> CounterSet -> IO ()
service port counterSet = do
let config = setPort port defaultConfig
httpServe config $
ifTop (renderStatistics counterSet)
<|> resourceNotFound
renderStatistics :: CounterSet -> Snap ()
renderStatistics counterSet = do
frozenSet@(FrozenSet (_, _, patternCounters)) <- liftIO $ freeze counterSet
let response = setResponseCode 200 $
setContentType "text/html" emptyResponse
putResponse response
writeBS htmlHead
writeBS $ htmlDiv "pink" (globalStats frozenSet)
forM_ (zip patternCounters alterStyles) $ \(patternCounter, style) ->
writeBS $ htmlDiv style (patternStats frozenSet patternCounter)
writeBS htmlFoot
resourceNotFound :: Snap ()
resourceNotFound = do
let response = setResponseCode 404 $
setContentType "text/plain" emptyResponse
putResponse response
writeBS "The requested resource was not found"
htmlDiv :: String -> [BS.ByteString] -> BS.ByteString
htmlDiv style xs =
BS.unlines $ concat
[ [ BS.pack $ printf "<div id=\"%s\">" style
, "<pre style=\"font-family:Courier,monospace;\">" ]
, xs
, [ "</pre>"
, "</div>" ] ]
globalStats :: FrozenSet -> [BS.ByteString]
globalStats (FrozenSet (t, GlobalCounter {..}, _)) =
let (dlTpt, ulTpt) = toThroughput totalByteCount t
in [ "==========================================================="
, BS.pack $ printf " Uptime : %.2fs"
(timeToDouble t)
, BS.pack $ printf " Total pattern time : %.2fs"
(timeToDouble totalPatternTime)
, BS.pack $ printf " Total download : %ld bytes at %s"
(download totalByteCount) (show dlTpt)
, BS.pack $ printf " Total upload : %ld bytes at %s"
(upload totalByteCount) (show ulTpt)
, BS.pack $ printf " Total # activations : %ld" totalActivations
, BS.pack $ printf " Total sleep time : %.2fs (%.2f%% of total)"
(timeToDouble totalSleepTime)
(timeToDouble $
totalSleepTime `percentOf` totalPatternTime)
, BS.pack $ printf " Total latency time : %.2fs (%.2f%% of total)"
(timeToDouble totalLatencyTime)
(timeToDouble $
totalLatencyTime `percentOf` totalPatternTime)
]
patternStats :: FrozenSet -> PatternCounter -> [BS.ByteString]
patternStats (FrozenSet (t, GlobalCounter {..}, _)) PatternCounter {..} =
let (dlTpt, ulTpt) = toThroughput byteCount t
in [ "==========================================================="
, BS.pack $ printf " Name : %s" patternName
, BS.pack $ printf " Pattern time : %.2fs (%.2f%% of total)"
(timeToDouble patternTime)
(timeToDouble $
patternTime `percentOf` totalPatternTime)
, BS.pack $ printf " Pattern download : %ld bytes at %s"
(download byteCount) (show dlTpt)
, BS.pack $ printf " Pattern upload : %ld bytes at %s"
(upload byteCount) (show ulTpt)
, BS.pack $ printf " # activations : %ld (%.2f%% of total)"
activations
((fromIntegral activations `percentOf`
fromIntegral totalActivations) :: Double)
, BS.pack $ printf " Sleep time : %.2fs (%.2f%% of pattern)"
(timeToDouble sleepTime)
(timeToDouble $ sleepTime `percentOf` patternTime)
, BS.pack $ printf " Latency time : %.2fs (%.2f%% of pattern)"
(timeToDouble latencyTime)
(timeToDouble $ latencyTime `percentOf` patternTime)
]
htmlHead :: BS.ByteString
htmlHead = BS.unlines
[ "<!DOCTYPE html>"
, "<html>"
, "<title>Synthetic Web Statistics</title>"
, "<meta http-equiv=\"refresh\" content=\"1\"/>"
, "<style>"
, "#pink{background-color:pink;margin-top:-17px;}"
, "#blue{background-color:lightblue;margin-top:-17px;}"
, "#gray{background-color:lightgray;margin-top:-17px;}"
, "</style>"
, "</head>"
, "<body>"
]
htmlFoot :: BS.ByteString
htmlFoot = BS.unlines
[ "</body>"
, "</html>"
]
percentOf :: (Fractional a, Ord a) => a -> a -> a
percentOf t1 t2
| t2 > 0 = t1 / t2 * 100
| otherwise = 0
timeToDouble :: NominalDiffTime -> Double
timeToDouble = realToFrac
alterStyles :: [String]
alterStyles = concat $ repeat ["gray", "blue"]
|
kosmoskatten/synthetic-web
|
src/SyntheticWeb/Observer.hs
|
Haskell
|
mit
| 5,709
|
module Carbon.DataStructures.Trees.SelfBalancingBinarySearchTree (Tree (..), create, from_list, to_list, remove, removeall, count, find, size, height, add, prettyprint, rotate_cw, rotate_ccw) where
import qualified Carbon.DataStructures.Trees.GenericBinaryTree as GenericBinaryTree
import Data.List (foldl')
import Debug.Trace
data Tree a
= Branch (Tree a) a (Tree a) Int Int
| Leaf
deriving (Show)
instance GenericBinaryTree.GenericBinaryTree Tree where
is_leaf Leaf = True
is_leaf _ = False
left (Branch left _ _ _ _) = left
right (Branch _ _ right _ _) = right
node (Branch _ node _ _ _) = node
details (Branch _ _ _ n h) = "N: " ++ (show n) ++ "; H: " ++ (show h)
from_list :: (Ord a) => [a] -> Tree a
from_list li = foldl' (\ tree val -> (add tree val)) create li
to_list :: Tree a -> [a]
to_list Leaf = []
to_list (Branch left node right n _) = (to_list left) ++ (replicate n node) ++ (to_list right)
create :: Tree a
create = Leaf
add :: (Ord a) => Tree a -> a -> Tree a
add (Branch left node right n _) val
= let (new_left, new_right, new_n)
| val < node = ((add left val), right, n)
| val > node = (left, (add right val), n)
| otherwise = (left, right, (n + 1))
in balance (Branch new_left node new_right new_n ((max (height new_left) (height new_right)) + 1))
add (Leaf) val = Branch Leaf val Leaf 1 0
balance :: Tree a -> Tree a
balance (Branch left node right n h)
= let
factor = balance_factor (Branch left node right n h)
sub_factor
| factor > 0 = balance_factor right
| factor < 0 = balance_factor left
| otherwise = 0
in if (factor /= 2 && factor /= -2)
then (Branch left node right n h)
else
let (new_left, new_right)
| factor * sub_factor > 0 = (left, right)
| factor == 2 = (left, (rotate right sub_factor))
| otherwise = ((rotate left sub_factor), right)
in rotate (Branch new_left node new_right n ((max (height new_left) (height new_right)) + 1)) factor
balance (Leaf) = Leaf
side :: Tree a -> Int -> Tree a
side (Branch left _ right _ _) s = if (s > 0) then right else left
remove :: (Ord a) => Tree a -> a -> Tree a
remove (Branch left node right n h) val
| ((val == node) && (n == 1)) = removeall (Branch left node right n h) val
| otherwise = balance $ Branch new_left node new_right new_n ((max (height new_left) (height new_right)) + 1)
where (new_left, new_right, new_n)
| val < node = ((remove left val), right, n)
| val > node = (left, (remove right val), n)
| otherwise = (left, right, n - 1)
remove (Leaf) _ = Leaf
removeall :: (Ord a) => Tree a -> a -> Tree a
removeall (Branch Leaf node Leaf n h) val
| node == val = Leaf
| otherwise = (Branch Leaf node Leaf n h)
removeall (Branch left node right n h) val
= balance $ Branch new_left new_node new_right new_n ((max (height new_left) (height new_right)) + 1)
where (new_left, new_right, new_node, new_n)
| val < node = ((removeall left val), right, node, n)
| val > node = (left, (removeall right val), node, n)
| otherwise = let
pop_'root (Leaf) _ = trace "POP ROOT LEAF" (Leaf, (node, n))
pop_'root (Branch Leaf node Leaf n _) _ = (Leaf, (node, n))
pop_'root (Branch _ node Leaf n _) 1 = (Leaf, (node, n))
pop_'root (Branch Leaf node _ n _) 0 = (Leaf, (node, n))
pop_'root (Branch left node right n _) side
= let
ret = pop_'root (if side == 0 then left else right) side
(left', right') = if side == 0 then ((fst ret), right) else (left, (fst ret))
in (balance (Branch left' node right' n ((max (height left') (height right')) + 1)), (snd ret))
factor = balance_factor (Branch left node right n h)
ret = if factor < 0 then (pop_'root left 1) else (pop_'root right 0)
root' = snd ret
(left', right') = if factor < 0 then ((fst ret), right) else (left, (fst ret)) -- TODO: optimize branch with earlier call?
in (left', right', (fst root'), (snd root')) --(left, right, 0)
removeall (Leaf) _ = Leaf
count :: (Ord a) => Tree a -> a -> Int
count (Branch left node right n _) val
| val == node = n
| val > node = count right val
| otherwise = count left val
count (Leaf) _ = 0
find :: Tree a -> (a -> Int) -> Int
find (Branch left node right n _) f
| f node == 0 = n
| f node < 0 = find right f
| f node > 0 = find left f
find (Leaf) _ = 0
size :: Tree a -> Int
size (Branch left _ right n _) = (size left) + (size right) + (min n 1)
size (Leaf) = 0
height :: Tree a -> Int
height (Branch _ _ _ _ h) = h
height (Leaf) = -1
prettyprint :: Show a => Tree a -> String
prettyprint (Leaf) = "{}"
prettyprint (Branch left node right n h) = GenericBinaryTree.prettyprint (Branch left node right n h)
balance_factor :: Tree a -> Int
balance_factor (Branch left _ right _ _) = (height right) - (height left)
balance_factor (Leaf) = 0
rotate :: Tree a -> Int -> Tree a
rotate (Branch left node right n h) rotation
| rotation > 0 = rotate_ccw (Branch left node right n h)
| rotation < 0 = rotate_cw (Branch left node right n h)
| otherwise = (Branch left node right n h)
rotate_cw :: Tree a -> Tree a
rotate_cw (Branch (Branch left_left left_node left_right left_n _) node right n _)
= Branch new_left left_node new_right left_n ((max (height new_left) (height new_right)) + 1)
where (new_left, new_right) = (left_left, (Branch left_right node right n ((max (height left_right) (height right)) + 1)))
rotate_ccw :: Tree a -> Tree a
rotate_ccw (Branch left node (Branch right_left right_node right_right right_n _) n _)
= Branch new_left right_node new_right right_n ((max (height new_left) (height new_right)) + 1)
where (new_left, new_right) = ((Branch left node right_left n ((max (height left) (height right_left)) + 1)), right_right)
|
Raekye/Carbon
|
haskell/src/Carbon/DataStructures/Trees/SelfBalancingBinarySearchTree.hs
|
Haskell
|
mit
| 5,693
|
module Main where
import Serve
import Handler.Scim.Portal
main = serve "13573" scimPortalHandler
|
stnma7e/scim_serv
|
portal/Main.hs
|
Haskell
|
mit
| 98
|
--------------------------------------------------------------------------------
-- |
-- Module : System.Socket.Unsafe
-- Copyright : (c) Lars Petersen 2015
-- License : MIT
--
-- Maintainer : info@lars-petersen.net
-- Stability : experimental
--------------------------------------------------------------------------------
module System.Socket.Unsafe (
Socket (..)
-- * Unsafe operations
-- ** unsafeSend
, unsafeSend
-- ** unsafeSendTo
, unsafeSendTo
-- ** unsafeReceive
, unsafeReceive
-- ** unsafeReceiveFrom
, unsafeReceiveFrom
-- ** unsafeGetSocketOption
, unsafeGetSocketOption
-- ** unsafeSetSocketOption
, unsafeSetSocketOption
-- * Waiting for events
-- ** waitRead
, waitRead
-- ** waitWrite
, waitWrite
-- ** waitConnected
, waitConnected
-- ** tryWaitRetryLoop
, tryWaitRetryLoop
) where
import Control.Concurrent.MVar
import Control.Exception ( throwIO )
import Control.Monad
import Foreign.C.Types
import Foreign.Ptr
import Foreign.Marshal
import Foreign.Storable
import System.Posix.Types ( Fd(..) )
import System.Socket.Internal.Socket
import System.Socket.Internal.SocketOption
import System.Socket.Internal.Platform
import System.Socket.Internal.Exception
import System.Socket.Internal.Message
-- | Like `System.Socket.send`, but using `Ptr` and length instead of a `ByteString`.
--
-- This function is /unsafe/. @bufPtr@ must refer to a buffer which size is at least @bufSize@ bytes.
unsafeSend :: Socket a t p -> Ptr b -> CSize -> MessageFlags -> IO CInt
unsafeSend s bufPtr bufSize flags =
tryWaitRetryLoop s waitWrite (\fd-> c_send fd bufPtr bufSize flags )
-- | Like `System.Socket.sendTo`, but using `Ptr` and length instead of a `ByteString`.
--
-- This function is /unsafe/. @bufPtr@ must refer to a buffer which size is at least @bufSize@ bytes.
unsafeSendTo :: Socket f t p -> Ptr b -> CSize -> MessageFlags -> Ptr (SocketAddress f) -> CInt -> IO CInt
unsafeSendTo s bufPtr bufSize flags addrPtr addrSize =
tryWaitRetryLoop s waitWrite (\fd-> c_sendto fd bufPtr (fromIntegral bufSize) flags addrPtr addrSize)
-- | Like `System.Socket.receive`, but using `Ptr` and length instead of a `ByteString`.
--
-- This function is /unsafe/. @bufPtr@ must refer to a buffer which size is at least @bufSize@ bytes.
unsafeReceive :: Socket a t p -> Ptr b -> CSize -> MessageFlags -> IO CInt
unsafeReceive s bufPtr bufSize flags =
tryWaitRetryLoop s waitRead (\fd-> c_recv fd bufPtr bufSize flags)
-- | Like `System.Socket.receiveFrom`, but using `Ptr` and length instead of a `ByteString`.
--
-- This function is /unsafe/. @bufPtr@ must refer to a buffer which size is at least @bufSize@ bytes.
unsafeReceiveFrom :: Socket f t p -> Ptr b -> CSize -> MessageFlags -> Ptr (SocketAddress f) -> Ptr CInt -> IO CInt
unsafeReceiveFrom s bufPtr bufSize flags addrPtr addrSizePtr =
tryWaitRetryLoop s waitRead (\fd-> c_recvfrom fd bufPtr bufSize flags addrPtr addrSizePtr)
tryWaitRetryLoop :: Socket f t p -> (Socket f t p -> Int -> IO ()) -> (Fd -> Ptr CInt -> IO CInt) -> IO CInt
tryWaitRetryLoop s@(Socket mfd) wait action = loop 0
where
loop iteration = do
-- acquire lock on socket
mi <- withMVar mfd $ \fd-> alloca $ \errPtr-> do
when (fd < 0) (throwIO eBadFileDescriptor)
i <- action fd errPtr
if i < 0 then do
err <- SocketException <$> peek errPtr
unless (err == eWouldBlock || err == eAgain || err == eInterrupted)
(throwIO err)
return Nothing
else
-- The following is quite interesting for debugging:
-- when (iteration /= 0) (print iteration)
return (Just i)
-- lock on socket is release here
case mi of
Just i ->
return i
Nothing -> do
wait s iteration -- this call is (eventually) blocking
loop $! iteration + 1 -- tail recursion
|
lpeterse/haskell-socket
|
src/System/Socket/Unsafe.hs
|
Haskell
|
mit
| 3,952
|
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE ScopedTypeVariables #-}
module Solver where
import Control.Monad
import Control.Monad.Loops
import Data.Bifunctor
import Data.List
import Data.List.HT
import Data.Monoid
import Data.Ratio
import qualified Gaussian as G
{-
Notes about this module:
for the purpose of solving small scale puzzles, `solveMatOne` looks good enough,
however this approach does not work in general if we cannot find the multiplicative inverse
of some number (which is usually the case for non-prime modulos).
While Gaussian module implements an approach that solves linear systems in general,
we have trouble converting a solution back to one that works under modulo.
-}
data Err i
= NoMultInv i
| Underdetermined
| Todo String
| Gaussian String
deriving (Show, Eq)
-- expect both input to be positive numbers.
extEuclidean :: Integral i => i -> i -> (i, (i, i))
extEuclidean a0 b0 = aux (a0, 1, 0) (b0, 0, 1)
where
aux (r0, s0, t0) y@(r1, s1, t1) =
if r1 == 0
then (r0, (s0, t0))
else aux y (r, s0 - q * s1, t0 - q * t1)
where
(q, r) = r0 `quotRem` r1
-- computes multiplicative inverse modulo p.
-- returns input value on failure.
multInv :: Integral i => i -> i -> Either i i
multInv p x =
if comm == 1
then
Right $
-- p * s + x * t = 1
t `mod` p
else Left x
where
(comm, (_s, t)) = extEuclidean p x
type ElimStepM i = [[i]] -> Either (Err i) (Maybe ([i], [[i]]))
solveMat' :: Integral i => (i -> ElimStepM i) -> i -> [[i]] -> Either (Err i) [i]
solveMat' fallback m mat = do
ut <- upperTriangular fallback m mat
pure $ reverse $ unfoldr (solveStep m) ([], reverse ut)
solveMat :: Integral i => i -> [[i]] -> Either (Err i) [i]
solveMat = solveMat' (\_ _ -> Left Underdetermined)
solveMatOne :: Integral i => i -> [[i]] -> Either (Err i) [i]
solveMatOne = solveMat' underDetFallback
solveMatGaussian :: Integral i => i -> [[i]] -> Either (Err i) [i]
solveMatGaussian m modMat = do
let tr orig i =
init orig
<> [if i == j then m else 0 | j <- [0 .. l -1]]
<> [last orig]
l = length modMat
mat = zipWith tr modMat [0 ..]
varCount = length (head mat) - 1
ut = G.upperTriangular ((fmap . fmap) fromIntegral mat)
filled =
G.fillTriangular varCount ut
rResults = reverse $ unfoldr G.solveStep ([], reverse filled)
dElim = foldr lcm 1 (fmap denominator rResults)
nResults = fmap (* fromInteger dElim) rResults
invM <- first (const (Gaussian "no inv")) $ multInv (toInteger m) dElim
when (any ((/= 1) . denominator) nResults) $
-- note: this shouldn't happen.
Left (Gaussian $ "denom /= 1: " <> show ut)
pure $ take l $ fmap ((`mod` m) . (* fromInteger invM) . fromInteger . numerator) nResults
-- try to get one solution out of an underdetermined system.
underDetFallback :: Integral i => i -> ElimStepM i
underDetFallback m eqns
| null eqns = stop
| isLhsSquare = do
{-
note that here we also have l >= 1.
-}
let fstNonZeroInd =
getFirst
. mconcat
. fmap (First . findIndex (\v -> v `mod` m /= 0))
$ eqns
case fstNonZeroInd of
Nothing ->
{-
Making this determined by fixing underdetermined variables to 0.
-}
let (hdL : tlL) =
fmap
(<> [0])
[[if r == c then 1 else 0 | c <- [1 .. l]] | r <- [1 .. l]]
in Right $ Just (hdL, fmap (drop 1) tlL)
Just nzInd -> do
let common = foldr gcd m (concat eqns)
m' = m `div` common
eqns' = (fmap . fmap) (`div` common) eqns
(doShuffle, unShuffle) = shuffler nzInd
eqns'' = fmap doShuffle eqns'
{-
This might seem to be a potential for infinite loop,
but we have prevented that by moving a column that contains
non-zero element to the front to make sure it's making progress.
Update: another case is when gcd is 1, in which case we leave it unhandled for now.
-}
when (common == 1) $
Left $ Todo (show nzInd)
rsPre <- solveMatOne m' eqns''
let rs = unShuffle rsPre
(hdL : tlL) =
zipWith
(\r lhs -> lhs <> [r])
rs
[[if r == c then 1 else 0 | c <- [1 .. l]] | r <- [1 .. l]]
Right $ Just (hdL, fmap (drop 1) tlL)
| otherwise = stop
where
stop = Left Underdetermined
l = length eqns
isLhsSquare = all ((== l + 1) . length) eqns
upperTriangular
:: forall i.
Integral i
=> (i -> ElimStepM i)
-> i
-> [[i]]
-> Either (Err i) [[i]]
upperTriangular fallback m = unfoldrM elimStepM
where
elimStepM :: ElimStepM i
elimStepM eqns = do
let alts = do
-- any equation without a zero on front
(e@(hd : _), es) <- removeEach eqns
guard $ gcd m hd == 1
pure (e, es)
case alts of
[] ->
if null eqns
then Right Nothing
else fallback m eqns
([], _) : _ -> Left Underdetermined
(e@(hd : _), es) : _ -> do
invHd <- first NoMultInv $ multInv m hd
let mul x y = (x * y) `mod` m
eNorm = fmap (mul invHd) (e :: [i])
norm eqn@(eh : _) =
if eh == 0
then eqn
else zipWith (\a b -> (a - b) `mod` m) eqn (fmap (mul eh) eNorm)
norm _ = error "length not unique"
pure $ Just (eNorm, fmap (drop 1 . norm) es)
solveStep :: Integral i => i -> ([i], [[i]]) -> Maybe (i, ([i], [[i]]))
solveStep _ (_, []) = Nothing
solveStep m (xs, hd : tl) = do
let x = (rhs - sum (zipWith (*) lhs xs)) `mod` m
1 : ys = hd
rhs = last ys
lhs = init ys
pure (x, (x : xs, tl))
shuffler :: Int -> ([a] -> [a], [a] -> [a])
shuffler i =
if i <= 0
then (id, id)
else
let doShuffle xs =
if i >= l
then xs
else
let (pres, h : tl) = splitAt i xs
in h : pres <> tl
where
l = length xs
unShuffle xs =
if i >= l
then xs
else
let (hd : ys) = xs
(ys0, ys1) = splitAt i ys
in ys0 <> (hd : ys1)
where
l = length xs
in (doShuffle, unShuffle)
|
Javran/misc
|
gaussian-elim/src/Solver.hs
|
Haskell
|
mit
| 6,510
|
-- | Data.TSTP.V module.
-- Adapted from https://github.com/agomezl/tstp2agda.
module Data.TSTP.V
( V
( V )
) where
------------------------------------------------------------------------------
import Athena.Utils.PrettyPrint ( Pretty ( pretty ) )
import Athena.Translation.Utils ( stdName )
------------------------------------------------------------------------------
-- The following code is from:
-- https://github.com/DanielSchuessler/logic-TPTP
-- and is used with the propose of reuses his
-- alex/happy parser in a more simple way
-- | Variable
newtype V = V String
deriving (Eq, Ord, Read, Show)
instance Pretty V where
pretty (V a) = pretty . stdName $ a
|
jonaprieto/athena
|
src/Data/TSTP/V.hs
|
Haskell
|
mit
| 696
|
{-# language NoImplicitPrelude, DoAndIfThenElse, OverloadedStrings, ExtendedDefaultRules #-}
{-# LANGUAGE CPP #-}
-- | Description : Shell scripting wrapper using @Shelly@ for the @notebook@, and
-- @console@ commands.
module IHaskell.IPython (
replaceIPythonKernelspec,
defaultConfFile,
getIHaskellDir,
getSandboxPackageConf,
subHome,
kernelName,
KernelSpecOptions(..),
defaultKernelSpecOptions,
) where
import IHaskellPrelude
import qualified Data.Text as T
import qualified Data.Text.Lazy as LT
import qualified Data.ByteString as BS
import qualified Data.ByteString.Lazy as LBS
import qualified Data.ByteString.Char8 as CBS
import Control.Concurrent (threadDelay)
import System.Argv0
import qualified Shelly as SH
import qualified System.IO as IO
import qualified System.FilePath as FP
import System.Directory
import System.Exit (exitFailure)
import Data.Aeson (toJSON)
import Data.Aeson.Text (encodeToTextBuilder)
import Data.Text.Lazy.Builder (toLazyText)
import Control.Monad (mplus)
import qualified System.IO.Strict as StrictIO
import qualified Paths_ihaskell as Paths
import qualified GHC.Paths
import IHaskell.Types
import System.Posix.Signals
import StringUtils (replace, split)
data KernelSpecOptions =
KernelSpecOptions
{ kernelSpecGhcLibdir :: String -- ^ GHC libdir.
, kernelSpecDebug :: Bool -- ^ Spew debugging output?
, kernelSpecConfFile :: IO (Maybe String) -- ^ Filename of profile JSON file.
, kernelSpecInstallPrefix :: Maybe String
, kernelSpecUseStack :: Bool -- ^ Whether to use @stack@ environments.
}
defaultKernelSpecOptions :: KernelSpecOptions
defaultKernelSpecOptions = KernelSpecOptions
{ kernelSpecGhcLibdir = GHC.Paths.libdir
, kernelSpecDebug = False
, kernelSpecConfFile = defaultConfFile
, kernelSpecInstallPrefix = Nothing
, kernelSpecUseStack = False
}
-- | The IPython kernel name.
kernelName :: String
kernelName = "haskell"
kernelArgs :: [String]
kernelArgs = ["--kernel", kernelName]
ipythonCommand :: SH.Sh SH.FilePath
ipythonCommand = do
jupyterMay <- SH.which "jupyter"
return $
case jupyterMay of
Nothing -> "ipython"
Just _ -> "jupyter"
locateIPython :: SH.Sh SH.FilePath
locateIPython = do
mbinary <- SH.which "jupyter"
case mbinary of
Nothing -> SH.errorExit "The Jupyter binary could not be located"
Just ipython -> return ipython
-- | Run the IPython command with any arguments. The kernel is set to IHaskell.
ipython :: Bool -- ^ Whether to suppress output.
-> [Text] -- ^ IPython command line arguments.
-> SH.Sh String -- ^ IPython output.
ipython suppress args = do
liftIO $ installHandler keyboardSignal (CatchOnce $ return ()) Nothing
-- We have this because using `run` does not let us use stdin.
cmd <- ipythonCommand
SH.runHandles cmd args handles doNothing
where
handles = [SH.InHandle SH.Inherit, outHandle suppress, errorHandle suppress]
outHandle True = SH.OutHandle SH.CreatePipe
outHandle False = SH.OutHandle SH.Inherit
errorHandle True = SH.ErrorHandle SH.CreatePipe
errorHandle False = SH.ErrorHandle SH.Inherit
doNothing _ stdout _ = if suppress
then liftIO $ StrictIO.hGetContents stdout
else return ""
-- | Run while suppressing all output.
quietRun path args = SH.runHandles path args handles nothing
where
handles = [SH.InHandle SH.Inherit, SH.OutHandle SH.CreatePipe, SH.ErrorHandle SH.CreatePipe]
nothing _ _ _ = return ()
fp :: SH.FilePath -> FilePath
fp = T.unpack . SH.toTextIgnore
-- | Create the directory and return it.
ensure :: SH.Sh SH.FilePath -> SH.Sh SH.FilePath
ensure getDir = do
dir <- getDir
SH.mkdir_p dir
return dir
-- | Return the data directory for IHaskell.
ihaskellDir :: SH.Sh FilePath
ihaskellDir = do
home <- maybe (error "$HOME not defined.") SH.fromText <$> SH.get_env "HOME"
fp <$> ensure (return (home SH.</> ".ihaskell"))
notebookDir :: SH.Sh SH.FilePath
notebookDir = ensure $ (SH.</> "notebooks") <$> ihaskellDir
getIHaskellDir :: IO String
getIHaskellDir = SH.shelly ihaskellDir
defaultConfFile :: IO (Maybe String)
defaultConfFile = fmap (fmap fp) . SH.shelly $ do
filename <- (SH.</> "rc.hs") <$> ihaskellDir
exists <- SH.test_f filename
return $ if exists
then Just filename
else Nothing
replaceIPythonKernelspec :: KernelSpecOptions -> IO ()
replaceIPythonKernelspec kernelSpecOpts = SH.shelly $ do
verifyIPythonVersion
installKernelspec True kernelSpecOpts
-- | Verify that a proper version of IPython is installed and accessible.
verifyIPythonVersion :: SH.Sh ()
verifyIPythonVersion = do
cmd <- ipythonCommand
pathMay <- SH.which cmd
case pathMay of
Nothing -> badIPython
"No Jupyter / IPython detected -- install Jupyter 3.0+ before using IHaskell."
Just path -> do
stdout <- SH.silently (SH.run path ["--version"])
stderr <- SH.lastStderr
let majorVersion = join . fmap listToMaybe . parseVersion . T.unpack
case mplus (majorVersion stderr) (majorVersion stdout) of
Nothing -> badIPython $ T.concat
[ "Detected Jupyter, but could not parse version number."
, "\n"
, "(stdout = "
, stdout
, ", stderr = "
, stderr
, ")"
]
Just version -> when (version < 3) oldIPython
where
badIPython :: Text -> SH.Sh ()
badIPython message = liftIO $ do
IO.hPutStrLn IO.stderr (T.unpack message)
exitFailure
oldIPython = badIPython
"Detected old version of Jupyter / IPython. IHaskell requires 3.0.0 or up."
-- | Install an IHaskell kernelspec into the right location. The right location is determined by
-- using `ipython kernelspec install --user`.
installKernelspec :: Bool -> KernelSpecOptions -> SH.Sh ()
installKernelspec replace opts = void $ do
ihaskellPath <- getIHaskellPath
confFile <- liftIO $ kernelSpecConfFile opts
let kernelFlags :: [String]
kernelFlags =
["--debug" | kernelSpecDebug opts] ++
(case confFile of
Nothing -> []
Just file -> ["--conf", file])
++ ["--ghclib", kernelSpecGhcLibdir opts]
++ ["--stack" | kernelSpecUseStack opts]
let kernelSpec = KernelSpec
{ kernelDisplayName = "Haskell"
, kernelLanguage = kernelName
, kernelCommand = [ihaskellPath, "kernel", "{connection_file}"] ++ kernelFlags
}
-- Create a temporary directory. Use this temporary directory to make a kernelspec directory; then,
-- shell out to IPython to install this kernelspec directory.
SH.withTmpDir $ \tmp -> do
let kernelDir = tmp SH.</> kernelName
let filename = kernelDir SH.</> "kernel.json"
SH.mkdir_p kernelDir
SH.writefile filename $ LT.toStrict $ toLazyText $ encodeToTextBuilder $ toJSON kernelSpec
let files = ["kernel.js", "logo-64x64.png"]
forM_ files $ \file -> do
src <- liftIO $ Paths.getDataFileName $ "html/" ++ file
SH.cp (SH.fromText $ T.pack src) (tmp SH.</> kernelName SH.</> file)
ipython <- locateIPython
let replaceFlag = ["--replace" | replace]
installPrefixFlag = maybe ["--user"] (\prefix -> ["--prefix", T.pack prefix]) (kernelSpecInstallPrefix opts)
cmd = concat [["kernelspec", "install"], installPrefixFlag, [SH.toTextIgnore kernelDir], replaceFlag]
SH.silently $ SH.run ipython cmd
kernelSpecCreated :: SH.Sh Bool
kernelSpecCreated = do
ipython <- locateIPython
out <- SH.silently $ SH.run ipython ["kernelspec", "list"]
let kernelspecs = map T.strip $ T.lines out
return $ T.pack kernelName `elem` kernelspecs
-- | Replace "~" with $HOME if $HOME is defined. Otherwise, do nothing.
subHome :: String -> IO String
subHome path = SH.shelly $ do
home <- T.unpack <$> fromMaybe "~" <$> SH.get_env "HOME"
return $ replace "~" home path
-- | Get the path to an executable. If it doensn't exist, fail with an error message complaining
-- about it.
path :: Text -> SH.Sh SH.FilePath
path exe = do
path <- SH.which $ SH.fromText exe
case path of
Nothing -> do
liftIO $ putStrLn $ "Could not find `" ++ T.unpack exe ++ "` executable."
fail $ "`" ++ T.unpack exe ++ "` not on $PATH."
Just exePath -> return exePath
-- | Parse an IPython version string into a list of integers.
parseVersion :: String -> Maybe [Int]
parseVersion versionStr =
let versions = map readMay $ split "." versionStr
parsed = all isJust versions
in if parsed
then Just $ map fromJust versions
else Nothing
-- | Get the absolute path to this IHaskell executable.
getIHaskellPath :: SH.Sh FilePath
getIHaskellPath = do
-- Get the absolute filepath to the argument.
f <- T.unpack <$> SH.toTextIgnore <$> liftIO getArgv0
-- If we have an absolute path, that's the IHaskell we're interested in.
if FP.isAbsolute f
then return f
else
-- Check whether this is a relative path, or just 'IHaskell' with $PATH resolution done by
-- the shell. If it's just 'IHaskell', use the $PATH variable to find where IHaskell lives.
if FP.takeFileName f == f
then do
ihaskellPath <- SH.which "ihaskell"
case ihaskellPath of
Nothing -> error "ihaskell not on $PATH and not referenced relative to directory."
Just path -> return $ T.unpack $ SH.toTextIgnore path
else liftIO $ makeAbsolute f
#if !MIN_VERSION_directory(1, 2, 2)
-- This is included in later versions of `directory`, but we cannot use later versions because GHC
-- library depends on a particular version of it.
makeAbsolute :: FilePath -> IO FilePath
makeAbsolute = fmap FP.normalise . absolutize
where
absolutize path -- avoid the call to `getCurrentDirectory` if we can
| FP.isRelative path = fmap (FP.</> path) getCurrentDirectory
| otherwise = return path
#endif
getSandboxPackageConf :: IO (Maybe String)
getSandboxPackageConf = SH.shelly $ do
myPath <- getIHaskellPath
let sandboxName = ".cabal-sandbox"
if not $ sandboxName `isInfixOf` myPath
then return Nothing
else do
let pieces = split "/" myPath
sandboxDir = intercalate "/" $ takeWhile (/= sandboxName) pieces ++ [sandboxName]
subdirs <- map fp <$> SH.ls (SH.fromText $ T.pack sandboxDir)
let confdirs = filter (isSuffixOf ("packages.conf.d" :: String)) subdirs
case confdirs of
[] -> return Nothing
dir:_ ->
return $ Just dir
|
sumitsahrawat/IHaskell
|
src/IHaskell/IPython.hs
|
Haskell
|
mit
| 10,974
|
module Monoid3 where
import Data.Semigroup
import Test.QuickCheck
import SemiGroupAssociativeLaw
import MonoidLaws
import ArbitrarySum
data Two a b = Two a b deriving (Eq, Show)
instance (Semigroup a, Semigroup b) => Semigroup (Two a b) where
(Two x1 y1) <> (Two x2 y2) = Two (x1 <> x2) (y1 <> y2)
instance (Semigroup a, Monoid a, Semigroup b, Monoid b) => Monoid (Two a b) where
mempty = Two mempty mempty
mappend = (<>)
instance (Arbitrary a, Arbitrary b) => Arbitrary (Two a b) where
arbitrary = Two <$> arbitrary <*> arbitrary
type TwoAssoc = Two (Sum Int) (Sum Int) -> Two (Sum Int) (Sum Int) -> Two (Sum Int) (Sum Int) -> Bool
main :: IO ()
main = do
quickCheck (semigroupAssoc :: TwoAssoc)
quickCheck (monoidLeftIdentity :: Two (Sum Int) (Sum Int) -> Bool)
quickCheck (monoidRightIdentity :: Two (Sum Int) (Sum Int) -> Bool)
|
NickAger/LearningHaskell
|
HaskellProgrammingFromFirstPrinciples/Chapter15.hsproj/Monoid3.hs
|
Haskell
|
mit
| 869
|
{-# LANGUAGE CPP, GeneralizedNewtypeDeriving, OverloadedStrings #-}
{-
compatibility with older GHC
-}
module Compiler.Compat ( PackageKey
, packageKeyString
, modulePackageKey
, stringToPackageKey
, primPackageKey
, mainPackageKey
, modulePackageName
, getPackageName
, getInstalledPackageName
, getPackageVersion
, getInstalledPackageVersion
, getPackageLibDirs
, getInstalledPackageLibDirs
, getPackageHsLibs
, getInstalledPackageHsLibs
, searchModule
, Version(..)
, showVersion
, isEmptyVersion
) where
import Module
import DynFlags
import FastString
import Prelude
import Packages hiding ( Version )
import Data.Binary
import Data.Text (Text)
import qualified Data.Text as T
import qualified Data.Version as DV
-- we do not support version tags since support for them has
-- been broken for a long time anyway
newtype Version = Version { unVersion :: [Integer] }
deriving (Ord, Eq, Show, Binary)
showVersion :: Version -> Text
showVersion = T.intercalate "." . map (T.pack . show) . unVersion
isEmptyVersion :: Version -> Bool
isEmptyVersion = null . unVersion
convertVersion :: DV.Version -> Version
convertVersion v = Version (map fromIntegral $ versionBranch v)
type PackageKey = UnitId
packageKeyString :: UnitId -> String
packageKeyString = unitIdString
modulePackageKey :: Module -> UnitId
modulePackageKey = moduleUnitId
stringToPackageKey :: String -> InstalledUnitId
stringToPackageKey = stringToInstalledUnitId
primPackageKey :: UnitId
primPackageKey = primUnitId
mainPackageKey :: UnitId
mainPackageKey = mainUnitId
getPackageName :: DynFlags -> UnitId -> String
getPackageName dflags
= maybe "" ((\(PackageName n) -> unpackFS n) . packageName)
. lookupPackage dflags
getInstalledPackageName :: DynFlags -> InstalledUnitId -> String
getInstalledPackageName dflags
= maybe "" ((\(PackageName n) -> unpackFS n) . packageName)
. lookupInstalledPackage dflags
modulePackageName :: DynFlags -> Module -> String
modulePackageName dflags
= getPackageName dflags . moduleUnitId
getPackageVersion :: DynFlags -> UnitId -> Maybe Version
getPackageVersion dflags
= fmap (convertVersion . packageVersion)
. lookupPackage dflags
getInstalledPackageVersion :: DynFlags -> InstalledUnitId -> Maybe Version
getInstalledPackageVersion dflags
= fmap (convertVersion . packageVersion)
. lookupInstalledPackage dflags
getPackageLibDirs :: DynFlags -> UnitId -> [FilePath]
getPackageLibDirs dflags
= maybe [] libraryDirs . lookupPackage dflags
getInstalledPackageLibDirs :: DynFlags -> InstalledUnitId -> [FilePath]
getInstalledPackageLibDirs dflags
= maybe [] libraryDirs . lookupInstalledPackage dflags
getPackageHsLibs :: DynFlags -> UnitId -> [String]
getPackageHsLibs dflags
= maybe [] hsLibraries . lookupPackage dflags
getInstalledPackageHsLibs :: DynFlags -> InstalledUnitId -> [String]
getInstalledPackageHsLibs dflags
= maybe [] hsLibraries . lookupInstalledPackage dflags
searchModule :: DynFlags -> ModuleName -> [(String, UnitId)]
searchModule dflags
= map ((\k -> (getPackageName dflags k, k)) . moduleUnitId . fst)
-- $ fromLookupResult
-- $ lookupModuleWithSuggestions dflags mn Nothing
. lookupModuleInAllPackages dflags
|
ghcjs/ghcjs
|
src/Compiler/Compat.hs
|
Haskell
|
mit
| 3,659
|
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE TemplateHaskell #-}
{- |
This is where all the real code for the cartographer lives.
-}
module Network.Eureka.Cartographer.HTTP (
Config(..),
withEureka,
website
) where
import Prelude hiding (lookup)
import Control.Exception (try, evaluate, SomeException)
import Control.Monad.IO.Class (liftIO)
import Data.Aeson (FromJSON(parseJSON), Value(Object), (.:),
Value(String))
import Data.ByteString (hGetContents)
import Data.Char (toLower)
import Data.GraphViz (DotGraph(DotGraph, strictGraph, directedGraph,
graphID, graphStatements), DotStatements(DotStmts, attrStmts, subGraphs,
nodeStmts, edgeStmts), ParseDotRepr, parseDotGraph, GraphvizOutput(Svg),
GraphvizCommand(Dot), graphvizWithHandle, DotNode(DotNode, nodeID,
nodeAttributes))
import Data.List.Split (splitOn)
import Data.Map (elems, lookup, keys)
import Data.Maybe (fromMaybe)
import Data.Text.Encoding (decodeUtf8)
import Data.Text.Lazy (Text)
import GHC.Generics (Generic)
import Network.Eureka (EurekaConfig(eurekaServerServiceUrls),
DataCenterInfo(DataCenterMyOwn, DataCenterAmazon), EurekaConnection,
InstanceConfig, def, discoverDataCenterAmazon, lookupAllApplications,
InstanceInfo(InstanceInfo, instanceInfoMetadata))
import Network.Eureka.Cartographer.TH (addCartographerMetadata)
import Network.HTTP.Client (newManager, defaultManagerSettings)
import Snap (Snap, writeBS, modifyResponse, setHeader, getParam)
import System.IO.Unsafe (unsafePerformIO)
import Text.Read (readMaybe)
import qualified Data.Map as Map (fromList)
import qualified Data.Text as T (unpack)
import qualified Data.Text.Lazy as TL (pack)
import qualified Network.Eureka as E (withEureka)
data Config = Config {
eureka :: CartographerEurekaConfig
} deriving (Generic)
instance FromJSON Config
data CartographerEurekaConfig
= EurekaDeveloper {
serviceUrls :: [String]
}
| EurekaAmazon {
serviceUrls :: [String]
} deriving Show
instance FromJSON CartographerEurekaConfig where
parseJSON (Object v) = do
datacenter <- v .: "datacenterType"
(String urls) <- v .: "serviceUrls"
return $ constructor datacenter (splitOn "," $ T.unpack urls)
where
constructor :: Text -> [String] -> CartographerEurekaConfig
constructor "developer" = EurekaDeveloper
constructor "amazon" = EurekaAmazon
constructor s = error (
"bad value for datacenterType config parameter: " ++ show s ++
". Valid values are 'developer' and 'amazon'."
)
parseJSON v = error $ "couldn't parse Eureka Config from: " ++ show v
{- |
Our own version of `withEureka`, which delegates to
`Network.Eureka.withEureka`
-}
withEureka
:: CartographerEurekaConfig
-> InstanceConfig
-> (EurekaConnection -> IO a)
-> IO a
withEureka EurekaAmazon {serviceUrls} instanceConfig a = do
dataCenter <- newManager defaultManagerSettings >>= discoverDataCenterAmazon
eurekaWithServiceUrls
serviceUrls
instanceConfig
(DataCenterAmazon dataCenter)
a
withEureka EurekaDeveloper {serviceUrls} instanceConfig a =
eurekaWithServiceUrls
serviceUrls
instanceConfig
DataCenterMyOwn
a
{- |
Helper for `withEureka`. Adds cartography metadata and delegates to
`E.withEureka`.
-}
eurekaWithServiceUrls
:: [String]
-> InstanceConfig
-> DataCenterInfo
-> (EurekaConnection -> IO a)
-> IO a
eurekaWithServiceUrls urls =
E.withEureka eurekaConfig . $(addCartographerMetadata "cartography.dot")
where
eurekaConfig = def {
eurekaServerServiceUrls = Map.fromList [("default", urls)]
}
{- |
The actual snap website that generates the pretty pictures.
-}
website :: EurekaConnection -> Snap ()
website eConn = do
apps <- liftIO (lookupAllApplications eConn)
(serveDotGraph . addNodes (keys apps) . joinInstances . concat . elems) apps
where
emptyGraph :: DotGraphT
emptyGraph = DotGraph {
strictGraph = True,
directedGraph = True,
graphID = Nothing,
graphStatements = DotStmts {
attrStmts = [],
subGraphs = [],
nodeStmts = [],
edgeStmts = []
}
}
addNodes :: [String] -> DotGraphT -> DotGraphT
addNodes nodes graph@DotGraph {graphStatements} =
graph {
graphStatements = foldr addNode graphStatements nodes
}
addNode :: String -> DotStatementsT -> DotStatementsT
addNode node stmts@DotStmts {nodeStmts} = stmts {
nodeStmts =
let nodeId = TL.pack (fmap toLower node) in
DotNode {nodeID = nodeId, nodeAttributes = []} : nodeStmts
}
joinInstances :: [InstanceInfo] -> DotGraphT
joinInstances = foldr joinInstance emptyGraph
joinInstance :: InstanceInfo -> DotGraphT -> DotGraphT
joinInstance inst dot =
joinGraph dot (instToGraph inst)
joinGraph :: DotGraphT -> DotGraphT -> DotGraphT
joinGraph
graph@DotGraph {graphStatements = s1}
DotGraph {graphStatements = s2} =
graph {graphStatements = joinStatements s1 s2}
joinStatements :: DotStatementsT -> DotStatementsT -> DotStatementsT
joinStatements s1 s2 = DotStmts {
attrStmts = attrStmts s1 ++ attrStmts s2,
subGraphs = subGraphs s1 ++ subGraphs s2,
nodeStmts = nodeStmts s1 ++ nodeStmts s2,
edgeStmts = edgeStmts s1 ++ edgeStmts s2
}
instToGraph :: InstanceInfo -> DotGraphT
instToGraph InstanceInfo {instanceInfoMetadata} =
maybe emptyGraph parseGraph (lookup "cartography" instanceInfoMetadata)
parseGraph :: String -> DotGraphT
parseGraph dotStr =
case parseDotGraphEither (TL.pack dotStr) of
Left _ -> emptyGraph
Right g -> g
serveDotGraph :: DotGraphT -> Snap ()
serveDotGraph graph = do
graphType <- getGraphType
modifyResponse (setHeader "Content-Type" "image/svg+xml")
writeBS =<< liftIO (graphvizWithHandle graphType graph Svg hGetContents)
{- |
Figures out the graph type based on the query string param "graphType".
-}
getGraphType :: Snap GraphvizCommand
getGraphType = do
typeM <- getParam "graphType"
return $ case typeM of
Nothing -> Dot
Just str ->
fromMaybe Dot (readMaybe (T.unpack (decodeUtf8 str)))
{- |
Shorthand type for dot graphs.
-}
type DotGraphT = DotGraph Text
{- |
Shorthand type for graph statements
-}
type DotStatementsT = DotStatements Text
{- |
Parse a dot graph using Either. Sadly, `parseDotGraph` in the graphviz
package is not total and throws a value error on bad input. Since
we can only catch the error in the IO monad, we are forced to use
`unsafePerformIO` to make this function total. This is safe because
it doesn't matter when, or how many times, this gets executed, and
there are no external side effects.
-}
parseDotGraphEither :: (ParseDotRepr dg n) => Text -> Either String (dg n)
parseDotGraphEither dotStr = unsafePerformIO $ do
graphE <- try (evaluate (parseDotGraph dotStr))
return $ case graphE of
Left e -> Left (show (e :: SomeException))
Right graph -> Right graph
|
SumAll/haskell-cartographer-server
|
src/Network/Eureka/Cartographer/HTTP.hs
|
Haskell
|
apache-2.0
| 7,188
|
module FFMpegCommandSpec where
import Test.HUnit
import FFMpegCommand
runFFMpegCommandTests = runTestTT tests
tests = TestList [ TestLabel "Test Single Time" testSingleTime
, TestLabel "Test Two Times" testTwoTimes ]
testSingleTime = TestCase (
assertEqual "test.mkv 00:00:01" (Just "ffmpeg -i test.mkv -ss 00:00:00.000 -t 00:00:01.000 0.mp4 -i test.mkv -ss 00:00:01.000 1.mp4") (generateCommand "test.mkv" "mp4" "" ["00:00:01"]) )
testTwoTimes = TestCase (
assertEqual "test.mkv 00:00:01 00:00:02" (Just "ffmpeg -i test.mkv -ss 00:00:00.000 -t 00:00:01.000 0.mp4 -i test.mkv -ss 00:00:01.000 -t 00:00:02.000 1.mp4 -i test.mkv -ss 00:00:02.000 2.mp4") (generateCommand "test.mkv" "mp4" "" ["00:00:01", "00:00:02"]) )
testExtraCommands = TestCase (
assertEqual "test.mkv 00:00:01 00:00:02" (Just "ffmpeg -i test.mkv -c:v libx264 -ss 00:00:00.000 -t 00:00:01.000 0.mp4 -i test.mkv -c:v libx264 -ss 00:00:01.000 -t 00:00:02.000 1.mp4 -i test.mkv -c:v libx264 -ss 00:00:02.000 2.mp4") (generateCommand "test.mkv" "mp4" "-c:v libx264" ["00:00:01", "00:00:02"]) )
|
connrs/ffsplitgen
|
test/FFMpegCommandSpec.hs
|
Haskell
|
apache-2.0
| 1,087
|
{-# LANGUAGE EmptyDataDecls #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE QuasiQuotes #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
module CourseStitch.Models.Tables (
module CourseStitch.Models.Types,
module CourseStitch.Models.Tables
)where
import Data.Text (Text)
import Data.ByteString.Char8 (ByteString)
import Database.Persist.TH
import CourseStitch.Models.Types
{- See the following page in the Yesod book for a description of what these
- quasiquotes generate.
- http://www.yesodweb.com/book/persistent#persistent_code_generation -}
share [mkPersist sqlSettings, mkMigrate "migrateAll"] [persistLowerCase|
Resource json
title Text
media Text
url Text
UniqueResourceUrl url
course Text
summary Text
preview Text
keywords Text
deriving Show
Concept json
topic TopicId Maybe
title Text
UniqueConceptTitle title
deriving Show Eq
Topic json
title Text
summary Text
UniqueTopicTitle title
deriving Show Eq
Relationship json
resource ResourceId
relationship RelationshipType
concept ConceptId
UniqueResourceConcept resource concept
deriving Show Eq
User
name Text
UniqueUserName name
hash ByteString
deriving Show
Session
user UserId
token Token
deriving Show
ResourceMastery json
user UserId
resource ResourceId
UniqueMasteryUserResource user resource
deriving Show
ConceptMastery json
user UserId
concept ConceptId
UniqueMasteryUserConcept user concept
deriving Show
|]
|
coursestitch/coursestitch-api
|
lib/CourseStitch/Models/Tables.hs
|
Haskell
|
apache-2.0
| 1,841
|
-- http://www.codewars.com/kata/5467e4d82edf8bbf40000155
module DescendingOrder where
import Data.List
descendingOrder :: Integer -> Integer
descendingOrder = foldl (\acc n -> acc * 10 + n) 0 . sortBy (flip compare) . map (`mod`10) . takeWhile (>0) . iterate (`div`10)
|
Bodigrim/katas
|
src/haskell/7-Descending-Order.hs
|
Haskell
|
bsd-2-clause
| 271
|
{-# OPTIONS -fglasgow-exts #-}
-----------------------------------------------------------------------------
{-| Module : QSystemTrayIcon_h.hs
Copyright : (c) David Harley 2010
Project : qtHaskell
Version : 1.1.4
Modified : 2010-09-02 17:02:18
Warning : this file is machine generated - do not modify.
--}
-----------------------------------------------------------------------------
module Qtc.Gui.QSystemTrayIcon_h where
import Foreign.C.Types
import Qtc.Enums.Base
import Qtc.Classes.Base
import Qtc.Classes.Qccs_h
import Qtc.Classes.Core_h
import Qtc.ClassTypes.Core
import Qth.ClassTypes.Core
import Qtc.Classes.Gui_h
import Qtc.ClassTypes.Gui
import Foreign.Marshal.Array
instance QunSetUserMethod (QSystemTrayIcon ()) where
unSetUserMethod qobj evid
= withBoolResult $
withObjectPtr qobj $ \cobj_qobj ->
qtc_QSystemTrayIcon_unSetUserMethod cobj_qobj (toCInt 0) (toCInt evid)
foreign import ccall "qtc_QSystemTrayIcon_unSetUserMethod" qtc_QSystemTrayIcon_unSetUserMethod :: Ptr (TQSystemTrayIcon a) -> CInt -> CInt -> IO (CBool)
instance QunSetUserMethod (QSystemTrayIconSc a) where
unSetUserMethod qobj evid
= withBoolResult $
withObjectPtr qobj $ \cobj_qobj ->
qtc_QSystemTrayIcon_unSetUserMethod cobj_qobj (toCInt 0) (toCInt evid)
instance QunSetUserMethodVariant (QSystemTrayIcon ()) where
unSetUserMethodVariant qobj evid
= withBoolResult $
withObjectPtr qobj $ \cobj_qobj ->
qtc_QSystemTrayIcon_unSetUserMethod cobj_qobj (toCInt 1) (toCInt evid)
instance QunSetUserMethodVariant (QSystemTrayIconSc a) where
unSetUserMethodVariant qobj evid
= withBoolResult $
withObjectPtr qobj $ \cobj_qobj ->
qtc_QSystemTrayIcon_unSetUserMethod cobj_qobj (toCInt 1) (toCInt evid)
instance QunSetUserMethodVariantList (QSystemTrayIcon ()) where
unSetUserMethodVariantList qobj evid
= withBoolResult $
withObjectPtr qobj $ \cobj_qobj ->
qtc_QSystemTrayIcon_unSetUserMethod cobj_qobj (toCInt 2) (toCInt evid)
instance QunSetUserMethodVariantList (QSystemTrayIconSc a) where
unSetUserMethodVariantList qobj evid
= withBoolResult $
withObjectPtr qobj $ \cobj_qobj ->
qtc_QSystemTrayIcon_unSetUserMethod cobj_qobj (toCInt 2) (toCInt evid)
instance QsetUserMethod (QSystemTrayIcon ()) (QSystemTrayIcon x0 -> IO ()) where
setUserMethod _eobj _eid _handler
= do
funptr <- wrapSetUserMethod_QSystemTrayIcon setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetUserMethod_QSystemTrayIcon_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
qtc_QSystemTrayIcon_setUserMethod cobj_eobj (toCInt _eid) (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return ()
where
setHandlerWrapper :: Ptr (TQSystemTrayIcon x0) -> IO ()
setHandlerWrapper x0
= do
x0obj <- objectFromPtr_nf x0
if (objectIsNull x0obj)
then return ()
else _handler x0obj
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
foreign import ccall "qtc_QSystemTrayIcon_setUserMethod" qtc_QSystemTrayIcon_setUserMethod :: Ptr (TQSystemTrayIcon a) -> CInt -> Ptr (Ptr (TQSystemTrayIcon x0) -> IO ()) -> Ptr () -> Ptr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO ()
foreign import ccall "wrapper" wrapSetUserMethod_QSystemTrayIcon :: (Ptr (TQSystemTrayIcon x0) -> IO ()) -> IO (FunPtr (Ptr (TQSystemTrayIcon x0) -> IO ()))
foreign import ccall "wrapper" wrapSetUserMethod_QSystemTrayIcon_d :: (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO (FunPtr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()))
instance QsetUserMethod (QSystemTrayIconSc a) (QSystemTrayIcon x0 -> IO ()) where
setUserMethod _eobj _eid _handler
= do
funptr <- wrapSetUserMethod_QSystemTrayIcon setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetUserMethod_QSystemTrayIcon_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
qtc_QSystemTrayIcon_setUserMethod cobj_eobj (toCInt _eid) (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return ()
where
setHandlerWrapper :: Ptr (TQSystemTrayIcon x0) -> IO ()
setHandlerWrapper x0
= do
x0obj <- objectFromPtr_nf x0
if (objectIsNull x0obj)
then return ()
else _handler x0obj
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
instance QsetUserMethod (QSystemTrayIcon ()) (QSystemTrayIcon x0 -> QVariant () -> IO (QVariant ())) where
setUserMethod _eobj _eid _handler
= do
funptr <- wrapSetUserMethodVariant_QSystemTrayIcon setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetUserMethodVariant_QSystemTrayIcon_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
qtc_QSystemTrayIcon_setUserMethodVariant cobj_eobj (toCInt _eid) (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return ()
where
setHandlerWrapper :: Ptr (TQSystemTrayIcon x0) -> Ptr (TQVariant ()) -> IO (Ptr (TQVariant ()))
setHandlerWrapper x0 x1
= do
x0obj <- objectFromPtr_nf x0
x1obj <- objectFromPtr_nf x1
rv <- if (objectIsNull x0obj)
then return $ objectCast x0obj
else _handler x0obj x1obj
withObjectPtr rv $ \cobj_rv -> return cobj_rv
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
foreign import ccall "qtc_QSystemTrayIcon_setUserMethodVariant" qtc_QSystemTrayIcon_setUserMethodVariant :: Ptr (TQSystemTrayIcon a) -> CInt -> Ptr (Ptr (TQSystemTrayIcon x0) -> Ptr (TQVariant ()) -> IO (Ptr (TQVariant ()))) -> Ptr () -> Ptr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO ()
foreign import ccall "wrapper" wrapSetUserMethodVariant_QSystemTrayIcon :: (Ptr (TQSystemTrayIcon x0) -> Ptr (TQVariant ()) -> IO (Ptr (TQVariant ()))) -> IO (FunPtr (Ptr (TQSystemTrayIcon x0) -> Ptr (TQVariant ()) -> IO (Ptr (TQVariant ()))))
foreign import ccall "wrapper" wrapSetUserMethodVariant_QSystemTrayIcon_d :: (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO (FunPtr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()))
instance QsetUserMethod (QSystemTrayIconSc a) (QSystemTrayIcon x0 -> QVariant () -> IO (QVariant ())) where
setUserMethod _eobj _eid _handler
= do
funptr <- wrapSetUserMethodVariant_QSystemTrayIcon setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetUserMethodVariant_QSystemTrayIcon_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
qtc_QSystemTrayIcon_setUserMethodVariant cobj_eobj (toCInt _eid) (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return ()
where
setHandlerWrapper :: Ptr (TQSystemTrayIcon x0) -> Ptr (TQVariant ()) -> IO (Ptr (TQVariant ()))
setHandlerWrapper x0 x1
= do
x0obj <- objectFromPtr_nf x0
x1obj <- objectFromPtr_nf x1
rv <- if (objectIsNull x0obj)
then return $ objectCast x0obj
else _handler x0obj x1obj
withObjectPtr rv $ \cobj_rv -> return cobj_rv
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
instance QunSetHandler (QSystemTrayIcon ()) where
unSetHandler qobj evid
= withBoolResult $
withObjectPtr qobj $ \cobj_qobj ->
withCWString evid $ \cstr_evid ->
qtc_QSystemTrayIcon_unSetHandler cobj_qobj cstr_evid
foreign import ccall "qtc_QSystemTrayIcon_unSetHandler" qtc_QSystemTrayIcon_unSetHandler :: Ptr (TQSystemTrayIcon a) -> CWString -> IO (CBool)
instance QunSetHandler (QSystemTrayIconSc a) where
unSetHandler qobj evid
= withBoolResult $
withObjectPtr qobj $ \cobj_qobj ->
withCWString evid $ \cstr_evid ->
qtc_QSystemTrayIcon_unSetHandler cobj_qobj cstr_evid
instance QsetHandler (QSystemTrayIcon ()) (QSystemTrayIcon x0 -> QObject t1 -> QEvent t2 -> IO (Bool)) where
setHandler _eobj _eid _handler
= do
funptr <- wrapSetHandler_QSystemTrayIcon1 setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetHandler_QSystemTrayIcon1_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
withCWString _eid $ \cstr_eid ->
qtc_QSystemTrayIcon_setHandler1 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return()
where
setHandlerWrapper :: Ptr (TQSystemTrayIcon x0) -> Ptr (TQObject t1) -> Ptr (TQEvent t2) -> IO (CBool)
setHandlerWrapper x0 x1 x2
= do x0obj <- qSystemTrayIconFromPtr x0
x1obj <- qObjectFromPtr x1
x2obj <- objectFromPtr_nf x2
let rv =
if (objectIsNull x0obj)
then return False
else _handler x0obj x1obj x2obj
rvf <- rv
return (toCBool rvf)
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
foreign import ccall "qtc_QSystemTrayIcon_setHandler1" qtc_QSystemTrayIcon_setHandler1 :: Ptr (TQSystemTrayIcon a) -> CWString -> Ptr (Ptr (TQSystemTrayIcon x0) -> Ptr (TQObject t1) -> Ptr (TQEvent t2) -> IO (CBool)) -> Ptr () -> Ptr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO ()
foreign import ccall "wrapper" wrapSetHandler_QSystemTrayIcon1 :: (Ptr (TQSystemTrayIcon x0) -> Ptr (TQObject t1) -> Ptr (TQEvent t2) -> IO (CBool)) -> IO (FunPtr (Ptr (TQSystemTrayIcon x0) -> Ptr (TQObject t1) -> Ptr (TQEvent t2) -> IO (CBool)))
foreign import ccall "wrapper" wrapSetHandler_QSystemTrayIcon1_d :: (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO (FunPtr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()))
instance QsetHandler (QSystemTrayIconSc a) (QSystemTrayIcon x0 -> QObject t1 -> QEvent t2 -> IO (Bool)) where
setHandler _eobj _eid _handler
= do
funptr <- wrapSetHandler_QSystemTrayIcon1 setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetHandler_QSystemTrayIcon1_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
withCWString _eid $ \cstr_eid ->
qtc_QSystemTrayIcon_setHandler1 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return()
where
setHandlerWrapper :: Ptr (TQSystemTrayIcon x0) -> Ptr (TQObject t1) -> Ptr (TQEvent t2) -> IO (CBool)
setHandlerWrapper x0 x1 x2
= do x0obj <- qSystemTrayIconFromPtr x0
x1obj <- qObjectFromPtr x1
x2obj <- objectFromPtr_nf x2
let rv =
if (objectIsNull x0obj)
then return False
else _handler x0obj x1obj x2obj
rvf <- rv
return (toCBool rvf)
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
instance QeventFilter_h (QSystemTrayIcon ()) ((QObject t1, QEvent t2)) where
eventFilter_h x0 (x1, x2)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
withObjectPtr x2 $ \cobj_x2 ->
qtc_QSystemTrayIcon_eventFilter cobj_x0 cobj_x1 cobj_x2
foreign import ccall "qtc_QSystemTrayIcon_eventFilter" qtc_QSystemTrayIcon_eventFilter :: Ptr (TQSystemTrayIcon a) -> Ptr (TQObject t1) -> Ptr (TQEvent t2) -> IO CBool
instance QeventFilter_h (QSystemTrayIconSc a) ((QObject t1, QEvent t2)) where
eventFilter_h x0 (x1, x2)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
withObjectPtr x2 $ \cobj_x2 ->
qtc_QSystemTrayIcon_eventFilter cobj_x0 cobj_x1 cobj_x2
|
keera-studios/hsQt
|
Qtc/Gui/QSystemTrayIcon_h.hs
|
Haskell
|
bsd-2-clause
| 13,411
|
module Spring13.Week4.Week4Spec where
import Test.Hspec
import Test.QuickCheck
import Spring13.Week4.Week4
main :: IO ()
main = hspec spec
spec :: Spec
spec =
do describe "fun1'" $
do it "property" $
do property $ \xs -> fun1' xs == fun1 (xs :: [Integer])
describe "fun2'" $
do it "cases" $
do fun2' 1 `shouldBe` fun2 1
fun2' 10 `shouldBe` fun2 10
fun2' 82 `shouldBe` fun2 82
fun2' 113 `shouldBe` fun2 113
describe "foldTree" $
do it "cases" $
do foldTree [] `shouldBe` (Leaf :: Tree Char)
foldTree "A" `shouldBe` Node 0 Leaf 'A' Leaf
foldTree "ABCDEFGHIJ" `shouldBe`
Node 3
(Node 2
(Node 1 (Node 0 Leaf 'D' Leaf) 'G' Leaf)
'I'
(Node 1 (Node 0 Leaf 'A' Leaf) 'E' Leaf))
'J'
(Node 2
(Node 1 (Node 0 Leaf 'B' Leaf) 'F' Leaf)
'H'
(Node 0 Leaf 'C' Leaf))
describe "foldTree'" $
do it "cases" $
do foldTree' [] `shouldBe` (Leaf :: Tree Char)
foldTree' "A" `shouldBe` Node 0 Leaf 'A' Leaf
foldTree' "ABCDEFGHIJ" `shouldBe`
Node 3
(Node 2
(Node 1 (Node 0 Leaf 'A' Leaf) 'B' Leaf)
'C'
(Node 1 (Node 0 Leaf 'D' Leaf) 'E' Leaf))
'F'
(Node 2
(Node 1 (Node 0 Leaf 'G' Leaf) 'H' Leaf)
'I'
(Node 0 Leaf 'J' Leaf))
describe "xor" $
do it "cases" $
do xor [False,True,False] `shouldBe` True
xor [False,True,False,False,True] `shouldBe` False
it "property" $
do property $
\xs ->
xor xs ==
if even (length $
filter (\x -> x)
(xs :: [Bool]))
then False
else True
|
bibaijin/cis194
|
test/Spring13/Week4/Week4Spec.hs
|
Haskell
|
bsd-3-clause
| 2,272
|
{-# LANGUAGE DataKinds #-}
module Data.SoftHeap.SHselect(shSelect) where
import Data.SoftHeap
import Control.Monad.ST
import Data.Natural
sOne=SSucc SZero
sTwo=SSucc sOne
sThree=SSucc sTwo
--returns
partition :: (Ord k) => [k] -> k -> Int
partition l x = undefined
slice :: Int -> Int -> [k] -> [k]
slice from to xs = take (to - from + 1) (drop from xs)
--TODO finish
shSelect :: (Ord k) => [k] -> Int -> k
shSelect l k
| k==1 = minimum l
| otherwise = runST $ do
h<-heapify sThree l
let third=(length l) `div` 3
x<-shSelectLoop h third
let xIndex=partition l x
if k < xIndex then return $ shSelect (slice 0 (xIndex-1) l) k else return $ shSelect (slice xIndex (k-xIndex+1) l) k
shSelectLoop :: (Ord k) => SoftHeap' s k t -> Int -> ST s k
shSelectLoop h 0=do
x<-findMin h
deleteMin h
let (Finite ret)=fst x
return ret
shSelectLoop h times=do
deleteMin' h
shSelectLoop h (times-1)
heapify' :: (Ord k) => [k] -> SoftHeap' s k t -> ST s ()
heapify' [] h=return ()
heapify' (x:xs) h=insert' h x>>heapify' xs h
heapify :: (Ord k) => SNat t -> [k] -> ST s (SoftHeap' s k (Finite t))
heapify t l=makeHeap t>>=(\h->heapify' l h>>return h)
|
formrre/soft-heap-haskell
|
soft-heap/src/Data/SoftHeap/SHselect.hs
|
Haskell
|
bsd-3-clause
| 1,213
|
{-# LANGUAGE LambdaCase, RankNTypes #-}
module Sloch
( LangToSloc
, PathToLangToSloc
, sloch
, summarize
, summarize'
) where
import Data.Map (Map)
import qualified Data.Map as M
import Data.Map.Extras (adjustWithDefault)
import Dirent (makeDirent, direntsAtDepth)
import Language (Language)
import Sloch.Dirent (SlochDirent(..), slochDirents)
type PathToLangToSloc = Map FilePath LangToSloc
type LangToSloc = Map Language [(FilePath, Int)]
sloch :: Int -> Bool -> FilePath -> IO PathToLangToSloc
sloch depth include_dotfiles path =
makeDirent include_dotfiles path >>= \case
Nothing -> return M.empty
Just dirent -> do
let dirents = direntsAtDepth depth dirent
slochDirents dirents >>= return . summarize
-- | Summarize a list of SlochDirents, where each element is summarized and put
-- into a summary map. Each element is therefore the context with which the
-- children (if they exist) shall be inserted into the map with.
summarize :: [SlochDirent] -> PathToLangToSloc
summarize = foldr step M.empty
where
step :: SlochDirent -> PathToLangToSloc -> PathToLangToSloc
step (SlochDirentFile path lang count) = M.insert path $ M.singleton lang [(path, count)]
step (SlochDirentDir path children) = M.insert path $ summarize' children
-- | Similar to summarize, but flattens a list of dirents into a single
-- LangToSloc map. No context (or "root" dirent) is associated with any of the
-- dirents in the list - they are all simply folded up uniformly.
summarize' :: [SlochDirent] -> LangToSloc
summarize' = foldr step M.empty
where
step :: SlochDirent -> LangToSloc -> LangToSloc
step (SlochDirentFile path lang count) = adjustWithDefault (x:) lang [x] where x = (path,count)
step (SlochDirentDir _ children) = M.unionWith (++) $ summarize' children
|
mitchellwrosen/Sloch
|
src/sloch/Sloch.hs
|
Haskell
|
bsd-3-clause
| 1,888
|
module Traduisons.Client where
import Control.Monad.Except
import Control.Monad.State
import qualified Data.Map as M
import Data.List
import Data.List.Split
import Traduisons.API
import Traduisons.Types
import Traduisons.Util
helpMsg :: String
helpMsg = "Help yourself."
runTest :: String -> ExceptT TraduisonsError IO (Maybe Message, AppState)
runTest input = do
let commands = concatMap parseInput $ splitOn ";" input
runCommands Nothing commands
createAppState :: ExceptT TraduisonsError IO AppState
createAppState = liftIO mkTraduisonsState >>= new
where new = return . AppState (Language "auto") (Language "en") [] M.empty
updateLanguageMap :: AppState -> ExceptT TraduisonsError IO AppState
updateLanguageMap appState = do
let tState = asTraduisonsState appState
langResponse <- lift $ runTraduisons tState getLanguagesForTranslate -- unfuck this and replace with the library I added.
langs <- M.insert "auto" "auto" <$> liftEither langResponse
return appState { asLanguageNameCodes = langs }
parseInput :: String -> [Command]
parseInput ('/':s) = SwapLanguages : parseInput s
parseInput "\EOT" = [Exit]
parseInput "?" = [Help]
parseInput "" = []
parseInput ('|':s) = [SetToLanguage s]
parseInput s
| "/" `isSuffixOf` s = SwapLanguages : parseInput (init s)
| "|" `isInfixOf` s = let (from, '|':to) = break (== '|') s
f ctor l = [ctor l | not (null l)]
in f SetFromLanguage from ++ f SetToLanguage to
| otherwise = [Translate s]
runCommands :: Maybe AppState -> [Command]
-> ExceptT TraduisonsError IO (Maybe Message, AppState)
runCommands appState cmds = do
let app = foldM (const runCommand) Nothing cmds
initial <- maybe createAppState return appState
runStateT app initial
runCommand :: Command -> StateT AppState (ExceptT TraduisonsError IO) (Maybe Message)
runCommand c = do
msg <- runCommand' c
modify (\a -> a { asHistory = (c, msg) : asHistory a })
return msg
runCommand' :: Command -> StateT AppState (ExceptT TraduisonsError IO) (Maybe Message)
runCommand' Exit = throwError $ TErr TraduisonsExit "Exit"
runCommand' Help = get >>= throwError . TErr TraduisonsHelp . renderLanguageNames
runCommand' SwapLanguages = get >>= \aS -> from aS >> to aS
where from = runCommand' . SetFromLanguage . getLanguage . asToLang
to = runCommand' . SetToLanguage . getLanguage . asFromLang
runCommand' (SetFromLanguage l) = const Nothing <$> modify setFromLang
where setFromLang appState = appState { asFromLang = Language l }
runCommand' (SetToLanguage l) = const Nothing <$> modify setToLang
where setToLang appState = appState { asToLang = Language l }
runCommand' (Translate rawMsg) = do
AppState fromLang' _ _ _ _ <- get
when (getLanguage fromLang' == "auto") $ void $ runCommand' (DetectLanguage rawMsg)
AppState fromLang toLang _ _ _ <- get
let message = Message fromLang rawMsg
withTokenRefresh $ translate toLang message
runCommand' (DetectLanguage rawMsg) = do
result <- withTokenRefresh (detectLanguage rawMsg)
case result of
Nothing -> throwError $ TErr LanguageDetectionError "Failed to detect language"
Just l -> runCommand' (SetFromLanguage (getLanguage l))
renderError :: TraduisonsError -> String
renderError (TErr flag msg) = case flag of
ArgumentOutOfRangeException -> "Bad language code: " ++ msg
LanguageDetectionError -> "Unable to detect language: " ++ msg
ArgumentException -> "Renewing expired token..."
TraduisonsHelp -> msg
e -> show e ++ ": " ++ msg
renderLanguageNames :: AppState -> String
renderLanguageNames (AppState (Language fL) (Language tL) _ m _) =
case (fName, tName) of
(Just f, Just t) -> f ++ "|" ++ t
_ -> ""
where fName = M.lookup fL m
tName = M.lookup tL m
|
bitemyapp/traduisons-hs
|
src/Traduisons/Client.hs
|
Haskell
|
bsd-3-clause
| 3,789
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.