ghc-lib-parser 9.2.3.20220527 → 9.2.3.20220709
raw patch · 6 files changed
+7983/−16845 lines, 6 files
Files
- compiler/GHC/Parser.y +4441/−0
- compiler/GHC/Parser/Lexer.x +3526/−0
- ghc-lib-parser.cabal +4/−3
- ghc-lib/stage0/compiler/build/GHC/Parser.hs +0/−13042
- ghc-lib/stage0/compiler/build/GHC/Parser/Lexer.hs +0/−3800
- ghc-lib/stage0/libraries/ghc-boot/build/GHC/Platform/Host.hs +12/−0
+ compiler/GHC/Parser.y view
@@ -0,0 +1,4441 @@+-- -*-haskell-*-+-- ---------------------------------------------------------------------------+-- (c) The University of Glasgow 1997-2003+---+-- The GHC grammar.+--+-- Author(s): Simon Marlow, Sven Panne 1997, 1998, 1999+-- ---------------------------------------------------------------------------++{+{-# LANGUAGE ViewPatterns #-}+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE LambdaCase #-}+{-# LANGUAGE RankNTypes #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE ScopedTypeVariables #-}++-- | This module provides the generated Happy parser for Haskell. It exports+-- a number of parsers which may be used in any library that uses the GHC API.+-- A common usage pattern is to initialize the parser state with a given string+-- and then parse that string:+--+-- @+-- runParser :: ParserOpts -> String -> P a -> ParseResult a+-- runParser opts str parser = unP parser parseState+-- where+-- filename = "\<interactive\>"+-- location = mkRealSrcLoc (mkFastString filename) 1 1+-- buffer = stringToStringBuffer str+-- parseState = initParserState opts buffer location+-- @+module GHC.Parser+ ( parseModule, parseSignature, parseImport, parseStatement, parseBackpack+ , parseDeclaration, parseExpression, parsePattern+ , parseTypeSignature+ , parseStmt, parseIdentifier+ , parseType, parseHeader+ , parseModuleNoHaddock+ )+where++-- base+import Control.Monad ( unless, liftM, when, (<=<) )+import GHC.Exts+import Data.Maybe ( maybeToList )+import Data.List.NonEmpty ( NonEmpty((:|)) )+import qualified Data.List.NonEmpty as NE+import qualified Prelude -- for happy-generated code++import GHC.Prelude++import GHC.Hs++import GHC.Driver.Backpack.Syntax++import GHC.Unit.Info+import GHC.Unit.Module+import GHC.Unit.Module.Warnings++import GHC.Data.OrdList+import GHC.Data.BooleanFormula ( BooleanFormula(..), LBooleanFormula, mkTrue )+import GHC.Data.FastString+import GHC.Data.Maybe ( orElse )++import GHC.Utils.Outputable+import GHC.Utils.Misc ( looksLikePackageName, fstOf3, sndOf3, thdOf3 )+import GHC.Utils.Panic+import GHC.Prelude++import GHC.Types.Name.Reader+import GHC.Types.Name.Occurrence ( varName, dataName, tcClsName, tvName, occNameFS, mkVarOcc, occNameString)+import GHC.Types.SrcLoc+import GHC.Types.Basic+import GHC.Types.Fixity+import GHC.Types.ForeignCall+import GHC.Types.SourceFile+import GHC.Types.SourceText++import GHC.Core.Type ( unrestrictedFunTyCon, Specificity(..) )+import GHC.Core.Class ( FunDep )+import GHC.Core.DataCon ( DataCon, dataConName )++import GHC.Parser.PostProcess+import GHC.Parser.PostProcess.Haddock+import GHC.Parser.Lexer+import GHC.Parser.Annotation+import GHC.Parser.Errors++import GHC.Builtin.Types ( unitTyCon, unitDataCon, tupleTyCon, tupleDataCon, nilDataCon,+ unboxedUnitTyCon, unboxedUnitDataCon,+ listTyCon_RDR, consDataCon_RDR, eqTyCon_RDR)++import qualified Data.Semigroup as Semi+}++%expect 0 -- shift/reduce conflicts++{- Note [shift/reduce conflicts]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+The 'happy' tool turns this grammar into an efficient parser that follows the+shift-reduce parsing model. There's a parse stack that contains items parsed so+far (both terminals and non-terminals). Every next token produced by the lexer+results in one of two actions:++ SHIFT: push the token onto the parse stack++ REDUCE: pop a few items off the parse stack and combine them+ with a function (reduction rule)++However, sometimes it's unclear which of the two actions to take.+Consider this code example:++ if x then y else f z++There are two ways to parse it:++ (if x then y else f) z+ if x then y else (f z)++How is this determined? At some point, the parser gets to the following state:++ parse stack: 'if' exp 'then' exp 'else' "f"+ next token: "z"++Scenario A (simplified):++ 1. REDUCE, parse stack: 'if' exp 'then' exp 'else' exp+ next token: "z"+ (Note that "f" reduced to exp here)++ 2. REDUCE, parse stack: exp+ next token: "z"++ 3. SHIFT, parse stack: exp "z"+ next token: ...++ 4. REDUCE, parse stack: exp+ next token: ...++ This way we get: (if x then y else f) z++Scenario B (simplified):++ 1. SHIFT, parse stack: 'if' exp 'then' exp 'else' "f" "z"+ next token: ...++ 2. REDUCE, parse stack: 'if' exp 'then' exp 'else' exp+ next token: ...++ 3. REDUCE, parse stack: exp+ next token: ...++ This way we get: if x then y else (f z)++The end result is determined by the chosen action. When Happy detects this, it+reports a shift/reduce conflict. At the top of the file, we have the following+directive:++ %expect 0++It means that we expect no unresolved shift/reduce conflicts in this grammar.+If you modify the grammar and get shift/reduce conflicts, follow the steps+below to resolve them.++STEP ONE+ is to figure out what causes the conflict.+ That's where the -i flag comes in handy:++ happy -agc --strict compiler/GHC/Parser.y -idetailed-info++ By analysing the output of this command, in a new file `detailed-info`, you+ can figure out which reduction rule causes the issue. At the top of the+ generated report, you will see a line like this:++ state 147 contains 67 shift/reduce conflicts.++ Scroll down to section State 147 (in your case it could be a different+ state). The start of the section lists the reduction rules that can fire+ and shows their context:++ exp10 -> fexp . (rule 492)+ fexp -> fexp . aexp (rule 498)+ fexp -> fexp . PREFIX_AT atype (rule 499)++ And then, for every token, it tells you the parsing action:++ ']' reduce using rule 492+ '::' reduce using rule 492+ '(' shift, and enter state 178+ QVARID shift, and enter state 44+ DO shift, and enter state 182+ ...++ But if you look closer, some of these tokens also have another parsing action+ in parentheses:++ QVARID shift, and enter state 44+ (reduce using rule 492)++ That's how you know rule 492 is causing trouble.+ Scroll back to the top to see what this rule is:++ ----------------------------------+ Grammar+ ----------------------------------+ ...+ ...+ exp10 -> fexp (492)+ optSemi -> ';' (493)+ ...+ ...++ Hence the shift/reduce conflict is caused by this parser production:++ exp10 :: { ECP }+ : '-' fexp { ... }+ | fexp { ... } -- problematic rule++STEP TWO+ is to mark the problematic rule with the %shift pragma. This signals to+ 'happy' that any shift/reduce conflicts involving this rule must be resolved+ in favor of a shift. There's currently no dedicated pragma to resolve in+ favor of the reduce.++STEP THREE+ is to add a dedicated Note for this specific conflict, as is done for all+ other conflicts below.+-}++{- Note [%shift: rule_activation -> {- empty -}]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Context:+ rule -> STRING . rule_activation rule_foralls infixexp '=' exp++Example:+ {-# RULES "name" [0] f = rhs #-}++Ambiguity:+ If we reduced, then we'd get an empty activation rule, and [0] would be+ parsed as part of the left-hand side expression.++ We shift, so [0] is parsed as an activation rule.+-}++{- Note [%shift: rule_foralls -> 'forall' rule_vars '.']+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Context:+ rule_foralls -> 'forall' rule_vars '.' . 'forall' rule_vars '.'+ rule_foralls -> 'forall' rule_vars '.' .++Example:+ {-# RULES "name" forall a1. forall a2. lhs = rhs #-}++Ambiguity:+ Same as in Note [%shift: rule_foralls -> {- empty -}]+ but for the second 'forall'.+-}++{- Note [%shift: rule_foralls -> {- empty -}]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Context:+ rule -> STRING rule_activation . rule_foralls infixexp '=' exp++Example:+ {-# RULES "name" forall a1. lhs = rhs #-}++Ambiguity:+ If we reduced, then we would get an empty rule_foralls; the 'forall', being+ a valid term-level identifier, would be parsed as part of the left-hand+ side expression.++ We shift, so the 'forall' is parsed as part of rule_foralls.+-}++{- Note [%shift: type -> btype]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Context:+ context -> btype .+ type -> btype .+ type -> btype . '->' ctype+ type -> btype . '->.' ctype++Example:+ a :: Maybe Integer -> Bool++Ambiguity:+ If we reduced, we would get: (a :: Maybe Integer) -> Bool+ We shift to get this instead: a :: (Maybe Integer -> Bool)+-}++{- Note [%shift: infixtype -> ftype]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Context:+ infixtype -> ftype .+ infixtype -> ftype . tyop infixtype+ ftype -> ftype . tyarg+ ftype -> ftype . PREFIX_AT tyarg++Example:+ a :: Maybe Integer++Ambiguity:+ If we reduced, we would get: (a :: Maybe) Integer+ We shift to get this instead: a :: (Maybe Integer)+-}++{- Note [%shift: atype -> tyvar]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Context:+ atype -> tyvar .+ tv_bndr_no_braces -> '(' tyvar . '::' kind ')'++Example:+ class C a where type D a = (a :: Type ...++Ambiguity:+ If we reduced, we could specify a default for an associated type like this:++ class C a where type D a+ type D a = (a :: Type)++ But we shift in order to allow injectivity signatures like this:++ class C a where type D a = (r :: Type) | r -> a+-}++{- Note [%shift: exp -> infixexp]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Context:+ exp -> infixexp . '::' sigtype+ exp -> infixexp . '-<' exp+ exp -> infixexp . '>-' exp+ exp -> infixexp . '-<<' exp+ exp -> infixexp . '>>-' exp+ exp -> infixexp .+ infixexp -> infixexp . qop exp10p++Examples:+ 1) if x then y else z -< e+ 2) if x then y else z :: T+ 3) if x then y else z + 1 -- (NB: '+' is in VARSYM)++Ambiguity:+ If we reduced, we would get:++ 1) (if x then y else z) -< e+ 2) (if x then y else z) :: T+ 3) (if x then y else z) + 1++ We shift to get this instead:++ 1) if x then y else (z -< e)+ 2) if x then y else (z :: T)+ 3) if x then y else (z + 1)+-}++{- Note [%shift: exp10 -> '-' fexp]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Context:+ exp10 -> '-' fexp .+ fexp -> fexp . aexp+ fexp -> fexp . PREFIX_AT atype++Examples & Ambiguity:+ Same as in Note [%shift: exp10 -> fexp],+ but with a '-' in front.+-}++{- Note [%shift: exp10 -> fexp]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Context:+ exp10 -> fexp .+ fexp -> fexp . aexp+ fexp -> fexp . PREFIX_AT atype++Examples:+ 1) if x then y else f z+ 2) if x then y else f @z++Ambiguity:+ If we reduced, we would get:++ 1) (if x then y else f) z+ 2) (if x then y else f) @z++ We shift to get this instead:++ 1) if x then y else (f z)+ 2) if x then y else (f @z)+-}++{- Note [%shift: aexp2 -> ipvar]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Context:+ aexp2 -> ipvar .+ dbind -> ipvar . '=' exp++Example:+ let ?x = ...++Ambiguity:+ If we reduced, ?x would be parsed as the LHS of a normal binding,+ eventually producing an error.++ We shift, so it is parsed as the LHS of an implicit binding.+-}++{- Note [%shift: aexp2 -> TH_TY_QUOTE]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Context:+ aexp2 -> TH_TY_QUOTE . tyvar+ aexp2 -> TH_TY_QUOTE . gtycon+ aexp2 -> TH_TY_QUOTE .++Examples:+ 1) x = ''+ 2) x = ''a+ 3) x = ''T++Ambiguity:+ If we reduced, the '' would result in reportEmptyDoubleQuotes even when+ followed by a type variable or a type constructor. But the only reason+ this reduction rule exists is to improve error messages.++ Naturally, we shift instead, so that ''a and ''T work as expected.+-}++{- Note [%shift: tup_tail -> {- empty -}]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Context:+ tup_exprs -> commas . tup_tail+ sysdcon_nolist -> '(' commas . ')'+ sysdcon_nolist -> '(#' commas . '#)'+ commas -> commas . ','++Example:+ (,,)++Ambiguity:+ A tuple section with no components is indistinguishable from the Haskell98+ data constructor for a tuple.++ If we reduced, (,,) would be parsed as a tuple section.+ We shift, so (,,) is parsed as a data constructor.++ This is preferable because we want to accept (,,) without -XTupleSections.+ See also Note [ExplicitTuple] in GHC.Hs.Expr.+-}++{- Note [%shift: qtyconop -> qtyconsym]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Context:+ oqtycon -> '(' qtyconsym . ')'+ qtyconop -> qtyconsym .++Example:+ foo :: (:%)++Ambiguity:+ If we reduced, (:%) would be parsed as a parenthehsized infix type+ expression without arguments, resulting in the 'failOpFewArgs' error.++ We shift, so it is parsed as a type constructor.+-}++{- Note [%shift: special_id -> 'group']+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Context:+ transformqual -> 'then' 'group' . 'using' exp+ transformqual -> 'then' 'group' . 'by' exp 'using' exp+ special_id -> 'group' .++Example:+ [ ... | then group by dept using groupWith+ , then take 5 ]++Ambiguity:+ If we reduced, 'group' would be parsed as a term-level identifier, just as+ 'take' in the other clause.++ We shift, so it is parsed as part of the 'group by' clause introduced by+ the -XTransformListComp extension.+-}++{- Note [%shift: activation -> {- empty -}]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Context:+ sigdecl -> '{-# INLINE' . activation qvarcon '#-}'+ activation -> {- empty -}+ activation -> explicit_activation++Example:++ {-# INLINE [0] Something #-}++Ambiguity:+ We don't know whether the '[' is the start of the activation or the beginning+ of the [] data constructor.+ We parse this as having '[0]' activation for inlining 'Something', rather than+ empty activation and inlining '[0] Something'.+-}++{- Note [Parser API Annotations]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+A lot of the productions are now cluttered with calls to+aa,am,acs,acsA etc.++These are helper functions to make sure that the locations of the+various keywords such as do / let / in are captured for use by tools+that want to do source to source conversions, such as refactorers or+structured editors.++The helper functions are defined at the bottom of this file.++See+ https://gitlab.haskell.org/ghc/ghc/wikis/api-annotations and+ https://gitlab.haskell.org/ghc/ghc/wikis/ghc-ast-annotations+for some background.++-}++{- Note [Parsing lists]+~~~~~~~~~~~~~~~~~~~~~~~+You might be wondering why we spend so much effort encoding our lists this+way:++importdecls+ : importdecls ';' importdecl+ | importdecls ';'+ | importdecl+ | {- empty -}++This might seem like an awfully roundabout way to declare a list; plus, to add+insult to injury you have to reverse the results at the end. The answer is that+left recursion prevents us from running out of stack space when parsing long+sequences. See: https://www.haskell.org/happy/doc/html/sec-sequences.html for+more guidance.++By adding/removing branches, you can affect what lists are accepted. Here+are the most common patterns, rewritten as regular expressions for clarity:++ -- Equivalent to: ';'* (x ';'+)* x? (can be empty, permits leading/trailing semis)+ xs : xs ';' x+ | xs ';'+ | x+ | {- empty -}++ -- Equivalent to x (';' x)* ';'* (non-empty, permits trailing semis)+ xs : xs ';' x+ | xs ';'+ | x++ -- Equivalent to ';'* alts (';' alts)* ';'* (non-empty, permits leading/trailing semis)+ alts : alts1+ | ';' alts+ alts1 : alts1 ';' alt+ | alts1 ';'+ | alt++ -- Equivalent to x (',' x)+ (non-empty, no trailing semis)+ xs : x+ | x ',' xs+-}++%token+ '_' { L _ ITunderscore } -- Haskell keywords+ 'as' { L _ ITas }+ 'case' { L _ ITcase }+ 'class' { L _ ITclass }+ 'data' { L _ ITdata }+ 'default' { L _ ITdefault }+ 'deriving' { L _ ITderiving }+ 'else' { L _ ITelse }+ 'hiding' { L _ IThiding }+ 'if' { L _ ITif }+ 'import' { L _ ITimport }+ 'in' { L _ ITin }+ 'infix' { L _ ITinfix }+ 'infixl' { L _ ITinfixl }+ 'infixr' { L _ ITinfixr }+ 'instance' { L _ ITinstance }+ 'let' { L _ ITlet }+ 'module' { L _ ITmodule }+ 'newtype' { L _ ITnewtype }+ 'of' { L _ ITof }+ 'qualified' { L _ ITqualified }+ 'then' { L _ ITthen }+ 'type' { L _ ITtype }+ 'where' { L _ ITwhere }++ 'forall' { L _ (ITforall _) } -- GHC extension keywords+ 'foreign' { L _ ITforeign }+ 'export' { L _ ITexport }+ 'label' { L _ ITlabel }+ 'dynamic' { L _ ITdynamic }+ 'safe' { L _ ITsafe }+ 'interruptible' { L _ ITinterruptible }+ 'unsafe' { L _ ITunsafe }+ 'family' { L _ ITfamily }+ 'role' { L _ ITrole }+ 'stdcall' { L _ ITstdcallconv }+ 'ccall' { L _ ITccallconv }+ 'capi' { L _ ITcapiconv }+ 'prim' { L _ ITprimcallconv }+ 'javascript' { L _ ITjavascriptcallconv }+ 'proc' { L _ ITproc } -- for arrow notation extension+ 'rec' { L _ ITrec } -- for arrow notation extension+ 'group' { L _ ITgroup } -- for list transform extension+ 'by' { L _ ITby } -- for list transform extension+ 'using' { L _ ITusing } -- for list transform extension+ 'pattern' { L _ ITpattern } -- for pattern synonyms+ 'static' { L _ ITstatic } -- for static pointers extension+ 'stock' { L _ ITstock } -- for DerivingStrategies extension+ 'anyclass' { L _ ITanyclass } -- for DerivingStrategies extension+ 'via' { L _ ITvia } -- for DerivingStrategies extension++ 'unit' { L _ ITunit }+ 'signature' { L _ ITsignature }+ 'dependency' { L _ ITdependency }++ '{-# INLINE' { L _ (ITinline_prag _ _ _) } -- INLINE or INLINABLE+ '{-# SPECIALISE' { L _ (ITspec_prag _) }+ '{-# SPECIALISE_INLINE' { L _ (ITspec_inline_prag _ _) }+ '{-# SOURCE' { L _ (ITsource_prag _) }+ '{-# RULES' { L _ (ITrules_prag _) }+ '{-# SCC' { L _ (ITscc_prag _)}+ '{-# DEPRECATED' { L _ (ITdeprecated_prag _) }+ '{-# WARNING' { L _ (ITwarning_prag _) }+ '{-# UNPACK' { L _ (ITunpack_prag _) }+ '{-# NOUNPACK' { L _ (ITnounpack_prag _) }+ '{-# ANN' { L _ (ITann_prag _) }+ '{-# MINIMAL' { L _ (ITminimal_prag _) }+ '{-# CTYPE' { L _ (ITctype _) }+ '{-# OVERLAPPING' { L _ (IToverlapping_prag _) }+ '{-# OVERLAPPABLE' { L _ (IToverlappable_prag _) }+ '{-# OVERLAPS' { L _ (IToverlaps_prag _) }+ '{-# INCOHERENT' { L _ (ITincoherent_prag _) }+ '{-# COMPLETE' { L _ (ITcomplete_prag _) }+ '#-}' { L _ ITclose_prag }++ '..' { L _ ITdotdot } -- reserved symbols+ ':' { L _ ITcolon }+ '::' { L _ (ITdcolon _) }+ '=' { L _ ITequal }+ '\\' { L _ ITlam }+ 'lcase' { L _ ITlcase }+ '|' { L _ ITvbar }+ '<-' { L _ (ITlarrow _) }+ '->' { L _ (ITrarrow _) }+ '->.' { L _ ITlolly }+ TIGHT_INFIX_AT { L _ ITat }+ '=>' { L _ (ITdarrow _) }+ '-' { L _ ITminus }+ PREFIX_TILDE { L _ ITtilde }+ PREFIX_BANG { L _ ITbang }+ PREFIX_MINUS { L _ ITprefixminus }+ '*' { L _ (ITstar _) }+ '-<' { L _ (ITlarrowtail _) } -- for arrow notation+ '>-' { L _ (ITrarrowtail _) } -- for arrow notation+ '-<<' { L _ (ITLarrowtail _) } -- for arrow notation+ '>>-' { L _ (ITRarrowtail _) } -- for arrow notation+ '.' { L _ ITdot }+ PREFIX_PROJ { L _ (ITproj True) } -- RecordDotSyntax+ TIGHT_INFIX_PROJ { L _ (ITproj False) } -- RecordDotSyntax+ PREFIX_AT { L _ ITtypeApp }+ PREFIX_PERCENT { L _ ITpercent } -- for linear types++ '{' { L _ ITocurly } -- special symbols+ '}' { L _ ITccurly }+ vocurly { L _ ITvocurly } -- virtual open curly (from layout)+ vccurly { L _ ITvccurly } -- virtual close curly (from layout)+ '[' { L _ ITobrack }+ ']' { L _ ITcbrack }+ '(' { L _ IToparen }+ ')' { L _ ITcparen }+ '(#' { L _ IToubxparen }+ '#)' { L _ ITcubxparen }+ '(|' { L _ (IToparenbar _) }+ '|)' { L _ (ITcparenbar _) }+ ';' { L _ ITsemi }+ ',' { L _ ITcomma }+ '`' { L _ ITbackquote }+ SIMPLEQUOTE { L _ ITsimpleQuote } -- 'x++ VARID { L _ (ITvarid _) } -- identifiers+ CONID { L _ (ITconid _) }+ VARSYM { L _ (ITvarsym _) }+ CONSYM { L _ (ITconsym _) }+ QVARID { L _ (ITqvarid _) }+ QCONID { L _ (ITqconid _) }+ QVARSYM { L _ (ITqvarsym _) }+ QCONSYM { L _ (ITqconsym _) }+++ -- QualifiedDo+ DO { L _ (ITdo _) }+ MDO { L _ (ITmdo _) }++ IPDUPVARID { L _ (ITdupipvarid _) } -- GHC extension+ LABELVARID { L _ (ITlabelvarid _) }++ CHAR { L _ (ITchar _ _) }+ STRING { L _ (ITstring _ _) }+ INTEGER { L _ (ITinteger _) }+ RATIONAL { L _ (ITrational _) }++ PRIMCHAR { L _ (ITprimchar _ _) }+ PRIMSTRING { L _ (ITprimstring _ _) }+ PRIMINTEGER { L _ (ITprimint _ _) }+ PRIMWORD { L _ (ITprimword _ _) }+ PRIMFLOAT { L _ (ITprimfloat _) }+ PRIMDOUBLE { L _ (ITprimdouble _) }++-- Template Haskell+'[|' { L _ (ITopenExpQuote _ _) }+'[p|' { L _ ITopenPatQuote }+'[t|' { L _ ITopenTypQuote }+'[d|' { L _ ITopenDecQuote }+'|]' { L _ (ITcloseQuote _) }+'[||' { L _ (ITopenTExpQuote _) }+'||]' { L _ ITcloseTExpQuote }+PREFIX_DOLLAR { L _ ITdollar }+PREFIX_DOLLAR_DOLLAR { L _ ITdollardollar }+TH_TY_QUOTE { L _ ITtyQuote } -- ''T+TH_QUASIQUOTE { L _ (ITquasiQuote _) }+TH_QQUASIQUOTE { L _ (ITqQuasiQuote _) }++%monad { P } { >>= } { return }+%lexer { (lexer True) } { L _ ITeof }+ -- Replace 'lexer' above with 'lexerDbg'+ -- to dump the tokens fed to the parser.+%tokentype { (Located Token) }++-- Exported parsers+%name parseModuleNoHaddock module+%name parseSignature signature+%name parseImport importdecl+%name parseStatement e_stmt+%name parseDeclaration topdecl+%name parseExpression exp+%name parsePattern pat+%name parseTypeSignature sigdecl+%name parseStmt maybe_stmt+%name parseIdentifier identifier+%name parseType ktype+%name parseBackpack backpack+%partial parseHeader header+%%++-----------------------------------------------------------------------------+-- Identifiers; one of the entry points+identifier :: { LocatedN RdrName }+ : qvar { $1 }+ | qcon { $1 }+ | qvarop { $1 }+ | qconop { $1 }+ | '(' '->' ')' {% amsrn (sLL $1 $> $ getRdrName unrestrictedFunTyCon)+ (NameAnn NameParens (glAA $1) (glAA $2) (glAA $3) []) }+ | '->' {% amsrn (sLL $1 $> $ getRdrName unrestrictedFunTyCon)+ (NameAnnRArrow (glAA $1) []) }++-----------------------------------------------------------------------------+-- Backpack stuff++backpack :: { [LHsUnit PackageName] }+ : implicit_top units close { fromOL $2 }+ | '{' units '}' { fromOL $2 }++units :: { OrdList (LHsUnit PackageName) }+ : units ';' unit { $1 `appOL` unitOL $3 }+ | units ';' { $1 }+ | unit { unitOL $1 }++unit :: { LHsUnit PackageName }+ : 'unit' pkgname 'where' unitbody+ { sL1 $1 $ HsUnit { hsunitName = $2+ , hsunitBody = fromOL $4 } }++unitid :: { LHsUnitId PackageName }+ : pkgname { sL1 $1 $ HsUnitId $1 [] }+ | pkgname '[' msubsts ']' { sLL $1 $> $ HsUnitId $1 (fromOL $3) }++msubsts :: { OrdList (LHsModuleSubst PackageName) }+ : msubsts ',' msubst { $1 `appOL` unitOL $3 }+ | msubsts ',' { $1 }+ | msubst { unitOL $1 }++msubst :: { LHsModuleSubst PackageName }+ : modid '=' moduleid { sLL (reLoc $1) $> $ (reLoc $1, $3) }+ | modid VARSYM modid VARSYM { sLL (reLoc $1) $> $ (reLoc $1, sLL $2 $> $ HsModuleVar (reLoc $3)) }++moduleid :: { LHsModuleId PackageName }+ : VARSYM modid VARSYM { sLL $1 $> $ HsModuleVar (reLoc $2) }+ | unitid ':' modid { sLL $1 (reLoc $>) $ HsModuleId $1 (reLoc $3) }++pkgname :: { Located PackageName }+ : STRING { sL1 $1 $ PackageName (getSTRING $1) }+ | litpkgname { sL1 $1 $ PackageName (unLoc $1) }++litpkgname_segment :: { Located FastString }+ : VARID { sL1 $1 $ getVARID $1 }+ | CONID { sL1 $1 $ getCONID $1 }+ | special_id { $1 }++-- Parse a minus sign regardless of whether -XLexicalNegation is turned on or off.+-- See Note [Minus tokens] in GHC.Parser.Lexer+HYPHEN :: { [AddEpAnn] }+ : '-' { [mj AnnMinus $1 ] }+ | PREFIX_MINUS { [mj AnnMinus $1 ] }+ | VARSYM {% if (getVARSYM $1 == fsLit "-")+ then return [mj AnnMinus $1]+ else do { addError $ PsError PsErrExpectedHyphen [] (getLoc $1)+ ; return [] } }+++litpkgname :: { Located FastString }+ : litpkgname_segment { $1 }+ -- a bit of a hack, means p - b is parsed same as p-b, enough for now.+ | litpkgname_segment HYPHEN litpkgname { sLL $1 $> $ appendFS (unLoc $1) (consFS '-' (unLoc $3)) }++mayberns :: { Maybe [LRenaming] }+ : {- empty -} { Nothing }+ | '(' rns ')' { Just (fromOL $2) }++rns :: { OrdList LRenaming }+ : rns ',' rn { $1 `appOL` unitOL $3 }+ | rns ',' { $1 }+ | rn { unitOL $1 }++rn :: { LRenaming }+ : modid 'as' modid { sLL (reLoc $1) (reLoc $>) $ Renaming (reLoc $1) (Just (reLoc $3)) }+ | modid { sL1 (reLoc $1) $ Renaming (reLoc $1) Nothing }++unitbody :: { OrdList (LHsUnitDecl PackageName) }+ : '{' unitdecls '}' { $2 }+ | vocurly unitdecls close { $2 }++unitdecls :: { OrdList (LHsUnitDecl PackageName) }+ : unitdecls ';' unitdecl { $1 `appOL` unitOL $3 }+ | unitdecls ';' { $1 }+ | unitdecl { unitOL $1 }++unitdecl :: { LHsUnitDecl PackageName }+ : 'module' maybe_src modid maybemodwarning maybeexports 'where' body+ -- XXX not accurate+ { sL1 $1 $ DeclD+ (case snd $2 of+ NotBoot -> HsSrcFile+ IsBoot -> HsBootFile)+ (reLoc $3)+ (Just $ sL1 $1 (HsModule noAnn (thdOf3 $7) (Just $3) $5 (fst $ sndOf3 $7) (snd $ sndOf3 $7) $4 Nothing)) }+ | 'signature' modid maybemodwarning maybeexports 'where' body+ { sL1 $1 $ DeclD+ HsigFile+ (reLoc $2)+ (Just $ sL1 $1 (HsModule noAnn (thdOf3 $6) (Just $2) $4 (fst $ sndOf3 $6) (snd $ sndOf3 $6) $3 Nothing)) }+ | 'module' maybe_src modid+ { sL1 $1 $ DeclD (case snd $2 of+ NotBoot -> HsSrcFile+ IsBoot -> HsBootFile) (reLoc $3) Nothing }+ | 'signature' modid+ { sL1 $1 $ DeclD HsigFile (reLoc $2) Nothing }+ | 'dependency' unitid mayberns+ { sL1 $1 $ IncludeD (IncludeDecl { idUnitId = $2+ , idModRenaming = $3+ , idSignatureInclude = False }) }+ | 'dependency' 'signature' unitid+ { sL1 $1 $ IncludeD (IncludeDecl { idUnitId = $3+ , idModRenaming = Nothing+ , idSignatureInclude = True }) }++-----------------------------------------------------------------------------+-- Module Header++-- The place for module deprecation is really too restrictive, but if it+-- was allowed at its natural place just before 'module', we get an ugly+-- s/r conflict with the second alternative. Another solution would be the+-- introduction of a new pragma DEPRECATED_MODULE, but this is not very nice,+-- either, and DEPRECATED is only expected to be used by people who really+-- know what they are doing. :-)++signature :: { Located HsModule }+ : 'signature' modid maybemodwarning maybeexports 'where' body+ {% fileSrcSpan >>= \ loc ->+ acs (\cs-> (L loc (HsModule (EpAnn (spanAsAnchor loc) (AnnsModule [mj AnnSignature $1, mj AnnWhere $5] (fstOf3 $6)) cs)+ (thdOf3 $6) (Just $2) $4 (fst $ sndOf3 $6)+ (snd $ sndOf3 $6) $3 Nothing))+ ) }++module :: { Located HsModule }+ : 'module' modid maybemodwarning maybeexports 'where' body+ {% fileSrcSpan >>= \ loc ->+ acsFinal (\cs -> (L loc (HsModule (EpAnn (spanAsAnchor loc) (AnnsModule [mj AnnModule $1, mj AnnWhere $5] (fstOf3 $6)) cs)+ (thdOf3 $6) (Just $2) $4 (fst $ sndOf3 $6)+ (snd $ sndOf3 $6) $3 Nothing)+ )) }+ | body2+ {% fileSrcSpan >>= \ loc ->+ acsFinal (\cs -> (L loc (HsModule (EpAnn (spanAsAnchor loc) (AnnsModule [] (fstOf3 $1)) cs)+ (thdOf3 $1) Nothing Nothing+ (fst $ sndOf3 $1) (snd $ sndOf3 $1) Nothing Nothing))) }++missing_module_keyword :: { () }+ : {- empty -} {% pushModuleContext }++implicit_top :: { () }+ : {- empty -} {% pushModuleContext }++maybemodwarning :: { Maybe (LocatedP WarningTxt) }+ : '{-# DEPRECATED' strings '#-}'+ {% fmap Just $ amsrp (sLL $1 $> $ DeprecatedTxt (sL1 $1 $ getDEPRECATED_PRAGs $1) (snd $ unLoc $2))+ (AnnPragma (mo $1) (mc $3) (fst $ unLoc $2)) }+ | '{-# WARNING' strings '#-}'+ {% fmap Just $ amsrp (sLL $1 $> $ WarningTxt (sL1 $1 $ getWARNING_PRAGs $1) (snd $ unLoc $2))+ (AnnPragma (mo $1) (mc $3) (fst $ unLoc $2))}+ | {- empty -} { Nothing }++body :: { (AnnList+ ,([LImportDecl GhcPs], [LHsDecl GhcPs])+ ,LayoutInfo) }+ : '{' top '}' { (AnnList Nothing (Just $ moc $1) (Just $ mcc $3) [] (fst $2)+ , snd $2, ExplicitBraces) }+ | vocurly top close { (AnnList Nothing Nothing Nothing [] (fst $2)+ , snd $2, VirtualBraces (getVOCURLY $1)) }++body2 :: { (AnnList+ ,([LImportDecl GhcPs], [LHsDecl GhcPs])+ ,LayoutInfo) }+ : '{' top '}' { (AnnList Nothing (Just $ moc $1) (Just $ mcc $3) [] (fst $2)+ , snd $2, ExplicitBraces) }+ | missing_module_keyword top close { (AnnList Nothing Nothing Nothing [] [], snd $2, VirtualBraces leftmostColumn) }+++top :: { ([TrailingAnn]+ ,([LImportDecl GhcPs], [LHsDecl GhcPs])) }+ : semis top1 { (reverse $1, $2) }++top1 :: { ([LImportDecl GhcPs], [LHsDecl GhcPs]) }+ : importdecls_semi topdecls_cs_semi { (reverse $1, cvTopDecls $2) }+ | importdecls_semi topdecls_cs { (reverse $1, cvTopDecls $2) }+ | importdecls { (reverse $1, []) }++-----------------------------------------------------------------------------+-- Module declaration & imports only++header :: { Located HsModule }+ : 'module' modid maybemodwarning maybeexports 'where' header_body+ {% fileSrcSpan >>= \ loc ->+ acs (\cs -> (L loc (HsModule (EpAnn (spanAsAnchor loc) (AnnsModule [mj AnnModule $1,mj AnnWhere $5] (AnnList Nothing Nothing Nothing [] [])) cs)+ NoLayoutInfo (Just $2) $4 $6 [] $3 Nothing+ ))) }+ | 'signature' modid maybemodwarning maybeexports 'where' header_body+ {% fileSrcSpan >>= \ loc ->+ acs (\cs -> (L loc (HsModule (EpAnn (spanAsAnchor loc) (AnnsModule [mj AnnModule $1,mj AnnWhere $5] (AnnList Nothing Nothing Nothing [] [])) cs)+ NoLayoutInfo (Just $2) $4 $6 [] $3 Nothing+ ))) }+ | header_body2+ {% fileSrcSpan >>= \ loc ->+ return (L loc (HsModule noAnn NoLayoutInfo Nothing Nothing $1 [] Nothing+ Nothing)) }++header_body :: { [LImportDecl GhcPs] }+ : '{' header_top { $2 }+ | vocurly header_top { $2 }++header_body2 :: { [LImportDecl GhcPs] }+ : '{' header_top { $2 }+ | missing_module_keyword header_top { $2 }++header_top :: { [LImportDecl GhcPs] }+ : semis header_top_importdecls { $2 }++header_top_importdecls :: { [LImportDecl GhcPs] }+ : importdecls_semi { $1 }+ | importdecls { $1 }++-----------------------------------------------------------------------------+-- The Export List++maybeexports :: { (Maybe (LocatedL [LIE GhcPs])) }+ : '(' exportlist ')' {% fmap Just $ amsrl (sLL $1 $> (fromOL $ snd $2))+ (AnnList Nothing (Just $ mop $1) (Just $ mcp $3) (fst $2) []) }+ | {- empty -} { Nothing }++exportlist :: { ([AddEpAnn], OrdList (LIE GhcPs)) }+ : exportlist1 { ([], $1) }+ | {- empty -} { ([], nilOL) }++ -- trailing comma:+ | exportlist1 ',' {% case $1 of+ SnocOL hs t -> do+ t' <- addTrailingCommaA t (gl $2)+ return ([], snocOL hs t')}+ | ',' { ([mj AnnComma $1], nilOL) }++exportlist1 :: { OrdList (LIE GhcPs) }+ : exportlist1 ',' export+ {% let ls = $1+ in if isNilOL ls+ then return (ls `appOL` $3)+ else case ls of+ SnocOL hs t -> do+ t' <- addTrailingCommaA t (gl $2)+ return (snocOL hs t' `appOL` $3)}+ | export { $1 }+++ -- No longer allow things like [] and (,,,) to be exported+ -- They are built in syntax, always available+export :: { OrdList (LIE GhcPs) }+ : qcname_ext export_subspec {% mkModuleImpExp (fst $ unLoc $2) $1 (snd $ unLoc $2)+ >>= \ie -> fmap (unitOL . reLocA) (return (sLL (reLoc $1) $> ie)) }+ | 'module' modid {% fmap (unitOL . reLocA) (acs (\cs -> sLL $1 (reLoc $>) (IEModuleContents (EpAnn (glR $1) [mj AnnModule $1] cs) $2))) }+ | 'pattern' qcon { unitOL (reLocA (sLL $1 (reLocN $>)+ (IEVar noExtField (sLLa $1 (reLocN $>) (IEPattern (glAA $1) $2))))) }++export_subspec :: { Located ([AddEpAnn],ImpExpSubSpec) }+ : {- empty -} { sL0 ([],ImpExpAbs) }+ | '(' qcnames ')' {% mkImpExpSubSpec (reverse (snd $2))+ >>= \(as,ie) -> return $ sLL $1 $>+ (as ++ [mop $1,mcp $3] ++ fst $2, ie) }++qcnames :: { ([AddEpAnn], [LocatedA ImpExpQcSpec]) }+ : {- empty -} { ([],[]) }+ | qcnames1 { $1 }++qcnames1 :: { ([AddEpAnn], [LocatedA ImpExpQcSpec]) } -- A reversed list+ : qcnames1 ',' qcname_ext_w_wildcard {% case (snd $1) of+ (l@(L la ImpExpQcWildcard):t) ->+ do { l' <- addTrailingCommaA l (gl $2)+ ; return ([mj AnnDotdot (reLoc l),+ mj AnnComma $2]+ ,(snd (unLoc $3) : l' : t)) }+ (l:t) ->+ do { l' <- addTrailingCommaA l (gl $2)+ ; return (fst $1 ++ fst (unLoc $3)+ , snd (unLoc $3) : l' : t)} }++ -- Annotations re-added in mkImpExpSubSpec+ | qcname_ext_w_wildcard { (fst (unLoc $1),[snd (unLoc $1)]) }++-- Variable, data constructor or wildcard+-- or tagged type constructor+qcname_ext_w_wildcard :: { Located ([AddEpAnn], LocatedA ImpExpQcSpec) }+ : qcname_ext { sL1A $1 ([],$1) }+ | '..' { sL1 $1 ([mj AnnDotdot $1], sL1a $1 ImpExpQcWildcard) }++qcname_ext :: { LocatedA ImpExpQcSpec }+ : qcname { reLocA $ sL1N $1 (ImpExpQcName $1) }+ | 'type' oqtycon {% do { n <- mkTypeImpExp $2+ ; return $ sLLa $1 (reLocN $>) (ImpExpQcType (glAA $1) n) }}++qcname :: { LocatedN RdrName } -- Variable or type constructor+ : qvar { $1 } -- Things which look like functions+ -- Note: This includes record selectors but+ -- also (-.->), see #11432+ | oqtycon_no_varcon { $1 } -- see Note [Type constructors in export list]++-----------------------------------------------------------------------------+-- Import Declarations++-- importdecls and topdecls must contain at least one declaration;+-- top handles the fact that these may be optional.++-- One or more semicolons+semis1 :: { Located [TrailingAnn] }+semis1 : semis1 ';' { sLL $1 $> $ if isZeroWidthSpan (gl $2) then (unLoc $1) else (AddSemiAnn (glAA $2) : (unLoc $1)) }+ | ';' { sL1 $1 $ msemi $1 }++-- Zero or more semicolons+semis :: { [TrailingAnn] }+semis : semis ';' { if isZeroWidthSpan (gl $2) then $1 else (AddSemiAnn (glAA $2) : $1) }+ | {- empty -} { [] }++-- No trailing semicolons, non-empty+importdecls :: { [LImportDecl GhcPs] }+importdecls+ : importdecls_semi importdecl+ { $2 : $1 }++-- May have trailing semicolons, can be empty+importdecls_semi :: { [LImportDecl GhcPs] }+importdecls_semi+ : importdecls_semi importdecl semis1+ {% do { i <- amsAl $2 (comb2 (reLoc $2) $3) (reverse $ unLoc $3)+ ; return (i : $1)} }+ | {- empty -} { [] }++importdecl :: { LImportDecl GhcPs }+ : 'import' maybe_src maybe_safe optqualified maybe_pkg modid optqualified maybeas maybeimpspec+ {% do {+ ; let { ; mPreQual = unLoc $4+ ; mPostQual = unLoc $7 }+ ; checkImportDecl mPreQual mPostQual+ ; let anns+ = EpAnnImportDecl+ { importDeclAnnImport = glAA $1+ , importDeclAnnPragma = fst $ fst $2+ , importDeclAnnSafe = fst $3+ , importDeclAnnQualified = fst $ importDeclQualifiedStyle mPreQual mPostQual+ , importDeclAnnPackage = fst $5+ , importDeclAnnAs = fst $8+ }+ ; fmap reLocA $ acs (\cs -> L (comb5 $1 (reLoc $6) $7 (snd $8) $9) $+ ImportDecl { ideclExt = EpAnn (glR $1) anns cs+ , ideclSourceSrc = snd $ fst $2+ , ideclName = $6, ideclPkgQual = snd $5+ , ideclSource = snd $2, ideclSafe = snd $3+ , ideclQualified = snd $ importDeclQualifiedStyle mPreQual mPostQual+ , ideclImplicit = False+ , ideclAs = unLoc (snd $8)+ , ideclHiding = unLoc $9 })+ }+ }+++maybe_src :: { ((Maybe (EpaLocation,EpaLocation),SourceText),IsBootInterface) }+ : '{-# SOURCE' '#-}' { ((Just (glAA $1,glAA $2),getSOURCE_PRAGs $1)+ , IsBoot) }+ | {- empty -} { ((Nothing,NoSourceText),NotBoot) }++maybe_safe :: { (Maybe EpaLocation,Bool) }+ : 'safe' { (Just (glAA $1),True) }+ | {- empty -} { (Nothing, False) }++maybe_pkg :: { (Maybe EpaLocation,Maybe StringLiteral) }+ : STRING {% do { let { pkgFS = getSTRING $1 }+ ; unless (looksLikePackageName (unpackFS pkgFS)) $+ addError $ PsError (PsErrInvalidPackageName pkgFS) [] (getLoc $1)+ ; return (Just (glAA $1), Just (StringLiteral (getSTRINGs $1) pkgFS Nothing)) } }+ | {- empty -} { (Nothing,Nothing) }++optqualified :: { Located (Maybe EpaLocation) }+ : 'qualified' { sL1 $1 (Just (glAA $1)) }+ | {- empty -} { noLoc Nothing }++maybeas :: { (Maybe EpaLocation,Located (Maybe (LocatedA ModuleName))) }+ : 'as' modid { (Just (glAA $1)+ ,sLL $1 (reLoc $>) (Just $2)) }+ | {- empty -} { (Nothing,noLoc Nothing) }++maybeimpspec :: { Located (Maybe (Bool, LocatedL [LIE GhcPs])) }+ : impspec {% let (b, ie) = unLoc $1 in+ checkImportSpec ie+ >>= \checkedIe ->+ return (L (gl $1) (Just (b, checkedIe))) }+ | {- empty -} { noLoc Nothing }++impspec :: { Located (Bool, LocatedL [LIE GhcPs]) }+ : '(' exportlist ')' {% do { es <- amsrl (sLL $1 $> $ fromOL $ snd $2)+ (AnnList Nothing (Just $ mop $1) (Just $ mcp $3) (fst $2) [])+ ; return $ sLL $1 $> (False, es)} }+ | 'hiding' '(' exportlist ')' {% do { es <- amsrl (sLL $1 $> $ fromOL $ snd $3)+ (AnnList Nothing (Just $ mop $2) (Just $ mcp $4) (mj AnnHiding $1:fst $3) [])+ ; return $ sLL $1 $> (True, es)} }++-----------------------------------------------------------------------------+-- Fixity Declarations++prec :: { Maybe (Located (SourceText,Int)) }+ : {- empty -} { Nothing }+ | INTEGER+ { Just (sL1 $1 (getINTEGERs $1,fromInteger (il_value (getINTEGER $1)))) }++infix :: { Located FixityDirection }+ : 'infix' { sL1 $1 InfixN }+ | 'infixl' { sL1 $1 InfixL }+ | 'infixr' { sL1 $1 InfixR }++ops :: { Located (OrdList (LocatedN RdrName)) }+ : ops ',' op {% case (unLoc $1) of+ SnocOL hs t -> do+ t' <- addTrailingCommaN t (gl $2)+ return (sLL $1 (reLocN $>) (snocOL hs t' `appOL` unitOL $3)) }+ | op { sL1N $1 (unitOL $1) }++-----------------------------------------------------------------------------+-- Top-Level Declarations++-- No trailing semicolons, non-empty+topdecls :: { OrdList (LHsDecl GhcPs) }+ : topdecls_semi topdecl { $1 `snocOL` $2 }++-- May have trailing semicolons, can be empty+topdecls_semi :: { OrdList (LHsDecl GhcPs) }+ : topdecls_semi topdecl semis1 {% do { t <- amsAl $2 (comb2 (reLoc $2) $3) (reverse $ unLoc $3)+ ; return ($1 `snocOL` t) }}+ | {- empty -} { nilOL }+++-----------------------------------------------------------------------------+-- Each topdecl accumulates prior comments+-- No trailing semicolons, non-empty+topdecls_cs :: { OrdList (LHsDecl GhcPs) }+ : topdecls_cs_semi topdecl_cs { $1 `snocOL` $2 }++-- May have trailing semicolons, can be empty+topdecls_cs_semi :: { OrdList (LHsDecl GhcPs) }+ : topdecls_cs_semi topdecl_cs semis1 {% do { t <- amsAl $2 (comb2 (reLoc $2) $3) (reverse $ unLoc $3)+ ; return ($1 `snocOL` t) }}+ | {- empty -} { nilOL }++-- Each topdecl accumulates prior comments+topdecl_cs :: { LHsDecl GhcPs }+topdecl_cs : topdecl {% commentsPA $1 }++-----------------------------------------------------------------------------+topdecl :: { LHsDecl GhcPs }+ : cl_decl { sL1 $1 (TyClD noExtField (unLoc $1)) }+ | ty_decl { sL1 $1 (TyClD noExtField (unLoc $1)) }+ | standalone_kind_sig { sL1 $1 (KindSigD noExtField (unLoc $1)) }+ | inst_decl { sL1 $1 (InstD noExtField (unLoc $1)) }+ | stand_alone_deriving { sL1 $1 (DerivD noExtField (unLoc $1)) }+ | role_annot { sL1 $1 (RoleAnnotD noExtField (unLoc $1)) }+ | 'default' '(' comma_types0 ')' {% acsA (\cs -> sLL $1 $>+ (DefD noExtField (DefaultDecl (EpAnn (glR $1) [mj AnnDefault $1,mop $2,mcp $4] cs) $3))) }+ | 'foreign' fdecl {% acsA (\cs -> sLL $1 $> ((snd $ unLoc $2) (EpAnn (glR $1) (mj AnnForeign $1:(fst $ unLoc $2)) cs))) }+ | '{-# DEPRECATED' deprecations '#-}' {% acsA (\cs -> sLL $1 $> $ WarningD noExtField (Warnings (EpAnn (glR $1) [mo $1,mc $3] cs) (getDEPRECATED_PRAGs $1) (fromOL $2))) }+ | '{-# WARNING' warnings '#-}' {% acsA (\cs -> sLL $1 $> $ WarningD noExtField (Warnings (EpAnn (glR $1) [mo $1,mc $3] cs) (getWARNING_PRAGs $1) (fromOL $2))) }+ | '{-# RULES' rules '#-}' {% acsA (\cs -> sLL $1 $> $ RuleD noExtField (HsRules (EpAnn (glR $1) [mo $1,mc $3] cs) (getRULES_PRAGs $1) (reverse $2))) }+ | annotation { $1 }+ | decl_no_th { $1 }++ -- Template Haskell Extension+ -- The $(..) form is one possible form of infixexp+ -- but we treat an arbitrary expression just as if+ -- it had a $(..) wrapped around it+ | infixexp {% runPV (unECP $1) >>= \ $1 ->+ do { d <- mkSpliceDecl $1+ ; commentsPA d }}++-- Type classes+--+cl_decl :: { LTyClDecl GhcPs }+ : 'class' tycl_hdr fds where_cls+ {% (mkClassDecl (comb4 $1 $2 $3 $4) $2 $3 (sndOf3 $ unLoc $4) (thdOf3 $ unLoc $4))+ (mj AnnClass $1:(fst $ unLoc $3)++(fstOf3 $ unLoc $4)) }++-- Type declarations (toplevel)+--+ty_decl :: { LTyClDecl GhcPs }+ -- ordinary type synonyms+ : 'type' type '=' ktype+ -- Note ktype, not sigtype, on the right of '='+ -- We allow an explicit for-all but we don't insert one+ -- in type Foo a = (b,b)+ -- Instead we just say b is out of scope+ --+ -- Note the use of type for the head; this allows+ -- infix type constructors to be declared+ {% mkTySynonym (comb2A $1 $4) $2 $4 [mj AnnType $1,mj AnnEqual $3] }++ -- type family declarations+ | 'type' 'family' type opt_tyfam_kind_sig opt_injective_info+ where_type_family+ -- Note the use of type for the head; this allows+ -- infix type constructors to be declared+ {% mkFamDecl (comb5 $1 (reLoc $3) $4 $5 $6) (snd $ unLoc $6) TopLevel $3+ (snd $ unLoc $4) (snd $ unLoc $5)+ (mj AnnType $1:mj AnnFamily $2:(fst $ unLoc $4)+ ++ (fst $ unLoc $5) ++ (fst $ unLoc $6)) }++ -- ordinary data type or newtype declaration+ | data_or_newtype capi_ctype tycl_hdr constrs maybe_derivings+ {% mkTyData (comb4 $1 $3 $4 $5) (snd $ unLoc $1) $2 $3+ Nothing (reverse (snd $ unLoc $4))+ (fmap reverse $5)+ ((fst $ unLoc $1):(fst $ unLoc $4)) }+ -- We need the location on tycl_hdr in case+ -- constrs and deriving are both empty++ -- ordinary GADT declaration+ | data_or_newtype capi_ctype tycl_hdr opt_kind_sig+ gadt_constrlist+ maybe_derivings+ {% mkTyData (comb4 $1 $3 $5 $6) (snd $ unLoc $1) $2 $3+ (snd $ unLoc $4) (snd $ unLoc $5)+ (fmap reverse $6)+ ((fst $ unLoc $1):(fst $ unLoc $4)++(fst $ unLoc $5)) }+ -- We need the location on tycl_hdr in case+ -- constrs and deriving are both empty++ -- data/newtype family+ | 'data' 'family' type opt_datafam_kind_sig+ {% mkFamDecl (comb3 $1 $2 $4) DataFamily TopLevel $3+ (snd $ unLoc $4) Nothing+ (mj AnnData $1:mj AnnFamily $2:(fst $ unLoc $4)) }++-- standalone kind signature+standalone_kind_sig :: { LStandaloneKindSig GhcPs }+ : 'type' sks_vars '::' sigktype+ {% mkStandaloneKindSig (comb2A $1 $4) (L (gl $2) $ unLoc $2) $4+ [mj AnnType $1,mu AnnDcolon $3]}++-- See also: sig_vars+sks_vars :: { Located [LocatedN RdrName] } -- Returned in reverse order+ : sks_vars ',' oqtycon+ {% case unLoc $1 of+ (h:t) -> do+ h' <- addTrailingCommaN h (gl $2)+ return (sLL $1 (reLocN $>) ($3 : h' : t)) }+ | oqtycon { sL1N $1 [$1] }++inst_decl :: { LInstDecl GhcPs }+ : 'instance' overlap_pragma inst_type where_inst+ {% do { (binds, sigs, _, ats, adts, _) <- cvBindsAndSigs (snd $ unLoc $4)+ ; let anns = (mj AnnInstance $1 : (fst $ unLoc $4))+ ; let cid cs = ClsInstDecl+ { cid_ext = (EpAnn (glR $1) anns cs, NoAnnSortKey)+ , cid_poly_ty = $3, cid_binds = binds+ , cid_sigs = mkClassOpSigs sigs+ , cid_tyfam_insts = ats+ , cid_overlap_mode = $2+ , cid_datafam_insts = adts }+ ; acsA (\cs -> L (comb3 $1 (reLoc $3) $4)+ (ClsInstD { cid_d_ext = noExtField, cid_inst = cid cs }))+ } }++ -- type instance declarations+ | 'type' 'instance' ty_fam_inst_eqn+ {% mkTyFamInst (comb2A $1 $3) (unLoc $3)+ (mj AnnType $1:mj AnnInstance $2:[]) }++ -- data/newtype instance declaration+ | data_or_newtype 'instance' capi_ctype datafam_inst_hdr constrs+ maybe_derivings+ {% mkDataFamInst (comb4 $1 $4 $5 $6) (snd $ unLoc $1) $3 (unLoc $4)+ Nothing (reverse (snd $ unLoc $5))+ (fmap reverse $6)+ ((fst $ unLoc $1):mj AnnInstance $2:(fst $ unLoc $5)) }++ -- GADT instance declaration+ | data_or_newtype 'instance' capi_ctype datafam_inst_hdr opt_kind_sig+ gadt_constrlist+ maybe_derivings+ {% mkDataFamInst (comb4 $1 $4 $6 $7) (snd $ unLoc $1) $3 (unLoc $4)+ (snd $ unLoc $5) (snd $ unLoc $6)+ (fmap reverse $7)+ ((fst $ unLoc $1):mj AnnInstance $2+ :(fst $ unLoc $5)++(fst $ unLoc $6)) }++overlap_pragma :: { Maybe (LocatedP OverlapMode) }+ : '{-# OVERLAPPABLE' '#-}' {% fmap Just $ amsrp (sLL $1 $> (Overlappable (getOVERLAPPABLE_PRAGs $1)))+ (AnnPragma (mo $1) (mc $2) []) }+ | '{-# OVERLAPPING' '#-}' {% fmap Just $ amsrp (sLL $1 $> (Overlapping (getOVERLAPPING_PRAGs $1)))+ (AnnPragma (mo $1) (mc $2) []) }+ | '{-# OVERLAPS' '#-}' {% fmap Just $ amsrp (sLL $1 $> (Overlaps (getOVERLAPS_PRAGs $1)))+ (AnnPragma (mo $1) (mc $2) []) }+ | '{-# INCOHERENT' '#-}' {% fmap Just $ amsrp (sLL $1 $> (Incoherent (getINCOHERENT_PRAGs $1)))+ (AnnPragma (mo $1) (mc $2) []) }+ | {- empty -} { Nothing }++deriv_strategy_no_via :: { LDerivStrategy GhcPs }+ : 'stock' {% acs (\cs -> sL1 $1 (StockStrategy (EpAnn (glR $1) [mj AnnStock $1] cs))) }+ | 'anyclass' {% acs (\cs -> sL1 $1 (AnyclassStrategy (EpAnn (glR $1) [mj AnnAnyclass $1] cs))) }+ | 'newtype' {% acs (\cs -> sL1 $1 (NewtypeStrategy (EpAnn (glR $1) [mj AnnNewtype $1] cs))) }++deriv_strategy_via :: { LDerivStrategy GhcPs }+ : 'via' sigktype {% acs (\cs -> sLLlA $1 $> (ViaStrategy (XViaStrategyPs (EpAnn (glR $1) [mj AnnVia $1] cs)+ $2))) }++deriv_standalone_strategy :: { Maybe (LDerivStrategy GhcPs) }+ : 'stock' {% fmap Just $ acs (\cs -> sL1 $1 (StockStrategy (EpAnn (glR $1) [mj AnnStock $1] cs))) }+ | 'anyclass' {% fmap Just $ acs (\cs -> sL1 $1 (AnyclassStrategy (EpAnn (glR $1) [mj AnnAnyclass $1] cs))) }+ | 'newtype' {% fmap Just $ acs (\cs -> sL1 $1 (NewtypeStrategy (EpAnn (glR $1) [mj AnnNewtype $1] cs))) }+ | deriv_strategy_via { Just $1 }+ | {- empty -} { Nothing }++-- Injective type families++opt_injective_info :: { Located ([AddEpAnn], Maybe (LInjectivityAnn GhcPs)) }+ : {- empty -} { noLoc ([], Nothing) }+ | '|' injectivity_cond { sLL $1 $> ([mj AnnVbar $1]+ , Just ($2)) }++injectivity_cond :: { LInjectivityAnn GhcPs }+ : tyvarid '->' inj_varids+ {% acs (\cs -> sLL (reLocN $1) $> (InjectivityAnn (EpAnn (glNR $1) [mu AnnRarrow $2] cs) $1 (reverse (unLoc $3)))) }++inj_varids :: { Located [LocatedN RdrName] }+ : inj_varids tyvarid { sLL $1 (reLocN $>) ($2 : unLoc $1) }+ | tyvarid { sL1N $1 [$1] }++-- Closed type families++where_type_family :: { Located ([AddEpAnn],FamilyInfo GhcPs) }+ : {- empty -} { noLoc ([],OpenTypeFamily) }+ | 'where' ty_fam_inst_eqn_list+ { sLL $1 $> (mj AnnWhere $1:(fst $ unLoc $2)+ ,ClosedTypeFamily (fmap reverse $ snd $ unLoc $2)) }++ty_fam_inst_eqn_list :: { Located ([AddEpAnn],Maybe [LTyFamInstEqn GhcPs]) }+ : '{' ty_fam_inst_eqns '}' { sLL $1 $> ([moc $1,mcc $3]+ ,Just (unLoc $2)) }+ | vocurly ty_fam_inst_eqns close { let (L loc _) = $2 in+ L loc ([],Just (unLoc $2)) }+ | '{' '..' '}' { sLL $1 $> ([moc $1,mj AnnDotdot $2+ ,mcc $3],Nothing) }+ | vocurly '..' close { let (L loc _) = $2 in+ L loc ([mj AnnDotdot $2],Nothing) }++ty_fam_inst_eqns :: { Located [LTyFamInstEqn GhcPs] }+ : ty_fam_inst_eqns ';' ty_fam_inst_eqn+ {% let (L loc eqn) = $3 in+ case unLoc $1 of+ [] -> return (sLLlA $1 $> (L loc eqn : unLoc $1))+ (h:t) -> do+ h' <- addTrailingSemiA h (gl $2)+ return (sLLlA $1 $> ($3 : h' : t)) }+ | ty_fam_inst_eqns ';' {% case unLoc $1 of+ [] -> return (sLL $1 $> (unLoc $1))+ (h:t) -> do+ h' <- addTrailingSemiA h (gl $2)+ return (sLL $1 $> (h':t)) }+ | ty_fam_inst_eqn { sLLAA $1 $> [$1] }+ | {- empty -} { noLoc [] }++ty_fam_inst_eqn :: { LTyFamInstEqn GhcPs }+ : 'forall' tv_bndrs '.' type '=' ktype+ {% do { hintExplicitForall $1+ ; tvbs <- fromSpecTyVarBndrs $2+ ; let loc = comb2A $1 $>+ ; cs <- getCommentsFor loc+ ; mkTyFamInstEqn loc (mkHsOuterExplicit (EpAnn (glR $1) (mu AnnForall $1, mj AnnDot $3) cs) tvbs) $4 $6 [mj AnnEqual $5] }}+ | type '=' ktype+ {% mkTyFamInstEqn (comb2A (reLoc $1) $>) mkHsOuterImplicit $1 $3 (mj AnnEqual $2:[]) }+ -- Note the use of type for the head; this allows+ -- infix type constructors and type patterns++-- Associated type family declarations+--+-- * They have a different syntax than on the toplevel (no family special+-- identifier).+--+-- * They also need to be separate from instances; otherwise, data family+-- declarations without a kind signature cause parsing conflicts with empty+-- data declarations.+--+at_decl_cls :: { LHsDecl GhcPs }+ : -- data family declarations, with optional 'family' keyword+ 'data' opt_family type opt_datafam_kind_sig+ {% liftM mkTyClD (mkFamDecl (comb3 $1 (reLoc $3) $4) DataFamily NotTopLevel $3+ (snd $ unLoc $4) Nothing+ (mj AnnData $1:$2++(fst $ unLoc $4))) }++ -- type family declarations, with optional 'family' keyword+ -- (can't use opt_instance because you get shift/reduce errors+ | 'type' type opt_at_kind_inj_sig+ {% liftM mkTyClD+ (mkFamDecl (comb3 $1 (reLoc $2) $3) OpenTypeFamily NotTopLevel $2+ (fst . snd $ unLoc $3)+ (snd . snd $ unLoc $3)+ (mj AnnType $1:(fst $ unLoc $3)) )}+ | 'type' 'family' type opt_at_kind_inj_sig+ {% liftM mkTyClD+ (mkFamDecl (comb3 $1 (reLoc $3) $4) OpenTypeFamily NotTopLevel $3+ (fst . snd $ unLoc $4)+ (snd . snd $ unLoc $4)+ (mj AnnType $1:mj AnnFamily $2:(fst $ unLoc $4)))}++ -- default type instances, with optional 'instance' keyword+ | 'type' ty_fam_inst_eqn+ {% liftM mkInstD (mkTyFamInst (comb2A $1 $2) (unLoc $2)+ [mj AnnType $1]) }+ | 'type' 'instance' ty_fam_inst_eqn+ {% liftM mkInstD (mkTyFamInst (comb2A $1 $3) (unLoc $3)+ (mj AnnType $1:mj AnnInstance $2:[]) )}++opt_family :: { [AddEpAnn] }+ : {- empty -} { [] }+ | 'family' { [mj AnnFamily $1] }++opt_instance :: { [AddEpAnn] }+ : {- empty -} { [] }+ | 'instance' { [mj AnnInstance $1] }++-- Associated type instances+--+at_decl_inst :: { LInstDecl GhcPs }+ -- type instance declarations, with optional 'instance' keyword+ : 'type' opt_instance ty_fam_inst_eqn+ -- Note the use of type for the head; this allows+ -- infix type constructors and type patterns+ {% mkTyFamInst (comb2A $1 $3) (unLoc $3)+ (mj AnnType $1:$2) }++ -- data/newtype instance declaration, with optional 'instance' keyword+ | data_or_newtype opt_instance capi_ctype datafam_inst_hdr constrs maybe_derivings+ {% mkDataFamInst (comb4 $1 $4 $5 $6) (snd $ unLoc $1) $3 (unLoc $4)+ Nothing (reverse (snd $ unLoc $5))+ (fmap reverse $6)+ ((fst $ unLoc $1):$2++(fst $ unLoc $5)) }++ -- GADT instance declaration, with optional 'instance' keyword+ | data_or_newtype opt_instance capi_ctype datafam_inst_hdr opt_kind_sig+ gadt_constrlist+ maybe_derivings+ {% mkDataFamInst (comb4 $1 $4 $6 $7) (snd $ unLoc $1) $3+ (unLoc $4) (snd $ unLoc $5) (snd $ unLoc $6)+ (fmap reverse $7)+ ((fst $ unLoc $1):$2++(fst $ unLoc $5)++(fst $ unLoc $6)) }++data_or_newtype :: { Located (AddEpAnn, NewOrData) }+ : 'data' { sL1 $1 (mj AnnData $1,DataType) }+ | 'newtype' { sL1 $1 (mj AnnNewtype $1,NewType) }++-- Family result/return kind signatures++opt_kind_sig :: { Located ([AddEpAnn], Maybe (LHsKind GhcPs)) }+ : { noLoc ([] , Nothing) }+ | '::' kind { sLL $1 (reLoc $>) ([mu AnnDcolon $1], Just $2) }++opt_datafam_kind_sig :: { Located ([AddEpAnn], LFamilyResultSig GhcPs) }+ : { noLoc ([] , noLoc (NoSig noExtField) )}+ | '::' kind { sLL $1 (reLoc $>) ([mu AnnDcolon $1], sLL $1 (reLoc $>) (KindSig noExtField $2))}++opt_tyfam_kind_sig :: { Located ([AddEpAnn], LFamilyResultSig GhcPs) }+ : { noLoc ([] , noLoc (NoSig noExtField) )}+ | '::' kind { sLL $1 (reLoc $>) ([mu AnnDcolon $1], sLL $1 (reLoc $>) (KindSig noExtField $2))}+ | '=' tv_bndr {% do { tvb <- fromSpecTyVarBndr $2+ ; return $ sLL $1 (reLoc $>) ([mj AnnEqual $1], sLL $1 (reLoc $>) (TyVarSig noExtField tvb))} }++opt_at_kind_inj_sig :: { Located ([AddEpAnn], ( LFamilyResultSig GhcPs+ , Maybe (LInjectivityAnn GhcPs)))}+ : { noLoc ([], (noLoc (NoSig noExtField), Nothing)) }+ | '::' kind { sLL $1 (reLoc $>) ( [mu AnnDcolon $1]+ , (sL1A $> (KindSig noExtField $2), Nothing)) }+ | '=' tv_bndr_no_braces '|' injectivity_cond+ {% do { tvb <- fromSpecTyVarBndr $2+ ; return $ sLL $1 $> ([mj AnnEqual $1, mj AnnVbar $3]+ , (sLL $1 (reLoc $2) (TyVarSig noExtField tvb), Just $4))} }++-- tycl_hdr parses the header of a class or data type decl,+-- which takes the form+-- T a b+-- Eq a => T a+-- (Eq a, Ord b) => T a b+-- T Int [a] -- for associated types+-- Rather a lot of inlining here, else we get reduce/reduce errors+tycl_hdr :: { Located (Maybe (LHsContext GhcPs), LHsType GhcPs) }+ : context '=>' type {% acs (\cs -> (sLLAA $1 $> (Just (addTrailingDarrowC $1 $2 cs), $3))) }+ | type { sL1A $1 (Nothing, $1) }++datafam_inst_hdr :: { Located (Maybe (LHsContext GhcPs), HsOuterFamEqnTyVarBndrs GhcPs, LHsType GhcPs) }+ : 'forall' tv_bndrs '.' context '=>' type {% hintExplicitForall $1+ >> fromSpecTyVarBndrs $2+ >>= \tvbs ->+ (acs (\cs -> (sLL $1 (reLoc $>)+ (Just ( addTrailingDarrowC $4 $5 cs)+ , mkHsOuterExplicit (EpAnn (glR $1) (mu AnnForall $1, mj AnnDot $3) emptyComments) tvbs, $6))))+ }+ | 'forall' tv_bndrs '.' type {% do { hintExplicitForall $1+ ; tvbs <- fromSpecTyVarBndrs $2+ ; let loc = comb2 $1 (reLoc $>)+ ; cs <- getCommentsFor loc+ ; return (sL loc (Nothing, mkHsOuterExplicit (EpAnn (glR $1) (mu AnnForall $1, mj AnnDot $3) cs) tvbs, $4))+ } }+ | context '=>' type {% acs (\cs -> (sLLAA $1 $>(Just (addTrailingDarrowC $1 $2 cs), mkHsOuterImplicit, $3))) }+ | type { sL1A $1 (Nothing, mkHsOuterImplicit, $1) }+++capi_ctype :: { Maybe (LocatedP CType) }+capi_ctype : '{-# CTYPE' STRING STRING '#-}'+ {% fmap Just $ amsrp (sLL $1 $> (CType (getCTYPEs $1) (Just (Header (getSTRINGs $2) (getSTRING $2)))+ (getSTRINGs $3,getSTRING $3)))+ (AnnPragma (mo $1) (mc $4) [mj AnnHeader $2,mj AnnVal $3]) }++ | '{-# CTYPE' STRING '#-}'+ {% fmap Just $ amsrp (sLL $1 $> (CType (getCTYPEs $1) Nothing (getSTRINGs $2, getSTRING $2)))+ (AnnPragma (mo $1) (mc $3) [mj AnnVal $2]) }++ | { Nothing }++-----------------------------------------------------------------------------+-- Stand-alone deriving++-- Glasgow extension: stand-alone deriving declarations+stand_alone_deriving :: { LDerivDecl GhcPs }+ : 'deriving' deriv_standalone_strategy 'instance' overlap_pragma inst_type+ {% do { let { err = text "in the stand-alone deriving instance"+ <> colon <+> quotes (ppr $5) }+ ; acsA (\cs -> sLL $1 (reLoc $>)+ (DerivDecl (EpAnn (glR $1) [mj AnnDeriving $1, mj AnnInstance $3] cs) (mkHsWildCardBndrs $5) $2 $4)) }}++-----------------------------------------------------------------------------+-- Role annotations++role_annot :: { LRoleAnnotDecl GhcPs }+role_annot : 'type' 'role' oqtycon maybe_roles+ {% mkRoleAnnotDecl (comb3N $1 $4 $3) $3 (reverse (unLoc $4))+ [mj AnnType $1,mj AnnRole $2] }++-- Reversed!+maybe_roles :: { Located [Located (Maybe FastString)] }+maybe_roles : {- empty -} { noLoc [] }+ | roles { $1 }++roles :: { Located [Located (Maybe FastString)] }+roles : role { sLL $1 $> [$1] }+ | roles role { sLL $1 $> $ $2 : unLoc $1 }++-- read it in as a varid for better error messages+role :: { Located (Maybe FastString) }+role : VARID { sL1 $1 $ Just $ getVARID $1 }+ | '_' { sL1 $1 Nothing }++-- Pattern synonyms++-- Glasgow extension: pattern synonyms+pattern_synonym_decl :: { LHsDecl GhcPs }+ : 'pattern' pattern_synonym_lhs '=' pat+ {% let (name, args, as ) = $2 in+ acsA (\cs -> sLL $1 (reLoc $>) . ValD noExtField $ mkPatSynBind name args $4+ ImplicitBidirectional+ (EpAnn (glR $1) (as ++ [mj AnnPattern $1, mj AnnEqual $3]) cs)) }++ | 'pattern' pattern_synonym_lhs '<-' pat+ {% let (name, args, as) = $2 in+ acsA (\cs -> sLL $1 (reLoc $>) . ValD noExtField $ mkPatSynBind name args $4 Unidirectional+ (EpAnn (glR $1) (as ++ [mj AnnPattern $1,mu AnnLarrow $3]) cs)) }++ | 'pattern' pattern_synonym_lhs '<-' pat where_decls+ {% do { let (name, args, as) = $2+ ; mg <- mkPatSynMatchGroup name $5+ ; acsA (\cs -> sLL $1 (reLoc $>) . ValD noExtField $+ mkPatSynBind name args $4 (ExplicitBidirectional mg)+ (EpAnn (glR $1) (as ++ [mj AnnPattern $1,mu AnnLarrow $3]) cs))+ }}++pattern_synonym_lhs :: { (LocatedN RdrName, HsPatSynDetails GhcPs, [AddEpAnn]) }+ : con vars0 { ($1, PrefixCon noTypeArgs $2, []) }+ | varid conop varid { ($2, InfixCon $1 $3, []) }+ | con '{' cvars1 '}' { ($1, RecCon $3, [moc $2, mcc $4] ) }++vars0 :: { [LocatedN RdrName] }+ : {- empty -} { [] }+ | varid vars0 { $1 : $2 }++cvars1 :: { [RecordPatSynField GhcPs] }+ : var { [RecordPatSynField (mkFieldOcc $1) $1] }+ | var ',' cvars1 {% do { h <- addTrailingCommaN $1 (gl $2)+ ; return ((RecordPatSynField (mkFieldOcc h) h) : $3 )}}++where_decls :: { LocatedL (OrdList (LHsDecl GhcPs)) }+ : 'where' '{' decls '}' {% amsrl (sLL $1 $> (snd $ unLoc $3))+ (AnnList (Just $ glR $3) (Just $ moc $2) (Just $ mcc $4) [mj AnnWhere $1] (fst $ unLoc $3)) }+ | 'where' vocurly decls close {% amsrl (sLL $1 $3 (snd $ unLoc $3))+ (AnnList (Just $ glR $3) Nothing Nothing [mj AnnWhere $1] (fst $ unLoc $3))}++pattern_synonym_sig :: { LSig GhcPs }+ : 'pattern' con_list '::' sigtype+ {% acsA (\cs -> sLL $1 (reLoc $>)+ $ PatSynSig (EpAnn (glR $1) (AnnSig (mu AnnDcolon $3) [mj AnnPattern $1]) cs)+ (unLoc $2) $4) }++qvarcon :: { LocatedN RdrName }+ : qvar { $1 }+ | qcon { $1 }++-----------------------------------------------------------------------------+-- Nested declarations++-- Declaration in class bodies+--+decl_cls :: { LHsDecl GhcPs }+decl_cls : at_decl_cls { $1 }+ | decl { $1 }++ -- A 'default' signature used with the generic-programming extension+ | 'default' infixexp '::' sigtype+ {% runPV (unECP $2) >>= \ $2 ->+ do { v <- checkValSigLhs $2+ ; let err = text "in default signature" <> colon <+>+ quotes (ppr $2)+ ; acsA (\cs -> sLL $1 (reLoc $>) $ SigD noExtField $ ClassOpSig (EpAnn (glR $1) (AnnSig (mu AnnDcolon $3) [mj AnnDefault $1]) cs) True [v] $4) }}++decls_cls :: { Located ([AddEpAnn],OrdList (LHsDecl GhcPs)) } -- Reversed+ : decls_cls ';' decl_cls {% if isNilOL (snd $ unLoc $1)+ then return (sLLlA $1 $> ((fst $ unLoc $1) ++ (mz AnnSemi $2)+ , unitOL $3))+ else case (snd $ unLoc $1) of+ SnocOL hs t -> do+ t' <- addTrailingSemiA t (gl $2)+ return (sLLlA $1 $> (fst $ unLoc $1+ , snocOL hs t' `appOL` unitOL $3)) }+ | decls_cls ';' {% if isNilOL (snd $ unLoc $1)+ then return (sLL $1 $> ( (fst $ unLoc $1) ++ (mz AnnSemi $2)+ ,snd $ unLoc $1))+ else case (snd $ unLoc $1) of+ SnocOL hs t -> do+ t' <- addTrailingSemiA t (gl $2)+ return (sLL $1 $> (fst $ unLoc $1+ , snocOL hs t')) }+ | decl_cls { sL1A $1 ([], unitOL $1) }+ | {- empty -} { noLoc ([],nilOL) }++decllist_cls+ :: { Located ([AddEpAnn]+ , OrdList (LHsDecl GhcPs)+ , LayoutInfo) } -- Reversed+ : '{' decls_cls '}' { sLL $1 $> (moc $1:mcc $3:(fst $ unLoc $2)+ ,snd $ unLoc $2, ExplicitBraces) }+ | vocurly decls_cls close { let { L l (anns, decls) = $2 }+ in L l (anns, decls, VirtualBraces (getVOCURLY $1)) }++-- Class body+--+where_cls :: { Located ([AddEpAnn]+ ,(OrdList (LHsDecl GhcPs)) -- Reversed+ ,LayoutInfo) }+ -- No implicit parameters+ -- May have type declarations+ : 'where' decllist_cls { sLL $1 $> (mj AnnWhere $1:(fstOf3 $ unLoc $2)+ ,sndOf3 $ unLoc $2,thdOf3 $ unLoc $2) }+ | {- empty -} { noLoc ([],nilOL,NoLayoutInfo) }++-- Declarations in instance bodies+--+decl_inst :: { Located (OrdList (LHsDecl GhcPs)) }+decl_inst : at_decl_inst { sL1A $1 (unitOL (sL1 $1 (InstD noExtField (unLoc $1)))) }+ | decl { sL1A $1 (unitOL $1) }++decls_inst :: { Located ([AddEpAnn],OrdList (LHsDecl GhcPs)) } -- Reversed+ : decls_inst ';' decl_inst {% if isNilOL (snd $ unLoc $1)+ then return (sLL $1 $> ((fst $ unLoc $1) ++ (mz AnnSemi $2)+ , unLoc $3))+ else case (snd $ unLoc $1) of+ SnocOL hs t -> do+ t' <- addTrailingSemiA t (gl $2)+ return (sLL $1 $> (fst $ unLoc $1+ , snocOL hs t' `appOL` unLoc $3)) }+ | decls_inst ';' {% if isNilOL (snd $ unLoc $1)+ then return (sLL $1 $> ((fst $ unLoc $1) ++ (mz AnnSemi $2)+ ,snd $ unLoc $1))+ else case (snd $ unLoc $1) of+ SnocOL hs t -> do+ t' <- addTrailingSemiA t (gl $2)+ return (sLL $1 $> (fst $ unLoc $1+ , snocOL hs t')) }+ | decl_inst { sL1 $1 ([],unLoc $1) }+ | {- empty -} { noLoc ([],nilOL) }++decllist_inst+ :: { Located ([AddEpAnn]+ , OrdList (LHsDecl GhcPs)) } -- Reversed+ : '{' decls_inst '}' { sLL $1 $> (moc $1:mcc $3:(fst $ unLoc $2),snd $ unLoc $2) }+ | vocurly decls_inst close { L (gl $2) (unLoc $2) }++-- Instance body+--+where_inst :: { Located ([AddEpAnn]+ , OrdList (LHsDecl GhcPs)) } -- Reversed+ -- No implicit parameters+ -- May have type declarations+ : 'where' decllist_inst { sLL $1 $> (mj AnnWhere $1:(fst $ unLoc $2)+ ,(snd $ unLoc $2)) }+ | {- empty -} { noLoc ([],nilOL) }++-- Declarations in binding groups other than classes and instances+--+decls :: { Located ([TrailingAnn], OrdList (LHsDecl GhcPs)) }+ : decls ';' decl {% if isNilOL (snd $ unLoc $1)+ then return (sLLlA $1 $> ((fst $ unLoc $1) ++ (msemi $2)+ , unitOL $3))+ else case (snd $ unLoc $1) of+ SnocOL hs t -> do+ t' <- addTrailingSemiA t (gl $2)+ let { this = unitOL $3;+ rest = snocOL hs t';+ these = rest `appOL` this }+ return (rest `seq` this `seq` these `seq`+ (sLLlA $1 $> (fst $ unLoc $1, these))) }+ | decls ';' {% if isNilOL (snd $ unLoc $1)+ then return (sLL $1 $> (((fst $ unLoc $1) ++ (msemi $2)+ ,snd $ unLoc $1)))+ else case (snd $ unLoc $1) of+ SnocOL hs t -> do+ t' <- addTrailingSemiA t (gl $2)+ return (sLL $1 $> (fst $ unLoc $1+ , snocOL hs t')) }+ | decl { sL1A $1 ([], unitOL $1) }+ | {- empty -} { noLoc ([],nilOL) }++decllist :: { Located (AnnList,Located (OrdList (LHsDecl GhcPs))) }+ : '{' decls '}' { sLL $1 $> (AnnList (Just $ glR $2) (Just $ moc $1) (Just $ mcc $3) [] (fst $ unLoc $2)+ ,sL1 $2 $ snd $ unLoc $2) }+ | vocurly decls close { L (gl $2) (AnnList (Just $ glR $2) Nothing Nothing [] (fst $ unLoc $2)+ ,sL1 $2 $ snd $ unLoc $2) }++-- Binding groups other than those of class and instance declarations+--+binds :: { Located (HsLocalBinds GhcPs) }+ -- May have implicit parameters+ -- No type declarations+ : decllist {% do { val_binds <- cvBindGroup (unLoc $ snd $ unLoc $1)+ ; cs <- getCommentsFor (gl $1)+ ; return (sL1 $1 $ HsValBinds (EpAnn (glR $1) (fst $ unLoc $1) cs) val_binds)} }++ | '{' dbinds '}' {% acs (\cs -> (L (comb3 $1 $2 $3)+ $ HsIPBinds (EpAnn (glR $1) (AnnList (Just$ glR $2) (Just $ moc $1) (Just $ mcc $3) [] []) cs) (IPBinds noExtField (reverse $ unLoc $2)))) }++ | vocurly dbinds close {% acs (\cs -> (L (gl $2)+ $ HsIPBinds (EpAnn (glR $1) (AnnList (Just $ glR $2) Nothing Nothing [] []) cs) (IPBinds noExtField (reverse $ unLoc $2)))) }+++wherebinds :: { Maybe (Located (HsLocalBinds GhcPs, Maybe EpAnnComments )) }+ -- May have implicit parameters+ -- No type declarations+ : 'where' binds {% do { r <- acs (\cs ->+ (sLL $1 $> (annBinds (mj AnnWhere $1) cs (unLoc $2))))+ ; return $ Just r} }+ | {- empty -} { Nothing }++-----------------------------------------------------------------------------+-- Transformation Rules++rules :: { [LRuleDecl GhcPs] } -- Reversed+ : rules ';' rule {% case $1 of+ [] -> return ($3:$1)+ (h:t) -> do+ h' <- addTrailingSemiA h (gl $2)+ return ($3:h':t) }+ | rules ';' {% case $1 of+ [] -> return $1+ (h:t) -> do+ h' <- addTrailingSemiA h (gl $2)+ return (h':t) }+ | rule { [$1] }+ | {- empty -} { [] }++rule :: { LRuleDecl GhcPs }+ : STRING rule_activation rule_foralls infixexp '=' exp+ {%runPV (unECP $4) >>= \ $4 ->+ runPV (unECP $6) >>= \ $6 ->+ acsA (\cs -> (sLLlA $1 $> $ HsRule+ { rd_ext = EpAnn (glR $1) ((fstOf3 $3) (mj AnnEqual $5 : (fst $2))) cs+ , rd_name = L (gl $1) (getSTRINGs $1, getSTRING $1)+ , rd_act = (snd $2) `orElse` AlwaysActive+ , rd_tyvs = sndOf3 $3, rd_tmvs = thdOf3 $3+ , rd_lhs = $4, rd_rhs = $6 })) }++-- Rules can be specified to be NeverActive, unlike inline/specialize pragmas+rule_activation :: { ([AddEpAnn],Maybe Activation) }+ -- See Note [%shift: rule_activation -> {- empty -}]+ : {- empty -} %shift { ([],Nothing) }+ | rule_explicit_activation { (fst $1,Just (snd $1)) }++-- This production is used to parse the tilde syntax in pragmas such as+-- * {-# INLINE[~2] ... #-}+-- * {-# SPECIALISE [~ 001] ... #-}+-- * {-# RULES ... [~0] ... g #-}+-- Note that it can be written either+-- without a space [~1] (the PREFIX_TILDE case), or+-- with a space [~ 1] (the VARSYM case).+-- See Note [Whitespace-sensitive operator parsing] in GHC.Parser.Lexer+rule_activation_marker :: { [AddEpAnn] }+ : PREFIX_TILDE { [mj AnnTilde $1] }+ | VARSYM {% if (getVARSYM $1 == fsLit "~")+ then return [mj AnnTilde $1]+ else do { addError $ PsError PsErrInvalidRuleActivationMarker [] (getLoc $1)+ ; return [] } }++rule_explicit_activation :: { ([AddEpAnn]+ ,Activation) } -- In brackets+ : '[' INTEGER ']' { ([mos $1,mj AnnVal $2,mcs $3]+ ,ActiveAfter (getINTEGERs $2) (fromInteger (il_value (getINTEGER $2)))) }+ | '[' rule_activation_marker INTEGER ']'+ { ($2++[mos $1,mj AnnVal $3,mcs $4]+ ,ActiveBefore (getINTEGERs $3) (fromInteger (il_value (getINTEGER $3)))) }+ | '[' rule_activation_marker ']'+ { ($2++[mos $1,mcs $3]+ ,NeverActive) }++rule_foralls :: { ([AddEpAnn] -> HsRuleAnn, Maybe [LHsTyVarBndr () GhcPs], [LRuleBndr GhcPs]) }+ : 'forall' rule_vars '.' 'forall' rule_vars '.' {% let tyvs = mkRuleTyVarBndrs $2+ in hintExplicitForall $1+ >> checkRuleTyVarBndrNames (mkRuleTyVarBndrs $2)+ >> return (\anns -> HsRuleAnn+ (Just (mu AnnForall $1,mj AnnDot $3))+ (Just (mu AnnForall $4,mj AnnDot $6))+ anns,+ Just (mkRuleTyVarBndrs $2), mkRuleBndrs $5) }++ -- See Note [%shift: rule_foralls -> 'forall' rule_vars '.']+ | 'forall' rule_vars '.' %shift { (\anns -> HsRuleAnn Nothing (Just (mu AnnForall $1,mj AnnDot $3)) anns,+ Nothing, mkRuleBndrs $2) }+ -- See Note [%shift: rule_foralls -> {- empty -}]+ | {- empty -} %shift { (\anns -> HsRuleAnn Nothing Nothing anns, Nothing, []) }++rule_vars :: { [LRuleTyTmVar] }+ : rule_var rule_vars { $1 : $2 }+ | {- empty -} { [] }++rule_var :: { LRuleTyTmVar }+ : varid { sL1N $1 (RuleTyTmVar noAnn $1 Nothing) }+ | '(' varid '::' ctype ')' {% acs (\cs -> sLL $1 $> (RuleTyTmVar (EpAnn (glR $1) [mop $1,mu AnnDcolon $3,mcp $5] cs) $2 (Just $4))) }++{- Note [Parsing explicit foralls in Rules]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+We really want the above definition of rule_foralls to be:++ rule_foralls : 'forall' tv_bndrs '.' 'forall' rule_vars '.'+ | 'forall' rule_vars '.'+ | {- empty -}++where rule_vars (term variables) can be named "forall", "family", or "role",+but tv_vars (type variables) cannot be. However, such a definition results+in a reduce/reduce conflict. For example, when parsing:+> {-# RULE "name" forall a ... #-}+before the '...' it is impossible to determine whether we should be in the+first or second case of the above.++This is resolved by using rule_vars (which is more general) for both, and+ensuring that type-level quantified variables do not have the names "forall",+"family", or "role" in the function 'checkRuleTyVarBndrNames' in+GHC.Parser.PostProcess.+Thus, whenever the definition of tyvarid (used for tv_bndrs) is changed relative+to varid (used for rule_vars), 'checkRuleTyVarBndrNames' must be updated.+-}++-----------------------------------------------------------------------------+-- Warnings and deprecations (c.f. rules)++warnings :: { OrdList (LWarnDecl GhcPs) }+ : warnings ';' warning {% if isNilOL $1+ then return ($1 `appOL` $3)+ else case $1 of+ SnocOL hs t -> do+ t' <- addTrailingSemiA t (gl $2)+ return (snocOL hs t' `appOL` $3) }+ | warnings ';' {% if isNilOL $1+ then return $1+ else case $1 of+ SnocOL hs t -> do+ t' <- addTrailingSemiA t (gl $2)+ return (snocOL hs t') }+ | warning { $1 }+ | {- empty -} { nilOL }++-- SUP: TEMPORARY HACK, not checking for `module Foo'+warning :: { OrdList (LWarnDecl GhcPs) }+ : namelist strings+ {% fmap unitOL $ acsA (\cs -> sLL $1 $>+ (Warning (EpAnn (glR $1) (fst $ unLoc $2) cs) (unLoc $1)+ (WarningTxt (noLoc NoSourceText) $ snd $ unLoc $2))) }++deprecations :: { OrdList (LWarnDecl GhcPs) }+ : deprecations ';' deprecation+ {% if isNilOL $1+ then return ($1 `appOL` $3)+ else case $1 of+ SnocOL hs t -> do+ t' <- addTrailingSemiA t (gl $2)+ return (snocOL hs t' `appOL` $3) }+ | deprecations ';' {% if isNilOL $1+ then return $1+ else case $1 of+ SnocOL hs t -> do+ t' <- addTrailingSemiA t (gl $2)+ return (snocOL hs t') }+ | deprecation { $1 }+ | {- empty -} { nilOL }++-- SUP: TEMPORARY HACK, not checking for `module Foo'+deprecation :: { OrdList (LWarnDecl GhcPs) }+ : namelist strings+ {% fmap unitOL $ acsA (\cs -> sLL $1 $> $ (Warning (EpAnn (glR $1) (fst $ unLoc $2) cs) (unLoc $1)+ (DeprecatedTxt (noLoc NoSourceText) $ snd $ unLoc $2))) }++strings :: { Located ([AddEpAnn],[Located StringLiteral]) }+ : STRING { sL1 $1 ([],[L (gl $1) (getStringLiteral $1)]) }+ | '[' stringlist ']' { sLL $1 $> $ ([mos $1,mcs $3],fromOL (unLoc $2)) }++stringlist :: { Located (OrdList (Located StringLiteral)) }+ : stringlist ',' STRING {% if isNilOL (unLoc $1)+ then return (sLL $1 $> (unLoc $1 `snocOL`+ (L (gl $3) (getStringLiteral $3))))+ else case (unLoc $1) of+ SnocOL hs t -> do+ let { t' = addTrailingCommaS t (glAA $2) }+ return (sLL $1 $> (snocOL hs t' `snocOL`+ (L (gl $3) (getStringLiteral $3))))++}+ | STRING { sLL $1 $> (unitOL (L (gl $1) (getStringLiteral $1))) }+ | {- empty -} { noLoc nilOL }++-----------------------------------------------------------------------------+-- Annotations+annotation :: { LHsDecl GhcPs }+ : '{-# ANN' name_var aexp '#-}' {% runPV (unECP $3) >>= \ $3 ->+ acsA (\cs -> sLL $1 $> (AnnD noExtField $ HsAnnotation+ (EpAnn (glR $1) (AnnPragma (mo $1) (mc $4) []) cs)+ (getANN_PRAGs $1)+ (ValueAnnProvenance $2) $3)) }++ | '{-# ANN' 'type' otycon aexp '#-}' {% runPV (unECP $4) >>= \ $4 ->+ acsA (\cs -> sLL $1 $> (AnnD noExtField $ HsAnnotation+ (EpAnn (glR $1) (AnnPragma (mo $1) (mc $5) [mj AnnType $2]) cs)+ (getANN_PRAGs $1)+ (TypeAnnProvenance $3) $4)) }++ | '{-# ANN' 'module' aexp '#-}' {% runPV (unECP $3) >>= \ $3 ->+ acsA (\cs -> sLL $1 $> (AnnD noExtField $ HsAnnotation+ (EpAnn (glR $1) (AnnPragma (mo $1) (mc $4) [mj AnnModule $2]) cs)+ (getANN_PRAGs $1)+ ModuleAnnProvenance $3)) }++-----------------------------------------------------------------------------+-- Foreign import and export declarations++fdecl :: { Located ([AddEpAnn],EpAnn [AddEpAnn] -> HsDecl GhcPs) }+fdecl : 'import' callconv safety fspec+ {% mkImport $2 $3 (snd $ unLoc $4) >>= \i ->+ return (sLL $1 $> (mj AnnImport $1 : (fst $ unLoc $4),i)) }+ | 'import' callconv fspec+ {% do { d <- mkImport $2 (noLoc PlaySafe) (snd $ unLoc $3);+ return (sLL $1 $> (mj AnnImport $1 : (fst $ unLoc $3),d)) }}+ | 'export' callconv fspec+ {% mkExport $2 (snd $ unLoc $3) >>= \i ->+ return (sLL $1 $> (mj AnnExport $1 : (fst $ unLoc $3),i) ) }++callconv :: { Located CCallConv }+ : 'stdcall' { sLL $1 $> StdCallConv }+ | 'ccall' { sLL $1 $> CCallConv }+ | 'capi' { sLL $1 $> CApiConv }+ | 'prim' { sLL $1 $> PrimCallConv}+ | 'javascript' { sLL $1 $> JavaScriptCallConv }++safety :: { Located Safety }+ : 'unsafe' { sLL $1 $> PlayRisky }+ | 'safe' { sLL $1 $> PlaySafe }+ | 'interruptible' { sLL $1 $> PlayInterruptible }++fspec :: { Located ([AddEpAnn]+ ,(Located StringLiteral, LocatedN RdrName, LHsSigType GhcPs)) }+ : STRING var '::' sigtype { sLL $1 (reLoc $>) ([mu AnnDcolon $3]+ ,(L (getLoc $1)+ (getStringLiteral $1), $2, $4)) }+ | var '::' sigtype { sLL (reLocN $1) (reLoc $>) ([mu AnnDcolon $2]+ ,(noLoc (StringLiteral NoSourceText nilFS Nothing), $1, $3)) }+ -- if the entity string is missing, it defaults to the empty string;+ -- the meaning of an empty entity string depends on the calling+ -- convention++-----------------------------------------------------------------------------+-- Type signatures++opt_sig :: { Maybe (AddEpAnn, LHsType GhcPs) }+ : {- empty -} { Nothing }+ | '::' ctype { Just (mu AnnDcolon $1, $2) }++opt_tyconsig :: { ([AddEpAnn], Maybe (LocatedN RdrName)) }+ : {- empty -} { ([], Nothing) }+ | '::' gtycon { ([mu AnnDcolon $1], Just $2) }++-- Like ktype, but for types that obey the forall-or-nothing rule.+-- See Note [forall-or-nothing rule] in GHC.Hs.Type.+sigktype :: { LHsSigType GhcPs }+ : sigtype { $1 }+ | ctype '::' kind {% acsA (\cs -> sLLAA $1 $> $ mkHsImplicitSigType $+ sLLa (reLoc $1) (reLoc $>) $ HsKindSig (EpAnn (glAR $1) [mu AnnDcolon $2] cs) $1 $3) }++-- Like ctype, but for types that obey the forall-or-nothing rule.+-- See Note [forall-or-nothing rule] in GHC.Hs.Type. To avoid duplicating the+-- logic in ctype here, we simply reuse the ctype production and perform+-- surgery on the LHsType it returns to turn it into an LHsSigType.+sigtype :: { LHsSigType GhcPs }+ : ctype { hsTypeToHsSigType $1 }++sig_vars :: { Located [LocatedN RdrName] } -- Returned in reversed order+ : sig_vars ',' var {% case unLoc $1 of+ [] -> return (sLL $1 (reLocN $>) ($3 : unLoc $1))+ (h:t) -> do+ h' <- addTrailingCommaN h (gl $2)+ return (sLL $1 (reLocN $>) ($3 : h' : t)) }+ | var { sL1N $1 [$1] }++sigtypes1 :: { OrdList (LHsSigType GhcPs) }+ : sigtype { unitOL $1 }+ | sigtype ',' sigtypes1 {% do { st <- addTrailingCommaA $1 (gl $2)+ ; return $ unitOL st `appOL` $3 } }+-----------------------------------------------------------------------------+-- Types++unpackedness :: { Located UnpackednessPragma }+ : '{-# UNPACK' '#-}' { sLL $1 $> (UnpackednessPragma [mo $1, mc $2] (getUNPACK_PRAGs $1) SrcUnpack) }+ | '{-# NOUNPACK' '#-}' { sLL $1 $> (UnpackednessPragma [mo $1, mc $2] (getNOUNPACK_PRAGs $1) SrcNoUnpack) }++forall_telescope :: { Located (HsForAllTelescope GhcPs) }+ : 'forall' tv_bndrs '.' {% do { hintExplicitForall $1+ ; acs (\cs -> (sLL $1 $> $+ mkHsForAllInvisTele (EpAnn (glR $1) (mu AnnForall $1,mu AnnDot $3) cs) $2 )) }}+ | 'forall' tv_bndrs '->' {% do { hintExplicitForall $1+ ; req_tvbs <- fromSpecTyVarBndrs $2+ ; acs (\cs -> (sLL $1 $> $+ mkHsForAllVisTele (EpAnn (glR $1) (mu AnnForall $1,mu AnnRarrow $3) cs) req_tvbs )) }}++-- A ktype is a ctype, possibly with a kind annotation+ktype :: { LHsType GhcPs }+ : ctype { $1 }+ | ctype '::' kind {% acsA (\cs -> sLLAA $1 $> $ HsKindSig (EpAnn (glAR $1) [mu AnnDcolon $2] cs) $1 $3) }++-- A ctype is a for-all type+ctype :: { LHsType GhcPs }+ : forall_telescope ctype { reLocA $ sLL $1 (reLoc $>) $+ HsForAllTy { hst_tele = unLoc $1+ , hst_xforall = noExtField+ , hst_body = $2 } }+ | context '=>' ctype {% acsA (\cs -> (sLL (reLoc $1) (reLoc $>) $+ HsQualTy { hst_ctxt = Just (addTrailingDarrowC $1 $2 cs)+ , hst_xqual = NoExtField+ , hst_body = $3 })) }++ | ipvar '::' type {% acsA (\cs -> sLL $1 (reLoc $>) (HsIParamTy (EpAnn (glR $1) [mu AnnDcolon $2] cs) $1 $3)) }+ | type { $1 }++----------------------+-- Notes for 'context'+-- We parse a context as a btype so that we don't get reduce/reduce+-- errors in ctype. The basic problem is that+-- (Eq a, Ord a)+-- looks so much like a tuple type. We can't tell until we find the =>++context :: { LHsContext GhcPs }+ : btype {% checkContext $1 }++{- Note [GADT decl discards annotations]+~~~~~~~~~~~~~~~~~~~~~+The type production for++ btype `->` ctype++add the AnnRarrow annotation twice, in different places.++This is because if the type is processed as usual, it belongs on the annotations+for the type as a whole.++But if the type is passed to mkGadtDecl, it discards the top level SrcSpan, and+the top-level annotation will be disconnected. Hence for this specific case it+is connected to the first type too.+-}++type :: { LHsType GhcPs }+ -- See Note [%shift: type -> btype]+ : btype %shift { $1 }+ | btype '->' ctype {% acsA (\cs -> sLL (reLoc $1) (reLoc $>)+ $ HsFunTy (EpAnn (glAR $1) (mau $2) cs) (HsUnrestrictedArrow (toUnicode $2)) $1 $3) }++ | btype mult '->' ctype {% hintLinear (getLoc $2)+ >> let arr = (unLoc $2) (toUnicode $3)+ in acsA (\cs -> sLL (reLoc $1) (reLoc $>)+ $ HsFunTy (EpAnn (glAR $1) (mau $3) cs) arr $1 $4) }++ | btype '->.' ctype {% hintLinear (getLoc $2) >>+ acsA (\cs -> sLL (reLoc $1) (reLoc $>)+ $ HsFunTy (EpAnn (glAR $1) (mlu $2) cs) (HsLinearArrow UnicodeSyntax Nothing) $1 $3) }+ -- [mu AnnLollyU $2] }++mult :: { Located (IsUnicodeSyntax -> HsArrow GhcPs) }+ : PREFIX_PERCENT atype { sLL $1 (reLoc $>) (\u -> mkMultTy u $1 $2) }++btype :: { LHsType GhcPs }+ : infixtype {% runPV $1 }++infixtype :: { forall b. DisambTD b => PV (LocatedA b) }+ -- See Note [%shift: infixtype -> ftype]+ : ftype %shift { $1 }+ | ftype tyop infixtype { $1 >>= \ $1 ->+ $3 >>= \ $3 ->+ do { when (looksLikeMult $1 $2 $3) $ hintLinear (getLocA $2)+ ; mkHsOpTyPV $1 $2 $3 } }+ | unpackedness infixtype { $2 >>= \ $2 ->+ mkUnpackednessPV $1 $2 }++ftype :: { forall b. DisambTD b => PV (LocatedA b) }+ : atype { mkHsAppTyHeadPV $1 }+ | tyop { failOpFewArgs $1 }+ | ftype tyarg { $1 >>= \ $1 ->+ mkHsAppTyPV $1 $2 }+ | ftype PREFIX_AT atype { $1 >>= \ $1 ->+ mkHsAppKindTyPV $1 (getLoc $2) $3 }++tyarg :: { LHsType GhcPs }+ : atype { $1 }+ | unpackedness atype {% addUnpackednessP $1 $2 }++tyop :: { LocatedN RdrName }+ : qtyconop { $1 }+ | tyvarop { $1 }+ | SIMPLEQUOTE qconop {% amsrn (sLL $1 (reLoc $>) (unLoc $2))+ (NameAnnQuote (glAA $1) (gl $2) []) }+ | SIMPLEQUOTE varop {% amsrn (sLL $1 (reLoc $>) (unLoc $2))+ (NameAnnQuote (glAA $1) (gl $2) []) }++atype :: { LHsType GhcPs }+ : ntgtycon {% acsa (\cs -> sL1a (reLocN $1) (HsTyVar (EpAnn (glNR $1) [] cs) NotPromoted $1)) } -- Not including unit tuples+ -- See Note [%shift: atype -> tyvar]+ | tyvar %shift {% acsa (\cs -> sL1a (reLocN $1) (HsTyVar (EpAnn (glNR $1) [] cs) NotPromoted $1)) } -- (See Note [Unit tuples])+ | '*' {% do { warnStarIsType (getLoc $1)+ ; return $ reLocA $ sL1 $1 (HsStarTy noExtField (isUnicode $1)) } }++ -- See Note [Whitespace-sensitive operator parsing] in GHC.Parser.Lexer+ | PREFIX_TILDE atype {% acsA (\cs -> sLLlA $1 $> (mkBangTy (EpAnn (glR $1) [mj AnnTilde $1] cs) SrcLazy $2)) }+ | PREFIX_BANG atype {% acsA (\cs -> sLLlA $1 $> (mkBangTy (EpAnn (glR $1) [mj AnnBang $1] cs) SrcStrict $2)) }++ | '{' fielddecls '}' {% do { decls <- acsA (\cs -> (sLL $1 $> $ HsRecTy (EpAnn (glR $1) (AnnList (Just $ listAsAnchor $2) (Just $ moc $1) (Just $ mcc $3) [] []) cs) $2))+ ; checkRecordSyntax decls }}+ -- Constructor sigs only+ | '(' ')' {% acsA (\cs -> sLL $1 $> $ HsTupleTy (EpAnn (glR $1) (AnnParen AnnParens (glAA $1) (glAA $2)) cs)+ HsBoxedOrConstraintTuple []) }+ | '(' ktype ',' comma_types1 ')' {% do { h <- addTrailingCommaA $2 (gl $3)+ ; acsA (\cs -> sLL $1 $> $ HsTupleTy (EpAnn (glR $1) (AnnParen AnnParens (glAA $1) (glAA $5)) cs)+ HsBoxedOrConstraintTuple (h : $4)) }}+ | '(#' '#)' {% acsA (\cs -> sLL $1 $> $ HsTupleTy (EpAnn (glR $1) (AnnParen AnnParensHash (glAA $1) (glAA $2)) cs) HsUnboxedTuple []) }+ | '(#' comma_types1 '#)' {% acsA (\cs -> sLL $1 $> $ HsTupleTy (EpAnn (glR $1) (AnnParen AnnParensHash (glAA $1) (glAA $3)) cs) HsUnboxedTuple $2) }+ | '(#' bar_types2 '#)' {% acsA (\cs -> sLL $1 $> $ HsSumTy (EpAnn (glR $1) (AnnParen AnnParensHash (glAA $1) (glAA $3)) cs) $2) }+ | '[' ktype ']' {% acsA (\cs -> sLL $1 $> $ HsListTy (EpAnn (glR $1) (AnnParen AnnParensSquare (glAA $1) (glAA $3)) cs) $2) }+ | '(' ktype ')' {% acsA (\cs -> sLL $1 $> $ HsParTy (EpAnn (glR $1) (AnnParen AnnParens (glAA $1) (glAA $3)) cs) $2) }+ | quasiquote { mapLocA (HsSpliceTy noExtField) $1 }+ | splice_untyped { mapLocA (HsSpliceTy noExtField) $1 }+ -- see Note [Promotion] for the followings+ | SIMPLEQUOTE qcon_nowiredlist {% acsA (\cs -> sLL $1 (reLocN $>) $ HsTyVar (EpAnn (glR $1) [mj AnnSimpleQuote $1,mjN AnnName $2] cs) IsPromoted $2) }+ | SIMPLEQUOTE '(' ktype ',' comma_types1 ')'+ {% do { h <- addTrailingCommaA $3 (gl $4)+ ; acsA (\cs -> sLL $1 $> $ HsExplicitTupleTy (EpAnn (glR $1) [mj AnnSimpleQuote $1,mop $2,mcp $6] cs) (h : $5)) }}+ | SIMPLEQUOTE '[' comma_types0 ']' {% acsA (\cs -> sLL $1 $> $ HsExplicitListTy (EpAnn (glR $1) [mj AnnSimpleQuote $1,mos $2,mcs $4] cs) IsPromoted $3) }+ | SIMPLEQUOTE var {% acsA (\cs -> sLL $1 (reLocN $>) $ HsTyVar (EpAnn (glR $1) [mj AnnSimpleQuote $1,mjN AnnName $2] cs) IsPromoted $2) }++ -- Two or more [ty, ty, ty] must be a promoted list type, just as+ -- if you had written '[ty, ty, ty]+ -- (One means a list type, zero means the list type constructor,+ -- so you have to quote those.)+ | '[' ktype ',' comma_types1 ']' {% do { h <- addTrailingCommaA $2 (gl $3)+ ; acsA (\cs -> sLL $1 $> $ HsExplicitListTy (EpAnn (glR $1) [mos $1,mcs $5] cs) NotPromoted (h:$4)) }}+ | INTEGER { reLocA $ sLL $1 $> $ HsTyLit noExtField $ HsNumTy (getINTEGERs $1)+ (il_value (getINTEGER $1)) }+ | CHAR { reLocA $ sLL $1 $> $ HsTyLit noExtField $ HsCharTy (getCHARs $1)+ (getCHAR $1) }+ | STRING { reLocA $ sLL $1 $> $ HsTyLit noExtField $ HsStrTy (getSTRINGs $1)+ (getSTRING $1) }+ | '_' { reLocA $ sL1 $1 $ mkAnonWildCardTy }++-- An inst_type is what occurs in the head of an instance decl+-- e.g. (Foo a, Gaz b) => Wibble a b+-- It's kept as a single type for convenience.+inst_type :: { LHsSigType GhcPs }+ : sigtype { $1 }++deriv_types :: { [LHsSigType GhcPs] }+ : sigktype { [$1] }++ | sigktype ',' deriv_types {% do { h <- addTrailingCommaA $1 (gl $2)+ ; return (h : $3) } }++comma_types0 :: { [LHsType GhcPs] } -- Zero or more: ty,ty,ty+ : comma_types1 { $1 }+ | {- empty -} { [] }++comma_types1 :: { [LHsType GhcPs] } -- One or more: ty,ty,ty+ : ktype { [$1] }+ | ktype ',' comma_types1 {% do { h <- addTrailingCommaA $1 (gl $2)+ ; return (h : $3) }}++bar_types2 :: { [LHsType GhcPs] } -- Two or more: ty|ty|ty+ : ktype '|' ktype {% do { h <- addTrailingVbarA $1 (gl $2)+ ; return [h,$3] }}+ | ktype '|' bar_types2 {% do { h <- addTrailingVbarA $1 (gl $2)+ ; return (h : $3) }}++tv_bndrs :: { [LHsTyVarBndr Specificity GhcPs] }+ : tv_bndr tv_bndrs { $1 : $2 }+ | {- empty -} { [] }++tv_bndr :: { LHsTyVarBndr Specificity GhcPs }+ : tv_bndr_no_braces { $1 }+ | '{' tyvar '}' {% acsA (\cs -> sLL $1 $> (UserTyVar (EpAnn (glR $1) [moc $1, mcc $3] cs) InferredSpec $2)) }+ | '{' tyvar '::' kind '}' {% acsA (\cs -> sLL $1 $> (KindedTyVar (EpAnn (glR $1) [moc $1,mu AnnDcolon $3 ,mcc $5] cs) InferredSpec $2 $4)) }++tv_bndr_no_braces :: { LHsTyVarBndr Specificity GhcPs }+ : tyvar {% acsA (\cs -> (sL1 (reLocN $1) (UserTyVar (EpAnn (glNR $1) [] cs) SpecifiedSpec $1))) }+ | '(' tyvar '::' kind ')' {% acsA (\cs -> (sLL $1 $> (KindedTyVar (EpAnn (glR $1) [mop $1,mu AnnDcolon $3 ,mcp $5] cs) SpecifiedSpec $2 $4))) }++fds :: { Located ([AddEpAnn],[LHsFunDep GhcPs]) }+ : {- empty -} { noLoc ([],[]) }+ | '|' fds1 { (sLL $1 $> ([mj AnnVbar $1]+ ,reverse (unLoc $2))) }++fds1 :: { Located [LHsFunDep GhcPs] }+ : fds1 ',' fd {%+ do { let (h:t) = unLoc $1 -- Safe from fds1 rules+ ; h' <- addTrailingCommaA h (gl $2)+ ; return (sLLlA $1 $> ($3 : h' : t)) }}+ | fd { sL1A $1 [$1] }++fd :: { LHsFunDep GhcPs }+ : varids0 '->' varids0 {% acsA (\cs -> L (comb3 $1 $2 $3)+ (FunDep (EpAnn (glR $1) [mu AnnRarrow $2] cs)+ (reverse (unLoc $1))+ (reverse (unLoc $3)))) }++varids0 :: { Located [LocatedN RdrName] }+ : {- empty -} { noLoc [] }+ | varids0 tyvar { sLL $1 (reLocN $>) ($2 : (unLoc $1)) }++-----------------------------------------------------------------------------+-- Kinds++kind :: { LHsKind GhcPs }+ : ctype { $1 }++{- Note [Promotion]+ ~~~~~~~~~~~~~~~~++- Syntax of promoted qualified names+We write 'Nat.Zero instead of Nat.'Zero when dealing with qualified+names. Moreover ticks are only allowed in types, not in kinds, for a+few reasons:+ 1. we don't need quotes since we cannot define names in kinds+ 2. if one day we merge types and kinds, tick would mean look in DataName+ 3. we don't have a kind namespace anyway++- Name resolution+When the user write Zero instead of 'Zero in types, we parse it a+HsTyVar ("Zero", TcClsName) instead of HsTyVar ("Zero", DataName). We+deal with this in the renamer. If a HsTyVar ("Zero", TcClsName) is not+bounded in the type level, then we look for it in the term level (we+change its namespace to DataName, see Note [Demotion] in GHC.Types.Names.OccName).+And both become a HsTyVar ("Zero", DataName) after the renamer.++-}+++-----------------------------------------------------------------------------+-- Datatype declarations++gadt_constrlist :: { Located ([AddEpAnn]+ ,[LConDecl GhcPs]) } -- Returned in order++ : 'where' '{' gadt_constrs '}' {% checkEmptyGADTs $+ L (comb2 $1 $3)+ ([mj AnnWhere $1+ ,moc $2+ ,mcc $4]+ , unLoc $3) }+ | 'where' vocurly gadt_constrs close {% checkEmptyGADTs $+ L (comb2 $1 $3)+ ([mj AnnWhere $1]+ , unLoc $3) }+ | {- empty -} { noLoc ([],[]) }++gadt_constrs :: { Located [LConDecl GhcPs] }+ : gadt_constr ';' gadt_constrs+ {% do { h <- addTrailingSemiA $1 (gl $2)+ ; return (L (comb2 (reLoc $1) $3) (h : unLoc $3)) }}+ | gadt_constr { L (glA $1) [$1] }+ | {- empty -} { noLoc [] }++-- We allow the following forms:+-- C :: Eq a => a -> T a+-- C :: forall a. Eq a => !a -> T a+-- D { x,y :: a } :: T a+-- forall a. Eq a => D { x,y :: a } :: T a++gadt_constr :: { LConDecl GhcPs }+ -- see Note [Difference in parsing GADT and data constructors]+ -- Returns a list because of: C,D :: ty+ -- TODO:AZ capture the optSemi. Why leading?+ : optSemi con_list '::' sigtype+ {% mkGadtDecl (comb2A $2 $>) (unLoc $2) $4 [mu AnnDcolon $3] }++{- Note [Difference in parsing GADT and data constructors]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+GADT constructors have simpler syntax than usual data constructors:+in GADTs, types cannot occur to the left of '::', so they cannot be mixed+with constructor names (see Note [Parsing data constructors is hard]).++Due to simplified syntax, GADT constructor names (left-hand side of '::')+use simpler grammar production than usual data constructor names. As a+consequence, GADT constructor names are restricted (names like '(*)' are+allowed in usual data constructors, but not in GADTs).+-}++constrs :: { Located ([AddEpAnn],[LConDecl GhcPs]) }+ : '=' constrs1 { sLL $1 $2 ([mj AnnEqual $1],unLoc $2)}++constrs1 :: { Located [LConDecl GhcPs] }+ : constrs1 '|' constr+ {% do { let (h:t) = unLoc $1+ ; h' <- addTrailingVbarA h (gl $2)+ ; return (sLLlA $1 $> ($3 : h' : t)) }}+ | constr { sL1A $1 [$1] }++constr :: { LConDecl GhcPs }+ : forall context '=>' constr_stuff+ {% acsA (\cs -> let (con,details) = unLoc $4 in+ (L (comb4 $1 (reLoc $2) $3 $4) (mkConDeclH98+ (EpAnn (spanAsAnchor (comb4 $1 (reLoc $2) $3 $4))+ (mu AnnDarrow $3:(fst $ unLoc $1)) cs)+ con+ (snd $ unLoc $1)+ (Just $2)+ details))) }+ | forall constr_stuff+ {% acsA (\cs -> let (con,details) = unLoc $2 in+ (L (comb2 $1 $2) (mkConDeclH98 (EpAnn (spanAsAnchor (comb2 $1 $2)) (fst $ unLoc $1) cs)+ con+ (snd $ unLoc $1)+ Nothing -- No context+ details))) }++forall :: { Located ([AddEpAnn], Maybe [LHsTyVarBndr Specificity GhcPs]) }+ : 'forall' tv_bndrs '.' { sLL $1 $> ([mu AnnForall $1,mj AnnDot $3], Just $2) }+ | {- empty -} { noLoc ([], Nothing) }++constr_stuff :: { Located (LocatedN RdrName, HsConDeclH98Details GhcPs) }+ : infixtype {% fmap (reLoc. (mapLoc (\b -> (dataConBuilderCon b,+ dataConBuilderDetails b))))+ (runPV $1) }++fielddecls :: { [LConDeclField GhcPs] }+ : {- empty -} { [] }+ | fielddecls1 { $1 }++fielddecls1 :: { [LConDeclField GhcPs] }+ : fielddecl ',' fielddecls1+ {% do { h <- addTrailingCommaA $1 (gl $2)+ ; return (h : $3) }}+ | fielddecl { [$1] }++fielddecl :: { LConDeclField GhcPs }+ -- A list because of f,g :: Int+ : sig_vars '::' ctype+ {% acsA (\cs -> L (comb2 $1 (reLoc $3))+ (ConDeclField (EpAnn (glR $1) [mu AnnDcolon $2] cs)+ (reverse (map (\ln@(L l n) -> L (locA l) $ FieldOcc noExtField ln) (unLoc $1))) $3 Nothing))}++-- Reversed!+maybe_derivings :: { Located (HsDeriving GhcPs) }+ : {- empty -} { noLoc [] }+ | derivings { $1 }++-- A list of one or more deriving clauses at the end of a datatype+derivings :: { Located (HsDeriving GhcPs) }+ : derivings deriving { sLL $1 $> ($2 : unLoc $1) } -- AZ: order?+ | deriving { sLL $1 $> [$1] }++-- The outer Located is just to allow the caller to+-- know the rightmost extremity of the 'deriving' clause+deriving :: { LHsDerivingClause GhcPs }+ : 'deriving' deriv_clause_types+ {% let { full_loc = comb2A $1 $> }+ in acs (\cs -> L full_loc $ HsDerivingClause (EpAnn (glR $1) [mj AnnDeriving $1] cs) Nothing $2) }++ | 'deriving' deriv_strategy_no_via deriv_clause_types+ {% let { full_loc = comb2A $1 $> }+ in acs (\cs -> L full_loc $ HsDerivingClause (EpAnn (glR $1) [mj AnnDeriving $1] cs) (Just $2) $3) }++ | 'deriving' deriv_clause_types deriv_strategy_via+ {% let { full_loc = comb2 $1 $> }+ in acs (\cs -> L full_loc $ HsDerivingClause (EpAnn (glR $1) [mj AnnDeriving $1] cs) (Just $3) $2) }++deriv_clause_types :: { LDerivClauseTys GhcPs }+ : qtycon { let { tc = sL1 (reLocL $1) $ mkHsImplicitSigType $+ sL1 (reLocL $1) $ HsTyVar noAnn NotPromoted $1 } in+ sL1 (reLocC $1) (DctSingle noExtField tc) }+ | '(' ')' {% amsrc (sLL $1 $> (DctMulti noExtField []))+ (AnnContext Nothing [glAA $1] [glAA $2]) }+ | '(' deriv_types ')' {% amsrc (sLL $1 $> (DctMulti noExtField $2))+ (AnnContext Nothing [glAA $1] [glAA $3])}++-----------------------------------------------------------------------------+-- Value definitions++{- Note [Declaration/signature overlap]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+There's an awkward overlap with a type signature. Consider+ f :: Int -> Int = ...rhs...+ Then we can't tell whether it's a type signature or a value+ definition with a result signature until we see the '='.+ So we have to inline enough to postpone reductions until we know.+-}++{-+ ATTENTION: Dirty Hackery Ahead! If the second alternative of vars is var+ instead of qvar, we get another shift/reduce-conflict. Consider the+ following programs:++ { (^^) :: Int->Int ; } Type signature; only var allowed++ { (^^) :: Int->Int = ... ; } Value defn with result signature;+ qvar allowed (because of instance decls)++ We can't tell whether to reduce var to qvar until after we've read the signatures.+-}++decl_no_th :: { LHsDecl GhcPs }+ : sigdecl { $1 }++ | infixexp opt_sig rhs {% runPV (unECP $1) >>= \ $1 ->+ do { let { l = comb2Al $1 $> }+ ; r <- checkValDef l $1 $2 $3;+ -- Depending upon what the pattern looks like we might get either+ -- a FunBind or PatBind back from checkValDef. See Note+ -- [FunBind vs PatBind]+ ; cs <- getCommentsFor l+ ; return $! (sL (commentsA l cs) $ ValD noExtField r) } }+ | pattern_synonym_decl { $1 }++decl :: { LHsDecl GhcPs }+ : decl_no_th { $1 }++ -- Why do we only allow naked declaration splices in top-level+ -- declarations and not here? Short answer: because readFail009+ -- fails terribly with a panic in cvBindsAndSigs otherwise.+ | splice_exp {% mkSpliceDecl $1 }++rhs :: { Located (GRHSs GhcPs (LHsExpr GhcPs)) }+ : '=' exp wherebinds {% runPV (unECP $2) >>= \ $2 ->+ do { let L l (bs, csw) = adaptWhereBinds $3+ ; let loc = (comb3 $1 (reLoc $2) (L l bs))+ ; acs (\cs ->+ sL loc (GRHSs csw (unguardedRHS (EpAnn (anc $ rs loc) (GrhsAnn Nothing (mj AnnEqual $1)) cs) loc $2)+ bs)) } }+ | gdrhs wherebinds {% do { let {L l (bs, csw) = adaptWhereBinds $2}+ ; acs (\cs -> sL (comb2 $1 (L l bs))+ (GRHSs (cs Semi.<> csw) (reverse (unLoc $1)) bs)) }}++gdrhs :: { Located [LGRHS GhcPs (LHsExpr GhcPs)] }+ : gdrhs gdrh { sLL $1 $> ($2 : unLoc $1) }+ | gdrh { sL1 $1 [$1] }++gdrh :: { LGRHS GhcPs (LHsExpr GhcPs) }+ : '|' guardquals '=' exp {% runPV (unECP $4) >>= \ $4 ->+ acs (\cs -> sL (comb2A $1 $>) $ GRHS (EpAnn (glR $1) (GrhsAnn (Just $ glAA $1) (mj AnnEqual $3)) cs) (unLoc $2) $4) }++sigdecl :: { LHsDecl GhcPs }+ :+ -- See Note [Declaration/signature overlap] for why we need infixexp here+ infixexp '::' sigtype+ {% do { $1 <- runPV (unECP $1)+ ; v <- checkValSigLhs $1+ ; acsA (\cs -> (sLLAl $1 (reLoc $>) $ SigD noExtField $+ TypeSig (EpAnn (glAR $1) (AnnSig (mu AnnDcolon $2) []) cs) [v] (mkHsWildCardBndrs $3)))} }++ | var ',' sig_vars '::' sigtype+ {% do { v <- addTrailingCommaN $1 (gl $2)+ ; let sig cs = TypeSig (EpAnn (glNR $1) (AnnSig (mu AnnDcolon $4) []) cs) (v : reverse (unLoc $3))+ (mkHsWildCardBndrs $5)+ ; acsA (\cs -> sLL (reLocN $1) (reLoc $>) $ SigD noExtField (sig cs) ) }}++ | infix prec ops+ {% do { mbPrecAnn <- traverse (\l2 -> do { checkPrecP l2 $3+ ; pure (mj AnnVal l2) })+ $2+ ; let (fixText, fixPrec) = case $2 of+ -- If an explicit precedence isn't supplied,+ -- it defaults to maxPrecedence+ Nothing -> (NoSourceText, maxPrecedence)+ Just l2 -> (fst $ unLoc l2, snd $ unLoc l2)+ ; acsA (\cs -> sLL $1 $> $ SigD noExtField+ (FixSig (EpAnn (glR $1) (mj AnnInfix $1 : maybeToList mbPrecAnn) cs) (FixitySig noExtField (fromOL $ unLoc $3)+ (Fixity fixText fixPrec (unLoc $1)))))+ }}++ | pattern_synonym_sig { sL1 $1 . SigD noExtField . unLoc $ $1 }++ | '{-# COMPLETE' con_list opt_tyconsig '#-}'+ {% let (dcolon, tc) = $3+ in acsA+ (\cs -> sLL $1 $>+ (SigD noExtField (CompleteMatchSig (EpAnn (glR $1) ([ mo $1 ] ++ dcolon ++ [mc $4]) cs) (getCOMPLETE_PRAGs $1) $2 tc))) }++ -- This rule is for both INLINE and INLINABLE pragmas+ | '{-# INLINE' activation qvarcon '#-}'+ {% acsA (\cs -> (sLL $1 $> $ SigD noExtField (InlineSig (EpAnn (glR $1) ((mo $1:fst $2) ++ [mc $4]) cs) $3+ (mkInlinePragma (getINLINE_PRAGs $1) (getINLINE $1)+ (snd $2))))) }++ | '{-# SCC' qvar '#-}'+ {% acsA (\cs -> sLL $1 $> (SigD noExtField (SCCFunSig (EpAnn (glR $1) [mo $1, mc $3] cs) (getSCC_PRAGs $1) $2 Nothing))) }++ | '{-# SCC' qvar STRING '#-}'+ {% do { scc <- getSCC $3+ ; let str_lit = StringLiteral (getSTRINGs $3) scc Nothing+ ; acsA (\cs -> sLL $1 $> (SigD noExtField (SCCFunSig (EpAnn (glR $1) [mo $1, mc $4] cs) (getSCC_PRAGs $1) $2 (Just ( sL1 $3 str_lit))))) }}++ | '{-# SPECIALISE' activation qvar '::' sigtypes1 '#-}'+ {% acsA (\cs ->+ let inl_prag = mkInlinePragma (getSPEC_PRAGs $1)+ (NoUserInlinePrag, FunLike) (snd $2)+ in sLL $1 $> $ SigD noExtField (SpecSig (EpAnn (glR $1) (mo $1:mu AnnDcolon $4:mc $6:(fst $2)) cs) $3 (fromOL $5) inl_prag)) }++ | '{-# SPECIALISE_INLINE' activation qvar '::' sigtypes1 '#-}'+ {% acsA (\cs -> sLL $1 $> $ SigD noExtField (SpecSig (EpAnn (glR $1) (mo $1:mu AnnDcolon $4:mc $6:(fst $2)) cs) $3 (fromOL $5)+ (mkInlinePragma (getSPEC_INLINE_PRAGs $1)+ (getSPEC_INLINE $1) (snd $2)))) }++ | '{-# SPECIALISE' 'instance' inst_type '#-}'+ {% acsA (\cs -> sLL $1 $>+ $ SigD noExtField (SpecInstSig (EpAnn (glR $1) [mo $1,mj AnnInstance $2,mc $4] cs) (getSPEC_PRAGs $1) $3)) }++ -- A minimal complete definition+ | '{-# MINIMAL' name_boolformula_opt '#-}'+ {% acsA (\cs -> sLL $1 $> $ SigD noExtField (MinimalSig (EpAnn (glR $1) [mo $1,mc $3] cs) (getMINIMAL_PRAGs $1) $2)) }++activation :: { ([AddEpAnn],Maybe Activation) }+ -- See Note [%shift: activation -> {- empty -}]+ : {- empty -} %shift { ([],Nothing) }+ | explicit_activation { (fst $1,Just (snd $1)) }++explicit_activation :: { ([AddEpAnn],Activation) } -- In brackets+ : '[' INTEGER ']' { ([mj AnnOpenS $1,mj AnnVal $2,mj AnnCloseS $3]+ ,ActiveAfter (getINTEGERs $2) (fromInteger (il_value (getINTEGER $2)))) }+ | '[' rule_activation_marker INTEGER ']'+ { ($2++[mj AnnOpenS $1,mj AnnVal $3,mj AnnCloseS $4]+ ,ActiveBefore (getINTEGERs $3) (fromInteger (il_value (getINTEGER $3)))) }++-----------------------------------------------------------------------------+-- Expressions++quasiquote :: { Located (HsSplice GhcPs) }+ : TH_QUASIQUOTE { let { loc = getLoc $1+ ; ITquasiQuote (quoter, quote, quoteSpan) = unLoc $1+ ; quoterId = mkUnqual varName quoter }+ in sL1 $1 (mkHsQuasiQuote quoterId (mkSrcSpanPs quoteSpan) quote) }+ | TH_QQUASIQUOTE { let { loc = getLoc $1+ ; ITqQuasiQuote (qual, quoter, quote, quoteSpan) = unLoc $1+ ; quoterId = mkQual varName (qual, quoter) }+ in sL1 $1 (mkHsQuasiQuote quoterId (mkSrcSpanPs quoteSpan) quote) }++exp :: { ECP }+ : infixexp '::' ctype+ { ECP $+ unECP $1 >>= \ $1 ->+ rejectPragmaPV $1 >>+ mkHsTySigPV (noAnnSrcSpan $ comb2Al $1 (reLoc $>)) $1 $3+ [(mu AnnDcolon $2)] }+ | infixexp '-<' exp {% runPV (unECP $1) >>= \ $1 ->+ runPV (unECP $3) >>= \ $3 ->+ fmap ecpFromCmd $+ acsA (\cs -> sLLAA $1 $> $ HsCmdArrApp (EpAnn (glAR $1) (mu Annlarrowtail $2) cs) $1 $3+ HsFirstOrderApp True) }+ | infixexp '>-' exp {% runPV (unECP $1) >>= \ $1 ->+ runPV (unECP $3) >>= \ $3 ->+ fmap ecpFromCmd $+ acsA (\cs -> sLLAA $1 $> $ HsCmdArrApp (EpAnn (glAR $1) (mu Annrarrowtail $2) cs) $3 $1+ HsFirstOrderApp False) }+ | infixexp '-<<' exp {% runPV (unECP $1) >>= \ $1 ->+ runPV (unECP $3) >>= \ $3 ->+ fmap ecpFromCmd $+ acsA (\cs -> sLLAA $1 $> $ HsCmdArrApp (EpAnn (glAR $1) (mu AnnLarrowtail $2) cs) $1 $3+ HsHigherOrderApp True) }+ | infixexp '>>-' exp {% runPV (unECP $1) >>= \ $1 ->+ runPV (unECP $3) >>= \ $3 ->+ fmap ecpFromCmd $+ acsA (\cs -> sLLAA $1 $> $ HsCmdArrApp (EpAnn (glAR $1) (mu AnnRarrowtail $2) cs) $3 $1+ HsHigherOrderApp False) }+ -- See Note [%shift: exp -> infixexp]+ | infixexp %shift { $1 }+ | exp_prag(exp) { $1 } -- See Note [Pragmas and operator fixity]++infixexp :: { ECP }+ : exp10 { $1 }+ | infixexp qop exp10p -- See Note [Pragmas and operator fixity]+ { ECP $+ superInfixOp $+ $2 >>= \ $2 ->+ unECP $1 >>= \ $1 ->+ unECP $3 >>= \ $3 ->+ rejectPragmaPV $1 >>+ (mkHsOpAppPV (comb2A (reLoc $1) $3) $1 $2 $3) }+ -- AnnVal annotation for NPlusKPat, which discards the operator++exp10p :: { ECP }+ : exp10 { $1 }+ | exp_prag(exp10p) { $1 } -- See Note [Pragmas and operator fixity]++exp_prag(e) :: { ECP }+ : prag_e e -- See Note [Pragmas and operator fixity]+ {% runPV (unECP $2) >>= \ $2 ->+ fmap ecpFromExp $+ return $ (reLocA $ sLLlA $1 $> $ HsPragE noExtField (unLoc $1) $2) }++exp10 :: { ECP }+ -- See Note [%shift: exp10 -> '-' fexp]+ : '-' fexp %shift { ECP $+ unECP $2 >>= \ $2 ->+ mkHsNegAppPV (comb2A $1 $>) $2+ [mj AnnMinus $1] }+ -- See Note [%shift: exp10 -> fexp]+ | fexp %shift { $1 }++optSemi :: { (Maybe EpaLocation,Bool) }+ : ';' { (msemim $1,True) }+ | {- empty -} { (Nothing,False) }++{- Note [Pragmas and operator fixity]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+'prag_e' is an expression pragma, such as {-# SCC ... #-}.++It must be used with care, or else #15730 happens. Consider this infix+expression:++ 1 / 2 / 2++There are two ways to parse it:++ 1. (1 / 2) / 2 = 0.25+ 2. 1 / (2 / 2) = 1.0++Due to the fixity of the (/) operator (assuming it comes from Prelude),+option 1 is the correct parse. However, in the past GHC's parser used to get+confused by the SCC annotation when it occurred in the middle of an infix+expression:++ 1 / {-# SCC ann #-} 2 / 2 -- used to get parsed as option 2++There are several ways to address this issue, see GHC Proposal #176 for a+detailed exposition:++ https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0176-scc-parsing.rst++The accepted fix is to disallow pragmas that occur within infix expressions.+Infix expressions are assembled out of 'exp10', so 'exp10' must not accept+pragmas. Instead, we accept them in exactly two places:++* at the start of an expression or a parenthesized subexpression:++ f = {-# SCC ann #-} 1 / 2 / 2 -- at the start of the expression+ g = 5 + ({-# SCC ann #-} 1 / 2 / 2) -- at the start of a parenthesized subexpression++* immediately after the last operator:++ f = 1 / 2 / {-# SCC ann #-} 2++In both cases, the parse does not depend on operator fixity. The second case+may sound unnecessary, but it's actually needed to support a common idiom:++ f $ {-# SCC ann $-} ...++-}+prag_e :: { Located (HsPragE GhcPs) }+ : '{-# SCC' STRING '#-}' {% do { scc <- getSCC $2+ ; acs (\cs -> (sLL $1 $>+ (HsPragSCC+ (EpAnn (glR $1) (AnnPragma (mo $1) (mc $3) [mj AnnValStr $2]) cs)+ (getSCC_PRAGs $1)+ (StringLiteral (getSTRINGs $2) scc Nothing))))} }+ | '{-# SCC' VARID '#-}' {% acs (\cs -> (sLL $1 $>+ (HsPragSCC+ (EpAnn (glR $1) (AnnPragma (mo $1) (mc $3) [mj AnnVal $2]) cs)+ (getSCC_PRAGs $1)+ (StringLiteral NoSourceText (getVARID $2) Nothing)))) }++fexp :: { ECP }+ : fexp aexp { ECP $+ superFunArg $+ unECP $1 >>= \ $1 ->+ unECP $2 >>= \ $2 ->+ mkHsAppPV (noAnnSrcSpan $ comb2A (reLoc $1) $>) $1 $2 }++ -- See Note [Whitespace-sensitive operator parsing] in GHC.Parser.Lexer+ | fexp PREFIX_AT atype { ECP $+ unECP $1 >>= \ $1 ->+ mkHsAppTypePV (noAnnSrcSpan $ comb2 (reLoc $1) (reLoc $>)) $1 (getLoc $2) $3 }++ | 'static' aexp {% runPV (unECP $2) >>= \ $2 ->+ fmap ecpFromExp $+ acsA (\cs -> sLL $1 (reLoc $>) $ HsStatic (EpAnn (glR $1) [mj AnnStatic $1] cs) $2) }++ | aexp { $1 }++aexp :: { ECP }+ -- See Note [Whitespace-sensitive operator parsing] in GHC.Parser.Lexer+ : qvar TIGHT_INFIX_AT aexp+ { ECP $+ unECP $3 >>= \ $3 ->+ mkHsAsPatPV (comb2 (reLocN $1) (reLoc $>)) $1 $3 [mj AnnAt $2] }+++ -- See Note [Whitespace-sensitive operator parsing] in GHC.Parser.Lexer+ | PREFIX_TILDE aexp { ECP $+ unECP $2 >>= \ $2 ->+ mkHsLazyPatPV (comb2 $1 (reLoc $>)) $2 [mj AnnTilde $1] }+ | PREFIX_BANG aexp { ECP $+ unECP $2 >>= \ $2 ->+ mkHsBangPatPV (comb2 $1 (reLoc $>)) $2 [mj AnnBang $1] }+ | PREFIX_MINUS aexp { ECP $+ unECP $2 >>= \ $2 ->+ mkHsNegAppPV (comb2A $1 $>) $2 [mj AnnMinus $1] }++ | '\\' apat apats '->' exp+ { ECP $+ unECP $5 >>= \ $5 ->+ mkHsLamPV (comb2 $1 (reLoc $>)) (\cs -> mkMatchGroup FromSource+ (reLocA $ sLLlA $1 $>+ [reLocA $ sLLlA $1 $>+ $ Match { m_ext = EpAnn (glR $1) [mj AnnLam $1] cs+ , m_ctxt = LambdaExpr+ , m_pats = $2:$3+ , m_grhss = unguardedGRHSs (comb2 $4 (reLoc $5)) $5 (EpAnn (glR $4) (GrhsAnn Nothing (mu AnnRarrow $4)) emptyComments) }])) }+ | 'let' binds 'in' exp { ECP $+ unECP $4 >>= \ $4 ->+ mkHsLetPV (comb2A $1 $>) (unLoc $2) $4+ (AnnsLet (glAA $1) (glAA $3)) }+ | '\\' 'lcase' altslist+ { ECP $ $3 >>= \ $3 ->+ mkHsLamCasePV (comb2 $1 (reLoc $>)) $3 [mj AnnLam $1,mj AnnCase $2] }+ | 'if' exp optSemi 'then' exp optSemi 'else' exp+ {% runPV (unECP $2) >>= \ ($2 :: LHsExpr GhcPs) ->+ return $ ECP $+ unECP $5 >>= \ $5 ->+ unECP $8 >>= \ $8 ->+ mkHsIfPV (comb2A $1 $>) $2 (snd $3) $5 (snd $6) $8+ (AnnsIf+ { aiIf = glAA $1+ , aiThen = glAA $4+ , aiElse = glAA $7+ , aiThenSemi = fst $3+ , aiElseSemi = fst $6})}++ | 'if' ifgdpats {% hintMultiWayIf (getLoc $1) >>= \_ ->+ fmap ecpFromExp $+ acsA (\cs -> sLL $1 $> $ HsMultiIf (EpAnn (glR $1) (mj AnnIf $1:(fst $ unLoc $2)) cs)+ (reverse $ snd $ unLoc $2)) }+ | 'case' exp 'of' altslist {% runPV (unECP $2) >>= \ ($2 :: LHsExpr GhcPs) ->+ return $ ECP $+ $4 >>= \ $4 ->+ mkHsCasePV (comb3 $1 $3 (reLoc $4)) $2 $4+ (EpAnnHsCase (glAA $1) (glAA $3) []) }+ -- QualifiedDo.+ | DO stmtlist {% do+ hintQualifiedDo $1+ return $ ECP $+ $2 >>= \ $2 ->+ mkHsDoPV (comb2A $1 $2)+ (fmap mkModuleNameFS (getDO $1))+ $2+ (AnnList (Just $ glAR $2) Nothing Nothing [mj AnnDo $1] []) }+ | MDO stmtlist {% hintQualifiedDo $1 >> runPV $2 >>= \ $2 ->+ fmap ecpFromExp $+ acsA (\cs -> L (comb2A $1 $2)+ (mkHsDoAnns (MDoExpr $+ fmap mkModuleNameFS (getMDO $1))+ $2+ (EpAnn (glR $1) (AnnList (Just $ glAR $2) Nothing Nothing [mj AnnMdo $1] []) cs) )) }+ | 'proc' aexp '->' exp+ {% (checkPattern <=< runPV) (unECP $2) >>= \ p ->+ runPV (unECP $4) >>= \ $4@cmd ->+ fmap ecpFromExp $+ acsA (\cs -> sLLlA $1 $> $ HsProc (EpAnn (glR $1) [mj AnnProc $1,mu AnnRarrow $3] cs) p (sLLlA $1 $> $ HsCmdTop noExtField cmd)) }++ | aexp1 { $1 }++aexp1 :: { ECP }+ : aexp1 '{' fbinds '}' { ECP $+ getBit OverloadedRecordUpdateBit >>= \ overloaded ->+ unECP $1 >>= \ $1 ->+ $3 >>= \ $3 ->+ mkHsRecordPV overloaded (comb2 (reLoc $1) $>) (comb2 $2 $4) $1 $3+ [moc $2,mcc $4]+ }++ -- See Note [Whitespace-sensitive operator parsing] in GHC.Parser.Lexer+ | aexp1 TIGHT_INFIX_PROJ field+ {% runPV (unECP $1) >>= \ $1 ->+ fmap ecpFromExp $ acsa (\cs ->+ let fl = sLL $2 $> (HsFieldLabel ((EpAnn (glR $2) (AnnFieldLabel (Just $ glAA $2)) emptyComments)) $3) in+ mkRdrGetField (noAnnSrcSpan $ comb2 (reLoc $1) $>) $1 fl (EpAnn (glAR $1) NoEpAnns cs)) }+++ | aexp2 { $1 }++aexp2 :: { ECP }+ : qvar { ECP $ mkHsVarPV $! $1 }+ | qcon { ECP $ mkHsVarPV $! $1 }+ -- See Note [%shift: aexp2 -> ipvar]+ | ipvar %shift {% acsExpr (\cs -> sL1a $1 (HsIPVar (comment (glRR $1) cs) $! unLoc $1)) }+ | overloaded_label {% acsExpr (\cs -> sL1a $1 (HsOverLabel (comment (glRR $1) cs) $! unLoc $1)) }+ | literal { ECP $ pvA (mkHsLitPV $! $1) }+-- This will enable overloaded strings permanently. Normally the renamer turns HsString+-- into HsOverLit when -foverloaded-strings is on.+-- | STRING { sL (getLoc $1) (HsOverLit $! mkHsIsString (getSTRINGs $1)+-- (getSTRING $1) noExtField) }+ | INTEGER { ECP $ pvA $ mkHsOverLitPV (sL1 $1 $ mkHsIntegral (getINTEGER $1)) }+ | RATIONAL { ECP $ pvA $ mkHsOverLitPV (sL1 $1 $ mkHsFractional (getRATIONAL $1)) }++ -- N.B.: sections get parsed by these next two productions.+ -- This allows you to write, e.g., '(+ 3, 4 -)', which isn't+ -- correct Haskell (you'd have to write '((+ 3), (4 -))')+ -- but the less cluttered version fell out of having texps.+ | '(' texp ')' { ECP $+ unECP $2 >>= \ $2 ->+ mkHsParPV (comb2 $1 $>) $2 (AnnParen AnnParens (glAA $1) (glAA $3)) }+ | '(' tup_exprs ')' { ECP $+ $2 >>= \ $2 ->+ mkSumOrTuplePV (noAnnSrcSpan $ comb2 $1 $>) Boxed $2+ [mop $1,mcp $3]}++ -- This case is only possible when 'OverloadedRecordDotBit' is enabled.+ | '(' projection ')' { ECP $+ acsA (\cs -> sLL $1 $> $ mkRdrProjection (NE.reverse (unLoc $2)) (EpAnn (glR $1) (AnnProjection (glAA $1) (glAA $3)) cs))+ >>= ecpFromExp'+ }++ | '(#' texp '#)' { ECP $+ unECP $2 >>= \ $2 ->+ mkSumOrTuplePV (noAnnSrcSpan $ comb2 $1 $>) Unboxed (Tuple [Right $2])+ [moh $1,mch $3] }+ | '(#' tup_exprs '#)' { ECP $+ $2 >>= \ $2 ->+ mkSumOrTuplePV (noAnnSrcSpan $ comb2 $1 $>) Unboxed $2+ [moh $1,mch $3] }++ | '[' list ']' { ECP $ $2 (comb2 $1 $>) (mos $1,mcs $3) }+ | '_' { ECP $ pvA $ mkHsWildCardPV (getLoc $1) }++ -- Template Haskell Extension+ | splice_untyped { ECP $ pvA $ mkHsSplicePV $1 }+ | splice_typed { ecpFromExp $ mapLoc (HsSpliceE noAnn) (reLocA $1) }++ | SIMPLEQUOTE qvar {% fmap ecpFromExp $ acsA (\cs -> sLL $1 (reLocN $>) $ HsBracket (EpAnn (glR $1) [mj AnnSimpleQuote $1] cs) (VarBr noExtField True $2)) }+ | SIMPLEQUOTE qcon {% fmap ecpFromExp $ acsA (\cs -> sLL $1 (reLocN $>) $ HsBracket (EpAnn (glR $1) [mj AnnSimpleQuote $1] cs) (VarBr noExtField True $2)) }+ | TH_TY_QUOTE tyvar {% fmap ecpFromExp $ acsA (\cs -> sLL $1 (reLocN $>) $ HsBracket (EpAnn (glR $1) [mj AnnThTyQuote $1 ] cs) (VarBr noExtField False $2)) }+ | TH_TY_QUOTE gtycon {% fmap ecpFromExp $ acsA (\cs -> sLL $1 (reLocN $>) $ HsBracket (EpAnn (glR $1) [mj AnnThTyQuote $1 ] cs) (VarBr noExtField False $2)) }+ -- See Note [%shift: aexp2 -> TH_TY_QUOTE]+ | TH_TY_QUOTE %shift {% reportEmptyDoubleQuotes (getLoc $1) }+ | '[|' exp '|]' {% runPV (unECP $2) >>= \ $2 ->+ fmap ecpFromExp $+ acsA (\cs -> sLL $1 $> $ HsBracket (EpAnn (glR $1) (if (hasE $1) then [mj AnnOpenE $1, mu AnnCloseQ $3]+ else [mu AnnOpenEQ $1,mu AnnCloseQ $3]) cs) (ExpBr noExtField $2)) }+ | '[||' exp '||]' {% runPV (unECP $2) >>= \ $2 ->+ fmap ecpFromExp $+ acsA (\cs -> sLL $1 $> $ HsBracket (EpAnn (glR $1) (if (hasE $1) then [mj AnnOpenE $1,mc $3] else [mo $1,mc $3]) cs) (TExpBr noExtField $2)) }+ | '[t|' ktype '|]' {% fmap ecpFromExp $+ acsA (\cs -> sLL $1 $> $ HsBracket (EpAnn (glR $1) [mo $1,mu AnnCloseQ $3] cs) (TypBr noExtField $2)) }+ | '[p|' infixexp '|]' {% (checkPattern <=< runPV) (unECP $2) >>= \p ->+ fmap ecpFromExp $+ acsA (\cs -> sLL $1 $> $ HsBracket (EpAnn (glR $1) [mo $1,mu AnnCloseQ $3] cs) (PatBr noExtField p)) }+ | '[d|' cvtopbody '|]' {% fmap ecpFromExp $+ acsA (\cs -> sLL $1 $> $ HsBracket (EpAnn (glR $1) (mo $1:mu AnnCloseQ $3:fst $2) cs) (DecBrL noExtField (snd $2))) }+ | quasiquote { ECP $ pvA $ mkHsSplicePV $1 }++ -- arrow notation extension+ | '(|' aexp cmdargs '|)' {% runPV (unECP $2) >>= \ $2 ->+ fmap ecpFromCmd $+ acsA (\cs -> sLL $1 $> $ HsCmdArrForm (EpAnn (glR $1) (AnnList (Just $ glR $1) (Just $ mu AnnOpenB $1) (Just $ mu AnnCloseB $4) [] []) cs) $2 Prefix+ Nothing (reverse $3)) }++projection :: { Located (NonEmpty (Located (HsFieldLabel GhcPs))) }+projection+ -- See Note [Whitespace-sensitive operator parsing] in GHC.Parsing.Lexer+ : projection TIGHT_INFIX_PROJ field+ {% acs (\cs -> sLL $1 $> ((sLL $2 $> $ HsFieldLabel (EpAnn (glR $1) (AnnFieldLabel (Just $ glAA $2)) cs) $3) `NE.cons` unLoc $1)) }+ | PREFIX_PROJ field {% acs (\cs -> sLL $1 $> ((sLL $1 $> $ HsFieldLabel (EpAnn (glR $1) (AnnFieldLabel (Just $ glAA $1)) cs) $2) :| [])) }++splice_exp :: { LHsExpr GhcPs }+ : splice_untyped { mapLoc (HsSpliceE noAnn) (reLocA $1) }+ | splice_typed { mapLoc (HsSpliceE noAnn) (reLocA $1) }++splice_untyped :: { Located (HsSplice GhcPs) }+ -- See Note [Whitespace-sensitive operator parsing] in GHC.Parser.Lexer+ : PREFIX_DOLLAR aexp2 {% runPV (unECP $2) >>= \ $2 ->+ acs (\cs -> sLLlA $1 $> $ mkUntypedSplice (EpAnn (glR $1) [mj AnnDollar $1] cs) DollarSplice $2) }++splice_typed :: { Located (HsSplice GhcPs) }+ -- See Note [Whitespace-sensitive operator parsing] in GHC.Parser.Lexer+ : PREFIX_DOLLAR_DOLLAR aexp2+ {% runPV (unECP $2) >>= \ $2 ->+ acs (\cs -> sLLlA $1 $> $ mkTypedSplice (EpAnn (glR $1) [mj AnnDollarDollar $1] cs) DollarSplice $2) }++cmdargs :: { [LHsCmdTop GhcPs] }+ : cmdargs acmd { $2 : $1 }+ | {- empty -} { [] }++acmd :: { LHsCmdTop GhcPs }+ : aexp {% runPV (unECP $1) >>= \ (cmd :: LHsCmd GhcPs) ->+ runPV (checkCmdBlockArguments cmd) >>= \ _ ->+ return (sL1A cmd $ HsCmdTop noExtField cmd) }++cvtopbody :: { ([AddEpAnn],[LHsDecl GhcPs]) }+ : '{' cvtopdecls0 '}' { ([mj AnnOpenC $1+ ,mj AnnCloseC $3],$2) }+ | vocurly cvtopdecls0 close { ([],$2) }++cvtopdecls0 :: { [LHsDecl GhcPs] }+ : topdecls_semi { cvTopDecls $1 }+ | topdecls { cvTopDecls $1 }++-----------------------------------------------------------------------------+-- Tuple expressions++-- "texp" is short for tuple expressions:+-- things that can appear unparenthesized as long as they're+-- inside parens or delimited by commas+texp :: { ECP }+ : exp { $1 }++ -- Note [Parsing sections]+ -- ~~~~~~~~~~~~~~~~~~~~~~~+ -- We include left and right sections here, which isn't+ -- technically right according to the Haskell standard.+ -- For example (3 +, True) isn't legal.+ -- However, we want to parse bang patterns like+ -- (!x, !y)+ -- and it's convenient to do so here as a section+ -- Then when converting expr to pattern we unravel it again+ -- Meanwhile, the renamer checks that real sections appear+ -- inside parens.+ | infixexp qop+ {% runPV (unECP $1) >>= \ $1 ->+ runPV (rejectPragmaPV $1) >>+ runPV $2 >>= \ $2 ->+ return $ ecpFromExp $+ reLocA $ sLL (reLoc $1) (reLocN $>) $ SectionL noAnn $1 (n2l $2) }+ | qopm infixexp { ECP $+ superInfixOp $+ unECP $2 >>= \ $2 ->+ $1 >>= \ $1 ->+ pvA $ mkHsSectionR_PV (comb2 (reLocN $1) (reLoc $>)) (n2l $1) $2 }++ -- View patterns get parenthesized above+ | exp '->' texp { ECP $+ unECP $1 >>= \ $1 ->+ unECP $3 >>= \ $3 ->+ mkHsViewPatPV (comb2 (reLoc $1) (reLoc $>)) $1 $3 [mu AnnRarrow $2] }++-- Always at least one comma or bar.+-- Though this can parse just commas (without any expressions), it won't+-- in practice, because (,,,) is parsed as a name. See Note [ExplicitTuple]+-- in GHC.Hs.Expr.+tup_exprs :: { forall b. DisambECP b => PV (SumOrTuple b) }+ : texp commas_tup_tail+ { unECP $1 >>= \ $1 ->+ $2 >>= \ $2 ->+ do { t <- amsA $1 [AddCommaAnn (EpaSpan $ rs $ fst $2)]+ ; return (Tuple (Right t : snd $2)) } }+ | commas tup_tail+ { $2 >>= \ $2 ->+ do { let {cos = map (\ll -> (Left (EpAnn (anc $ rs ll) (EpaSpan $ rs ll) emptyComments))) (fst $1) }+ ; return (Tuple (cos ++ $2)) } }++ | texp bars { unECP $1 >>= \ $1 -> return $+ (Sum 1 (snd $2 + 1) $1 [] (fst $2)) }++ | bars texp bars0+ { unECP $2 >>= \ $2 -> return $+ (Sum (snd $1 + 1) (snd $1 + snd $3 + 1) $2 (fst $1) (fst $3)) }++-- Always starts with commas; always follows an expr+commas_tup_tail :: { forall b. DisambECP b => PV (SrcSpan,[Either (EpAnn EpaLocation) (LocatedA b)]) }+commas_tup_tail : commas tup_tail+ { $2 >>= \ $2 ->+ do { let {cos = map (\l -> (Left (EpAnn (anc $ rs l) (EpaSpan $ rs l) emptyComments))) (tail $ fst $1) }+ ; return ((head $ fst $1, cos ++ $2)) } }++-- Always follows a comma+tup_tail :: { forall b. DisambECP b => PV [Either (EpAnn EpaLocation) (LocatedA b)] }+ : texp commas_tup_tail { unECP $1 >>= \ $1 ->+ $2 >>= \ $2 ->+ do { t <- amsA $1 [AddCommaAnn (EpaSpan $ rs $ fst $2)]+ ; return (Right t : snd $2) } }+ | texp { unECP $1 >>= \ $1 ->+ return [Right $1] }+ -- See Note [%shift: tup_tail -> {- empty -}]+ | {- empty -} %shift { return [Left noAnn] }++-----------------------------------------------------------------------------+-- List expressions++-- The rules below are little bit contorted to keep lexps left-recursive while+-- avoiding another shift/reduce-conflict.+-- Never empty.+list :: { forall b. DisambECP b => SrcSpan -> (AddEpAnn, AddEpAnn) -> PV (LocatedA b) }+ : texp { \loc (ao,ac) -> unECP $1 >>= \ $1 ->+ mkHsExplicitListPV loc [$1] (AnnList Nothing (Just ao) (Just ac) [] []) }+ | lexps { \loc (ao,ac) -> $1 >>= \ $1 ->+ mkHsExplicitListPV loc (reverse $1) (AnnList Nothing (Just ao) (Just ac) [] []) }+ | texp '..' { \loc (ao,ac) -> unECP $1 >>= \ $1 ->+ acsA (\cs -> L loc $ ArithSeq (EpAnn (spanAsAnchor loc) [ao,mj AnnDotdot $2,ac] cs) Nothing (From $1))+ >>= ecpFromExp' }+ | texp ',' exp '..' { \loc (ao,ac) ->+ unECP $1 >>= \ $1 ->+ unECP $3 >>= \ $3 ->+ acsA (\cs -> L loc $ ArithSeq (EpAnn (spanAsAnchor loc) [ao,mj AnnComma $2,mj AnnDotdot $4,ac] cs) Nothing (FromThen $1 $3))+ >>= ecpFromExp' }+ | texp '..' exp { \loc (ao,ac) ->+ unECP $1 >>= \ $1 ->+ unECP $3 >>= \ $3 ->+ acsA (\cs -> L loc $ ArithSeq (EpAnn (spanAsAnchor loc) [ao,mj AnnDotdot $2,ac] cs) Nothing (FromTo $1 $3))+ >>= ecpFromExp' }+ | texp ',' exp '..' exp { \loc (ao,ac) ->+ unECP $1 >>= \ $1 ->+ unECP $3 >>= \ $3 ->+ unECP $5 >>= \ $5 ->+ acsA (\cs -> L loc $ ArithSeq (EpAnn (spanAsAnchor loc) [ao,mj AnnComma $2,mj AnnDotdot $4,ac] cs) Nothing (FromThenTo $1 $3 $5))+ >>= ecpFromExp' }+ | texp '|' flattenedpquals+ { \loc (ao,ac) ->+ checkMonadComp >>= \ ctxt ->+ unECP $1 >>= \ $1 -> do { t <- addTrailingVbarA $1 (gl $2)+ ; acsA (\cs -> L loc $ mkHsCompAnns ctxt (unLoc $3) t (EpAnn (spanAsAnchor loc) (AnnList Nothing (Just ao) (Just ac) [] []) cs))+ >>= ecpFromExp' } }++lexps :: { forall b. DisambECP b => PV [LocatedA b] }+ : lexps ',' texp { $1 >>= \ $1 ->+ unECP $3 >>= \ $3 ->+ case $1 of+ (h:t) -> do+ h' <- addTrailingCommaA h (gl $2)+ return (((:) $! $3) $! (h':t)) }+ | texp ',' texp { unECP $1 >>= \ $1 ->+ unECP $3 >>= \ $3 ->+ do { h <- addTrailingCommaA $1 (gl $2)+ ; return [$3,h] }}++-----------------------------------------------------------------------------+-- List Comprehensions++flattenedpquals :: { Located [LStmt GhcPs (LHsExpr GhcPs)] }+ : pquals { case (unLoc $1) of+ [qs] -> sL1 $1 qs+ -- We just had one thing in our "parallel" list so+ -- we simply return that thing directly++ qss -> sL1 $1 [sL1a $1 $ ParStmt noExtField [ParStmtBlock noExtField qs [] noSyntaxExpr |+ qs <- qss]+ noExpr noSyntaxExpr]+ -- We actually found some actual parallel lists so+ -- we wrap them into as a ParStmt+ }++pquals :: { Located [[LStmt GhcPs (LHsExpr GhcPs)]] }+ : squals '|' pquals+ {% case unLoc $1 of+ (h:t) -> do+ h' <- addTrailingVbarA h (gl $2)+ return (sLL $1 $> (reverse (h':t) : unLoc $3)) }+ | squals { L (getLoc $1) [reverse (unLoc $1)] }++squals :: { Located [LStmt GhcPs (LHsExpr GhcPs)] } -- In reverse order, because the last+ -- one can "grab" the earlier ones+ : squals ',' transformqual+ {% case unLoc $1 of+ (h:t) -> do+ h' <- addTrailingCommaA h (gl $2)+ return (sLL $1 $> [sLLa $1 $> ((unLoc $3) (glRR $1) (reverse (h':t)))]) }+ | squals ',' qual+ {% runPV $3 >>= \ $3 ->+ case unLoc $1 of+ (h:t) -> do+ h' <- addTrailingCommaA h (gl $2)+ return (sLL $1 (reLoc $>) ($3 : (h':t))) }+ | transformqual {% return (sLL $1 $> [L (getLocAnn $1) ((unLoc $1) (glRR $1) [])]) }+ | qual {% runPV $1 >>= \ $1 ->+ return $ sL1A $1 [$1] }+-- | transformquals1 ',' '{|' pquals '|}' { sLL $1 $> ($4 : unLoc $1) }+-- | '{|' pquals '|}' { sL1 $1 [$2] }++-- It is possible to enable bracketing (associating) qualifier lists+-- by uncommenting the lines with {| |} above. Due to a lack of+-- consensus on the syntax, this feature is not being used until we+-- get user demand.++transformqual :: { Located (RealSrcSpan -> [LStmt GhcPs (LHsExpr GhcPs)] -> Stmt GhcPs (LHsExpr GhcPs)) }+ -- Function is applied to a list of stmts *in order*+ : 'then' exp {% runPV (unECP $2) >>= \ $2 ->+ acs (\cs->+ sLLlA $1 $> (\r ss -> (mkTransformStmt (EpAnn (anc r) [mj AnnThen $1] cs) ss $2))) }+ | 'then' exp 'by' exp {% runPV (unECP $2) >>= \ $2 ->+ runPV (unECP $4) >>= \ $4 ->+ acs (\cs -> sLLlA $1 $> (+ \r ss -> (mkTransformByStmt (EpAnn (anc r) [mj AnnThen $1,mj AnnBy $3] cs) ss $2 $4))) }+ | 'then' 'group' 'using' exp+ {% runPV (unECP $4) >>= \ $4 ->+ acs (\cs -> sLLlA $1 $> (+ \r ss -> (mkGroupUsingStmt (EpAnn (anc r) [mj AnnThen $1,mj AnnGroup $2,mj AnnUsing $3] cs) ss $4))) }++ | 'then' 'group' 'by' exp 'using' exp+ {% runPV (unECP $4) >>= \ $4 ->+ runPV (unECP $6) >>= \ $6 ->+ acs (\cs -> sLLlA $1 $> (+ \r ss -> (mkGroupByUsingStmt (EpAnn (anc r) [mj AnnThen $1,mj AnnGroup $2,mj AnnBy $3,mj AnnUsing $5] cs) ss $4 $6))) }++-- Note that 'group' is a special_id, which means that you can enable+-- TransformListComp while still using Data.List.group. However, this+-- introduces a shift/reduce conflict. Happy chooses to resolve the conflict+-- in by choosing the "group by" variant, which is what we want.++-----------------------------------------------------------------------------+-- Guards++guardquals :: { Located [LStmt GhcPs (LHsExpr GhcPs)] }+ : guardquals1 { L (getLoc $1) (reverse (unLoc $1)) }++guardquals1 :: { Located [LStmt GhcPs (LHsExpr GhcPs)] }+ : guardquals1 ',' qual {% runPV $3 >>= \ $3 ->+ case unLoc $1 of+ (h:t) -> do+ h' <- addTrailingCommaA h (gl $2)+ return (sLL $1 (reLoc $>) ($3 : (h':t))) }+ | qual {% runPV $1 >>= \ $1 ->+ return $ sL1A $1 [$1] }++-----------------------------------------------------------------------------+-- Case alternatives++altslist :: { forall b. DisambECP b => PV (LocatedL [LMatch GhcPs (LocatedA b)]) }+ : '{' alts '}' { $2 >>= \ $2 -> amsrl+ (sLL $1 $> (reverse (snd $ unLoc $2)))+ (AnnList (Just $ glR $2) (Just $ moc $1) (Just $ mcc $3) (fst $ unLoc $2) []) }+ | vocurly alts close { $2 >>= \ $2 -> amsrl+ (L (getLoc $2) (reverse (snd $ unLoc $2)))+ (AnnList (Just $ glR $2) Nothing Nothing (fst $ unLoc $2) []) }+ | '{' '}' { amsrl (sLL $1 $> []) (AnnList Nothing (Just $ moc $1) (Just $ mcc $2) [] []) }+ | vocurly close { return $ noLocA [] }++alts :: { forall b. DisambECP b => PV (Located ([AddEpAnn],[LMatch GhcPs (LocatedA b)])) }+ : alts1 { $1 >>= \ $1 -> return $+ sL1 $1 (fst $ unLoc $1,snd $ unLoc $1) }+ | ';' alts { $2 >>= \ $2 -> return $+ sLL $1 $> (((mz AnnSemi $1) ++ (fst $ unLoc $2) )+ ,snd $ unLoc $2) }++alts1 :: { forall b. DisambECP b => PV (Located ([AddEpAnn],[LMatch GhcPs (LocatedA b)])) }+ : alts1 ';' alt { $1 >>= \ $1 ->+ $3 >>= \ $3 ->+ case snd $ unLoc $1 of+ [] -> return (sLL $1 (reLoc $>) ((fst $ unLoc $1) ++ (mz AnnSemi $2)+ ,[$3]))+ (h:t) -> do+ h' <- addTrailingSemiA h (gl $2)+ return (sLL $1 (reLoc $>) (fst $ unLoc $1,$3 : h' : t)) }+ | alts1 ';' { $1 >>= \ $1 ->+ case snd $ unLoc $1 of+ [] -> return (sLL $1 $> ((fst $ unLoc $1) ++ (mz AnnSemi $2)+ ,[]))+ (h:t) -> do+ h' <- addTrailingSemiA h (gl $2)+ return (sLL $1 $> (fst $ unLoc $1, h' : t)) }+ | alt { $1 >>= \ $1 -> return $ sL1 (reLoc $1) ([],[$1]) }++alt :: { forall b. DisambECP b => PV (LMatch GhcPs (LocatedA b)) }+ : pat alt_rhs { $2 >>= \ $2 ->+ acsA (\cs -> sLL (reLoc $1) $>+ (Match { m_ext = (EpAnn (glAR $1) [] cs)+ , m_ctxt = CaseAlt+ , m_pats = [$1]+ , m_grhss = unLoc $2 }))}++alt_rhs :: { forall b. DisambECP b => PV (Located (GRHSs GhcPs (LocatedA b))) }+ : ralt wherebinds { $1 >>= \alt ->+ do { let {L l (bs, csw) = adaptWhereBinds $2}+ ; acs (\cs -> sLL alt (L l bs) (GRHSs (cs Semi.<> csw) (unLoc alt) bs)) }}++ralt :: { forall b. DisambECP b => PV (Located [LGRHS GhcPs (LocatedA b)]) }+ : '->' exp { unECP $2 >>= \ $2 ->+ acs (\cs -> sLLlA $1 $> (unguardedRHS (EpAnn (glR $1) (GrhsAnn Nothing (mu AnnRarrow $1)) cs) (comb2 $1 (reLoc $2)) $2)) }+ | gdpats { $1 >>= \gdpats ->+ return $ sL1 gdpats (reverse (unLoc gdpats)) }++gdpats :: { forall b. DisambECP b => PV (Located [LGRHS GhcPs (LocatedA b)]) }+ : gdpats gdpat { $1 >>= \gdpats ->+ $2 >>= \gdpat ->+ return $ sLL gdpats gdpat (gdpat : unLoc gdpats) }+ | gdpat { $1 >>= \gdpat -> return $ sL1 gdpat [gdpat] }++-- layout for MultiWayIf doesn't begin with an open brace, because it's hard to+-- generate the open brace in addition to the vertical bar in the lexer, and+-- we don't need it.+ifgdpats :: { Located ([AddEpAnn],[LGRHS GhcPs (LHsExpr GhcPs)]) }+ : '{' gdpats '}' {% runPV $2 >>= \ $2 ->+ return $ sLL $1 $> ([moc $1,mcc $3],unLoc $2) }+ | gdpats close {% runPV $1 >>= \ $1 ->+ return $ sL1 $1 ([],unLoc $1) }++gdpat :: { forall b. DisambECP b => PV (LGRHS GhcPs (LocatedA b)) }+ : '|' guardquals '->' exp+ { unECP $4 >>= \ $4 ->+ acs (\cs -> sL (comb2A $1 $>) $ GRHS (EpAnn (glR $1) (GrhsAnn (Just $ glAA $1) (mu AnnRarrow $3)) cs) (unLoc $2) $4) }++-- 'pat' recognises a pattern, including one with a bang at the top+-- e.g. "!x" or "!(x,y)" or "C a b" etc+-- Bangs inside are parsed as infix operator applications, so that+-- we parse them right when bang-patterns are off+pat :: { LPat GhcPs }+pat : exp {% (checkPattern <=< runPV) (unECP $1) }++bindpat :: { LPat GhcPs }+bindpat : exp {% -- See Note [Parser-Validator Hint] in GHC.Parser.PostProcess+ checkPattern_hints [SuggestMissingDo]+ (unECP $1) }++apat :: { LPat GhcPs }+apat : aexp {% (checkPattern <=< runPV) (unECP $1) }++apats :: { [LPat GhcPs] }+ : apat apats { $1 : $2 }+ | {- empty -} { [] }++-----------------------------------------------------------------------------+-- Statement sequences++stmtlist :: { forall b. DisambECP b => PV (LocatedL [LocatedA (Stmt GhcPs (LocatedA b))]) }+ : '{' stmts '}' { $2 >>= \ $2 -> amsrl+ (sLL $1 $> (reverse $ snd $ unLoc $2)) (AnnList (Just $ glR $2) (Just $ moc $1) (Just $ mcc $3) (fromOL $ fst $ unLoc $2) []) }+ | vocurly stmts close { $2 >>= \ $2 -> amsrl+ (L (gl $2) (reverse $ snd $ unLoc $2)) (AnnList (Just $ glR $2) Nothing Nothing (fromOL $ fst $ unLoc $2) []) }++-- do { ;; s ; s ; ; s ;; }+-- The last Stmt should be an expression, but that's hard to enforce+-- here, because we need too much lookahead if we see do { e ; }+-- So we use BodyStmts throughout, and switch the last one over+-- in ParseUtils.checkDo instead++stmts :: { forall b. DisambECP b => PV (Located (OrdList AddEpAnn,[LStmt GhcPs (LocatedA b)])) }+ : stmts ';' stmt { $1 >>= \ $1 ->+ $3 >>= \ ($3 :: LStmt GhcPs (LocatedA b)) ->+ case (snd $ unLoc $1) of+ [] -> return (sLL $1 (reLoc $>) ((fst $ unLoc $1) `snocOL` (mj AnnSemi $2)+ ,$3 : (snd $ unLoc $1)))+ (h:t) -> do+ { h' <- addTrailingSemiA h (gl $2)+ ; return $ sLL $1 (reLoc $>) (fst $ unLoc $1,$3 :(h':t)) }}++ | stmts ';' { $1 >>= \ $1 ->+ case (snd $ unLoc $1) of+ [] -> return (sLL $1 $> ((fst $ unLoc $1) `snocOL` (mj AnnSemi $2),snd $ unLoc $1))+ (h:t) -> do+ { h' <- addTrailingSemiA h (gl $2)+ ; return $ sL1 $1 (fst $ unLoc $1,h':t) }}+ | stmt { $1 >>= \ $1 ->+ return $ sL1A $1 (nilOL,[$1]) }+ | {- empty -} { return $ noLoc (nilOL,[]) }+++-- For typing stmts at the GHCi prompt, where+-- the input may consist of just comments.+maybe_stmt :: { Maybe (LStmt GhcPs (LHsExpr GhcPs)) }+ : stmt {% fmap Just (runPV $1) }+ | {- nothing -} { Nothing }++-- For GHC API.+e_stmt :: { LStmt GhcPs (LHsExpr GhcPs) }+ : stmt {% runPV $1 }++stmt :: { forall b. DisambECP b => PV (LStmt GhcPs (LocatedA b)) }+ : qual { $1 }+ | 'rec' stmtlist { $2 >>= \ $2 ->+ acsA (\cs -> (sLL $1 (reLoc $>) $ mkRecStmt+ (EpAnn (glR $1) (hsDoAnn $1 $2 AnnRec) cs)+ $2)) }++qual :: { forall b. DisambECP b => PV (LStmt GhcPs (LocatedA b)) }+ : bindpat '<-' exp { unECP $3 >>= \ $3 ->+ acsA (\cs -> sLLlA (reLoc $1) $>+ $ mkPsBindStmt (EpAnn (glAR $1) [mu AnnLarrow $2] cs) $1 $3) }+ | exp { unECP $1 >>= \ $1 ->+ return $ sL1 $1 $ mkBodyStmt $1 }+ | 'let' binds { acsA (\cs -> (sLL $1 $>+ $ mkLetStmt (EpAnn (glR $1) [mj AnnLet $1] cs) (unLoc $2))) }++-----------------------------------------------------------------------------+-- Record Field Update/Construction++fbinds :: { forall b. DisambECP b => PV ([Fbind b], Maybe SrcSpan) }+ : fbinds1 { $1 }+ | {- empty -} { return ([], Nothing) }++fbinds1 :: { forall b. DisambECP b => PV ([Fbind b], Maybe SrcSpan) }+ : fbind ',' fbinds1+ { $1 >>= \ $1 ->+ $3 >>= \ $3 -> do+ h <- addTrailingCommaFBind $1 (gl $2)+ return (case $3 of (flds, dd) -> (h : flds, dd)) }+ | fbind { $1 >>= \ $1 ->+ return ([$1], Nothing) }+ | '..' { return ([], Just (getLoc $1)) }++fbind :: { forall b. DisambECP b => PV (Fbind b) }+ : qvar '=' texp { unECP $3 >>= \ $3 ->+ fmap Left $ acsA (\cs -> sLL (reLocN $1) (reLoc $>) $ HsRecField (EpAnn (glNR $1) [mj AnnEqual $2] cs) (sL1N $1 $ mkFieldOcc $1) $3 False) }+ -- RHS is a 'texp', allowing view patterns (#6038)+ -- and, incidentally, sections. Eg+ -- f (R { x = show -> s }) = ...++ | qvar { placeHolderPunRhs >>= \rhs ->+ fmap Left $ acsa (\cs -> sL1a (reLocN $1) $ HsRecField (EpAnn (glNR $1) [] cs) (sL1N $1 $ mkFieldOcc $1) rhs True) }+ -- In the punning case, use a place-holder+ -- The renamer fills in the final value++ -- See Note [Whitespace-sensitive operator parsing] in GHC.Parser.Lexer+ -- AZ: need to pull out the let block into a helper+ | field TIGHT_INFIX_PROJ fieldToUpdate '=' texp+ { do+ let top = sL1 $1 $ HsFieldLabel noAnn $1+ ((L lf (HsFieldLabel _ f)):t) = reverse (unLoc $3)+ lf' = comb2 $2 (L lf ())+ fields = top : L lf' (HsFieldLabel (EpAnn (spanAsAnchor lf') (AnnFieldLabel (Just $ glAA $2)) emptyComments) f) : t+ final = last fields+ l = comb2 $1 $3+ isPun = False+ $5 <- unECP $5+ fmap Right $ mkHsProjUpdatePV (comb2 $1 (reLoc $5)) (L l fields) $5 isPun+ [mj AnnEqual $4]+ }++ -- See Note [Whitespace-sensitive operator parsing] in GHC.Parser.Lexer+ -- AZ: need to pull out the let block into a helper+ | field TIGHT_INFIX_PROJ fieldToUpdate+ { do+ let top = sL1 $1 $ HsFieldLabel noAnn $1+ ((L lf (HsFieldLabel _ f)):t) = reverse (unLoc $3)+ lf' = comb2 $2 (L lf ())+ fields = top : L lf' (HsFieldLabel (EpAnn (spanAsAnchor lf') (AnnFieldLabel (Just $ glAA $2)) emptyComments) f) : t+ final = last fields+ l = comb2 $1 $3+ isPun = True+ var <- mkHsVarPV (L (noAnnSrcSpan $ getLoc final) (mkRdrUnqual . mkVarOcc . unpackFS . unLoc . hflLabel . unLoc $ final))+ fmap Right $ mkHsProjUpdatePV l (L l fields) var isPun []+ }++fieldToUpdate :: { Located [Located (HsFieldLabel GhcPs)] }+fieldToUpdate+ -- See Note [Whitespace-sensitive operator parsing] in Lexer.x+ : fieldToUpdate TIGHT_INFIX_PROJ field {% getCommentsFor (getLoc $3) >>= \cs ->+ return (sLL $1 $> ((sLL $2 $> (HsFieldLabel (EpAnn (glR $2) (AnnFieldLabel $ Just $ glAA $2) cs) $3)) : unLoc $1)) }+ | field {% getCommentsFor (getLoc $1) >>= \cs ->+ return (sL1 $1 [sL1 $1 (HsFieldLabel (EpAnn (glR $1) (AnnFieldLabel Nothing) cs) $1)]) }++-----------------------------------------------------------------------------+-- Implicit Parameter Bindings++dbinds :: { Located [LIPBind GhcPs] } -- reversed+ : dbinds ';' dbind+ {% case unLoc $1 of+ (h:t) -> do+ h' <- addTrailingSemiA h (gl $2)+ return (let { this = $3; rest = h':t }+ in rest `seq` this `seq` sLL $1 (reLoc $>) (this : rest)) }+ | dbinds ';' {% case unLoc $1 of+ (h:t) -> do+ h' <- addTrailingSemiA h (gl $2)+ return (sLL $1 $> (h':t)) }+ | dbind { let this = $1 in this `seq` (sL1 (reLoc $1) [this]) }+-- | {- empty -} { [] }++dbind :: { LIPBind GhcPs }+dbind : ipvar '=' exp {% runPV (unECP $3) >>= \ $3 ->+ acsA (\cs -> sLLlA $1 $> (IPBind (EpAnn (glR $1) [mj AnnEqual $2] cs) (Left $1) $3)) }++ipvar :: { Located HsIPName }+ : IPDUPVARID { sL1 $1 (HsIPName (getIPDUPVARID $1)) }++-----------------------------------------------------------------------------+-- Overloaded labels++overloaded_label :: { Located FastString }+ : LABELVARID { sL1 $1 (getLABELVARID $1) }++-----------------------------------------------------------------------------+-- Warnings and deprecations++name_boolformula_opt :: { LBooleanFormula (LocatedN RdrName) }+ : name_boolformula { $1 }+ | {- empty -} { noLocA mkTrue }++name_boolformula :: { LBooleanFormula (LocatedN RdrName) }+ : name_boolformula_and { $1 }+ | name_boolformula_and '|' name_boolformula+ {% do { h <- addTrailingVbarL $1 (gl $2)+ ; return (reLocA $ sLLAA $1 $> (Or [h,$3])) } }++name_boolformula_and :: { LBooleanFormula (LocatedN RdrName) }+ : name_boolformula_and_list+ { reLocA $ sLLAA (head $1) (last $1) (And ($1)) }++name_boolformula_and_list :: { [LBooleanFormula (LocatedN RdrName)] }+ : name_boolformula_atom { [$1] }+ | name_boolformula_atom ',' name_boolformula_and_list+ {% do { h <- addTrailingCommaL $1 (gl $2)+ ; return (h : $3) } }++name_boolformula_atom :: { LBooleanFormula (LocatedN RdrName) }+ : '(' name_boolformula ')' {% amsrl (sLL $1 $> (Parens $2))+ (AnnList Nothing (Just (mop $1)) (Just (mcp $3)) [] []) }+ | name_var { reLocA $ sL1N $1 (Var $1) }++namelist :: { Located [LocatedN RdrName] }+namelist : name_var { sL1N $1 [$1] }+ | name_var ',' namelist {% do { h <- addTrailingCommaN $1 (gl $2)+ ; return (sLL (reLocN $1) $> (h : unLoc $3)) }}++name_var :: { LocatedN RdrName }+name_var : var { $1 }+ | con { $1 }++-----------------------------------------+-- Data constructors+-- There are two different productions here as lifted list constructors+-- are parsed differently.++qcon_nowiredlist :: { LocatedN RdrName }+ : gen_qcon { $1 }+ | sysdcon_nolist { L (getLoc $1) $ nameRdrName (dataConName (unLoc $1)) }++qcon :: { LocatedN RdrName }+ : gen_qcon { $1}+ | sysdcon { L (getLoc $1) $ nameRdrName (dataConName (unLoc $1)) }++gen_qcon :: { LocatedN RdrName }+ : qconid { $1 }+ | '(' qconsym ')' {% amsrn (sLL $1 $> (unLoc $2))+ (NameAnn NameParens (glAA $1) (glNRR $2) (glAA $3) []) }++con :: { LocatedN RdrName }+ : conid { $1 }+ | '(' consym ')' {% amsrn (sLL $1 $> (unLoc $2))+ (NameAnn NameParens (glAA $1) (glNRR $2) (glAA $3) []) }+ | sysdcon { L (getLoc $1) $ nameRdrName (dataConName (unLoc $1)) }++con_list :: { Located [LocatedN RdrName] }+con_list : con { sL1N $1 [$1] }+ | con ',' con_list {% do { h <- addTrailingCommaN $1 (gl $2)+ ; return (sLL (reLocN $1) $> (h : unLoc $3)) }}++-- See Note [ExplicitTuple] in GHC.Hs.Expr+sysdcon_nolist :: { LocatedN DataCon } -- Wired in data constructors+ : '(' ')' {% amsrn (sLL $1 $> unitDataCon) (NameAnnOnly NameParens (glAA $1) (glAA $2) []) }+ | '(' commas ')' {% amsrn (sLL $1 $> $ tupleDataCon Boxed (snd $2 + 1))+ (NameAnnCommas NameParens (glAA $1) (map (EpaSpan . realSrcSpan) (fst $2)) (glAA $3) []) }+ | '(#' '#)' {% amsrn (sLL $1 $> $ unboxedUnitDataCon) (NameAnnOnly NameParensHash (glAA $1) (glAA $2) []) }+ | '(#' commas '#)' {% amsrn (sLL $1 $> $ tupleDataCon Unboxed (snd $2 + 1))+ (NameAnnCommas NameParensHash (glAA $1) (map (EpaSpan . realSrcSpan) (fst $2)) (glAA $3) []) }++-- See Note [Empty lists] in GHC.Hs.Expr+sysdcon :: { LocatedN DataCon }+ : sysdcon_nolist { $1 }+ | '[' ']' {% amsrn (sLL $1 $> nilDataCon) (NameAnnOnly NameSquare (glAA $1) (glAA $2) []) }++conop :: { LocatedN RdrName }+ : consym { $1 }+ | '`' conid '`' {% amsrn (sLL $1 $> (unLoc $2))+ (NameAnn NameBackquotes (glAA $1) (glNRR $2) (glAA $3) []) }++qconop :: { LocatedN RdrName }+ : qconsym { $1 }+ | '`' qconid '`' {% amsrn (sLL $1 $> (unLoc $2))+ (NameAnn NameBackquotes (glAA $1) (glNRR $2) (glAA $3) []) }++----------------------------------------------------------------------------+-- Type constructors+++-- See Note [Unit tuples] in GHC.Hs.Type for the distinction+-- between gtycon and ntgtycon+gtycon :: { LocatedN RdrName } -- A "general" qualified tycon, including unit tuples+ : ntgtycon { $1 }+ | '(' ')' {% amsrn (sLL $1 $> $ getRdrName unitTyCon)+ (NameAnnOnly NameParens (glAA $1) (glAA $2) []) }+ | '(#' '#)' {% amsrn (sLL $1 $> $ getRdrName unboxedUnitTyCon)+ (NameAnnOnly NameParensHash (glAA $1) (glAA $2) []) }++ntgtycon :: { LocatedN RdrName } -- A "general" qualified tycon, excluding unit tuples+ : oqtycon { $1 }+ | '(' commas ')' {% amsrn (sLL $1 $> $ getRdrName (tupleTyCon Boxed+ (snd $2 + 1)))+ (NameAnnCommas NameParens (glAA $1) (map (EpaSpan . realSrcSpan) (fst $2)) (glAA $3) []) }+ | '(#' commas '#)' {% amsrn (sLL $1 $> $ getRdrName (tupleTyCon Unboxed+ (snd $2 + 1)))+ (NameAnnCommas NameParensHash (glAA $1) (map (EpaSpan . realSrcSpan) (fst $2)) (glAA $3) []) }+ | '(' '->' ')' {% amsrn (sLL $1 $> $ getRdrName unrestrictedFunTyCon)+ (NameAnn NameParens (glAA $1) (glAA $2) (glAA $3) []) }+ | '[' ']' {% amsrn (sLL $1 $> $ listTyCon_RDR)+ (NameAnnOnly NameSquare (glAA $1) (glAA $2) []) }++oqtycon :: { LocatedN RdrName } -- An "ordinary" qualified tycon;+ -- These can appear in export lists+ : qtycon { $1 }+ | '(' qtyconsym ')' {% amsrn (sLL $1 $> (unLoc $2))+ (NameAnn NameParens (glAA $1) (glNRR $2) (glAA $3) []) }++oqtycon_no_varcon :: { LocatedN RdrName } -- Type constructor which cannot be mistaken+ -- for variable constructor in export lists+ -- see Note [Type constructors in export list]+ : qtycon { $1 }+ | '(' QCONSYM ')' {% let { name :: Located RdrName+ ; name = sL1 $2 $! mkQual tcClsName (getQCONSYM $2) }+ in amsrn (sLL $1 $> (unLoc name)) (NameAnn NameParens (glAA $1) (glAA $2) (glAA $3) []) }+ | '(' CONSYM ')' {% let { name :: Located RdrName+ ; name = sL1 $2 $! mkUnqual tcClsName (getCONSYM $2) }+ in amsrn (sLL $1 $> (unLoc name)) (NameAnn NameParens (glAA $1) (glAA $2) (glAA $3) []) }+ | '(' ':' ')' {% let { name :: Located RdrName+ ; name = sL1 $2 $! consDataCon_RDR }+ in amsrn (sLL $1 $> (unLoc name)) (NameAnn NameParens (glAA $1) (glAA $2) (glAA $3) []) }++{- Note [Type constructors in export list]+~~~~~~~~~~~~~~~~~~~~~+Mixing type constructors and data constructors in export lists introduces+ambiguity in grammar: e.g. (*) may be both a type constructor and a function.++-XExplicitNamespaces allows to disambiguate by explicitly prefixing type+constructors with 'type' keyword.++This ambiguity causes reduce/reduce conflicts in parser, which are always+resolved in favour of data constructors. To get rid of conflicts we demand+that ambiguous type constructors (those, which are formed by the same+productions as variable constructors) are always prefixed with 'type' keyword.+Unambiguous type constructors may occur both with or without 'type' keyword.++Note that in the parser we still parse data constructors as type+constructors. As such, they still end up in the type constructor namespace+until after renaming when we resolve the proper namespace for each exported+child.+-}++qtyconop :: { LocatedN RdrName } -- Qualified or unqualified+ -- See Note [%shift: qtyconop -> qtyconsym]+ : qtyconsym %shift { $1 }+ | '`' qtycon '`' {% amsrn (sLL $1 $> (unLoc $2))+ (NameAnn NameBackquotes (glAA $1) (glNRR $2) (glAA $3) []) }++qtycon :: { LocatedN RdrName } -- Qualified or unqualified+ : QCONID { sL1n $1 $! mkQual tcClsName (getQCONID $1) }+ | tycon { $1 }++tycon :: { LocatedN RdrName } -- Unqualified+ : CONID { sL1n $1 $! mkUnqual tcClsName (getCONID $1) }++qtyconsym :: { LocatedN RdrName }+ : QCONSYM { sL1n $1 $! mkQual tcClsName (getQCONSYM $1) }+ | QVARSYM { sL1n $1 $! mkQual tcClsName (getQVARSYM $1) }+ | tyconsym { $1 }++tyconsym :: { LocatedN RdrName }+ : CONSYM { sL1n $1 $! mkUnqual tcClsName (getCONSYM $1) }+ | VARSYM { sL1n $1 $!+ -- See Note [eqTyCon (~) is built-in syntax] in GHC.Builtin.Types+ if getVARSYM $1 == fsLit "~"+ then eqTyCon_RDR+ else mkUnqual tcClsName (getVARSYM $1) }+ | ':' { sL1n $1 $! consDataCon_RDR }+ | '-' { sL1n $1 $! mkUnqual tcClsName (fsLit "-") }+ | '.' { sL1n $1 $! mkUnqual tcClsName (fsLit ".") }++-- An "ordinary" unqualified tycon. See `oqtycon` for the qualified version.+-- These can appear in `ANN type` declarations (#19374).+otycon :: { LocatedN RdrName }+ : tycon { $1 }+ | '(' tyconsym ')' {% amsrn (sLL $1 $> (unLoc $2))+ (NameAnn NameParens (glAA $1) (glNRR $2) (glAA $3) []) }++-----------------------------------------------------------------------------+-- Operators++op :: { LocatedN RdrName } -- used in infix decls+ : varop { $1 }+ | conop { $1 }+ | '->' { sL1n $1 $ getRdrName unrestrictedFunTyCon }++varop :: { LocatedN RdrName }+ : varsym { $1 }+ | '`' varid '`' {% amsrn (sLL $1 $> (unLoc $2))+ (NameAnn NameBackquotes (glAA $1) (glNRR $2) (glAA $3) []) }++qop :: { forall b. DisambInfixOp b => PV (LocatedN b) } -- used in sections+ : qvarop { mkHsVarOpPV $1 }+ | qconop { mkHsConOpPV $1 }+ | hole_op { pvN $1 }++qopm :: { forall b. DisambInfixOp b => PV (LocatedN b) } -- used in sections+ : qvaropm { mkHsVarOpPV $1 }+ | qconop { mkHsConOpPV $1 }+ | hole_op { pvN $1 }++hole_op :: { forall b. DisambInfixOp b => PV (Located b) } -- used in sections+hole_op : '`' '_' '`' { mkHsInfixHolePV (comb2 $1 $>)+ (\cs -> EpAnn (glR $1) (EpAnnUnboundVar (glAA $1, glAA $3) (glAA $2)) cs) }++qvarop :: { LocatedN RdrName }+ : qvarsym { $1 }+ | '`' qvarid '`' {% amsrn (sLL $1 $> (unLoc $2))+ (NameAnn NameBackquotes (glAA $1) (glNRR $2) (glAA $3) []) }++qvaropm :: { LocatedN RdrName }+ : qvarsym_no_minus { $1 }+ | '`' qvarid '`' {% amsrn (sLL $1 $> (unLoc $2))+ (NameAnn NameBackquotes (glAA $1) (glNRR $2) (glAA $3) []) }++-----------------------------------------------------------------------------+-- Type variables++tyvar :: { LocatedN RdrName }+tyvar : tyvarid { $1 }++tyvarop :: { LocatedN RdrName }+tyvarop : '`' tyvarid '`' {% amsrn (sLL $1 $> (unLoc $2))+ (NameAnn NameBackquotes (glAA $1) (glNRR $2) (glAA $3) []) }++tyvarid :: { LocatedN RdrName }+ : VARID { sL1n $1 $! mkUnqual tvName (getVARID $1) }+ | special_id { sL1n $1 $! mkUnqual tvName (unLoc $1) }+ | 'unsafe' { sL1n $1 $! mkUnqual tvName (fsLit "unsafe") }+ | 'safe' { sL1n $1 $! mkUnqual tvName (fsLit "safe") }+ | 'interruptible' { sL1n $1 $! mkUnqual tvName (fsLit "interruptible") }+ -- If this changes relative to varid, update 'checkRuleTyVarBndrNames'+ -- in GHC.Parser.PostProcess+ -- See Note [Parsing explicit foralls in Rules]++-----------------------------------------------------------------------------+-- Variables++var :: { LocatedN RdrName }+ : varid { $1 }+ | '(' varsym ')' {% amsrn (sLL $1 $> (unLoc $2))+ (NameAnn NameParens (glAA $1) (glNRR $2) (glAA $3) []) }++qvar :: { LocatedN RdrName }+ : qvarid { $1 }+ | '(' varsym ')' {% amsrn (sLL $1 $> (unLoc $2))+ (NameAnn NameParens (glAA $1) (glNRR $2) (glAA $3) []) }+ | '(' qvarsym1 ')' {% amsrn (sLL $1 $> (unLoc $2))+ (NameAnn NameParens (glAA $1) (glNRR $2) (glAA $3) []) }+-- We've inlined qvarsym here so that the decision about+-- whether it's a qvar or a var can be postponed until+-- *after* we see the close paren.++field :: { Located FastString }+ : VARID { sL1 $1 $! getVARID $1 }++qvarid :: { LocatedN RdrName }+ : varid { $1 }+ | QVARID { sL1n $1 $! mkQual varName (getQVARID $1) }++-- Note that 'role' and 'family' get lexed separately regardless of+-- the use of extensions. However, because they are listed here,+-- this is OK and they can be used as normal varids.+-- See Note [Lexing type pseudo-keywords] in GHC.Parser.Lexer+varid :: { LocatedN RdrName }+ : VARID { sL1n $1 $! mkUnqual varName (getVARID $1) }+ | special_id { sL1n $1 $! mkUnqual varName (unLoc $1) }+ | 'unsafe' { sL1n $1 $! mkUnqual varName (fsLit "unsafe") }+ | 'safe' { sL1n $1 $! mkUnqual varName (fsLit "safe") }+ | 'interruptible' { sL1n $1 $! mkUnqual varName (fsLit "interruptible")}+ | 'forall' { sL1n $1 $! mkUnqual varName (fsLit "forall") }+ | 'family' { sL1n $1 $! mkUnqual varName (fsLit "family") }+ | 'role' { sL1n $1 $! mkUnqual varName (fsLit "role") }+ -- If this changes relative to tyvarid, update 'checkRuleTyVarBndrNames'+ -- in GHC.Parser.PostProcess+ -- See Note [Parsing explicit foralls in Rules]++qvarsym :: { LocatedN RdrName }+ : varsym { $1 }+ | qvarsym1 { $1 }++qvarsym_no_minus :: { LocatedN RdrName }+ : varsym_no_minus { $1 }+ | qvarsym1 { $1 }++qvarsym1 :: { LocatedN RdrName }+qvarsym1 : QVARSYM { sL1n $1 $ mkQual varName (getQVARSYM $1) }++varsym :: { LocatedN RdrName }+ : varsym_no_minus { $1 }+ | '-' { sL1n $1 $ mkUnqual varName (fsLit "-") }++varsym_no_minus :: { LocatedN RdrName } -- varsym not including '-'+ : VARSYM { sL1n $1 $ mkUnqual varName (getVARSYM $1) }+ | special_sym { sL1n $1 $ mkUnqual varName (unLoc $1) }+++-- These special_ids are treated as keywords in various places,+-- but as ordinary ids elsewhere. 'special_id' collects all these+-- except 'unsafe', 'interruptible', 'forall', 'family', 'role', 'stock', and+-- 'anyclass', whose treatment differs depending on context+special_id :: { Located FastString }+special_id+ : 'as' { sL1 $1 (fsLit "as") }+ | 'qualified' { sL1 $1 (fsLit "qualified") }+ | 'hiding' { sL1 $1 (fsLit "hiding") }+ | 'export' { sL1 $1 (fsLit "export") }+ | 'label' { sL1 $1 (fsLit "label") }+ | 'dynamic' { sL1 $1 (fsLit "dynamic") }+ | 'stdcall' { sL1 $1 (fsLit "stdcall") }+ | 'ccall' { sL1 $1 (fsLit "ccall") }+ | 'capi' { sL1 $1 (fsLit "capi") }+ | 'prim' { sL1 $1 (fsLit "prim") }+ | 'javascript' { sL1 $1 (fsLit "javascript") }+ -- See Note [%shift: special_id -> 'group']+ | 'group' %shift { sL1 $1 (fsLit "group") }+ | 'stock' { sL1 $1 (fsLit "stock") }+ | 'anyclass' { sL1 $1 (fsLit "anyclass") }+ | 'via' { sL1 $1 (fsLit "via") }+ | 'unit' { sL1 $1 (fsLit "unit") }+ | 'dependency' { sL1 $1 (fsLit "dependency") }+ | 'signature' { sL1 $1 (fsLit "signature") }++special_sym :: { Located FastString }+special_sym : '.' { sL1 $1 (fsLit ".") }+ | '*' { sL1 $1 (fsLit (starSym (isUnicode $1))) }++-----------------------------------------------------------------------------+-- Data constructors++qconid :: { LocatedN RdrName } -- Qualified or unqualified+ : conid { $1 }+ | QCONID { sL1n $1 $! mkQual dataName (getQCONID $1) }++conid :: { LocatedN RdrName }+ : CONID { sL1n $1 $ mkUnqual dataName (getCONID $1) }++qconsym :: { LocatedN RdrName } -- Qualified or unqualified+ : consym { $1 }+ | QCONSYM { sL1n $1 $ mkQual dataName (getQCONSYM $1) }++consym :: { LocatedN RdrName }+ : CONSYM { sL1n $1 $ mkUnqual dataName (getCONSYM $1) }++ -- ':' means only list cons+ | ':' { sL1n $1 $ consDataCon_RDR }+++-----------------------------------------------------------------------------+-- Literals++literal :: { Located (HsLit GhcPs) }+ : CHAR { sL1 $1 $ HsChar (getCHARs $1) $ getCHAR $1 }+ | STRING { sL1 $1 $ HsString (getSTRINGs $1)+ $ getSTRING $1 }+ | PRIMINTEGER { sL1 $1 $ HsIntPrim (getPRIMINTEGERs $1)+ $ getPRIMINTEGER $1 }+ | PRIMWORD { sL1 $1 $ HsWordPrim (getPRIMWORDs $1)+ $ getPRIMWORD $1 }+ | PRIMCHAR { sL1 $1 $ HsCharPrim (getPRIMCHARs $1)+ $ getPRIMCHAR $1 }+ | PRIMSTRING { sL1 $1 $ HsStringPrim (getPRIMSTRINGs $1)+ $ getPRIMSTRING $1 }+ | PRIMFLOAT { sL1 $1 $ HsFloatPrim noExtField $ getPRIMFLOAT $1 }+ | PRIMDOUBLE { sL1 $1 $ HsDoublePrim noExtField $ getPRIMDOUBLE $1 }++-----------------------------------------------------------------------------+-- Layout++close :: { () }+ : vccurly { () } -- context popped in lexer.+ | error {% popContext }++-----------------------------------------------------------------------------+-- Miscellaneous (mostly renamings)++modid :: { LocatedA ModuleName }+ : CONID { sL1a $1 $ mkModuleNameFS (getCONID $1) }+ | QCONID { sL1a $1 $ let (mod,c) = getQCONID $1 in+ mkModuleNameFS+ (mkFastString+ (unpackFS mod ++ '.':unpackFS c))+ }++commas :: { ([SrcSpan],Int) } -- One or more commas+ : commas ',' { ((fst $1)++[gl $2],snd $1 + 1) }+ | ',' { ([gl $1],1) }++bars0 :: { ([EpaLocation],Int) } -- Zero or more bars+ : bars { $1 }+ | { ([], 0) }++bars :: { ([EpaLocation],Int) } -- One or more bars+ : bars '|' { ((fst $1)++[glAA $2],snd $1 + 1) }+ | '|' { ([glAA $1],1) }++{+happyError :: P a+happyError = srcParseFail++getVARID (L _ (ITvarid x)) = x+getCONID (L _ (ITconid x)) = x+getVARSYM (L _ (ITvarsym x)) = x+getCONSYM (L _ (ITconsym x)) = x+getDO (L _ (ITdo x)) = x+getMDO (L _ (ITmdo x)) = x+getQVARID (L _ (ITqvarid x)) = x+getQCONID (L _ (ITqconid x)) = x+getQVARSYM (L _ (ITqvarsym x)) = x+getQCONSYM (L _ (ITqconsym x)) = x+getIPDUPVARID (L _ (ITdupipvarid x)) = x+getLABELVARID (L _ (ITlabelvarid x)) = x+getCHAR (L _ (ITchar _ x)) = x+getSTRING (L _ (ITstring _ x)) = x+getINTEGER (L _ (ITinteger x)) = x+getRATIONAL (L _ (ITrational x)) = x+getPRIMCHAR (L _ (ITprimchar _ x)) = x+getPRIMSTRING (L _ (ITprimstring _ x)) = x+getPRIMINTEGER (L _ (ITprimint _ x)) = x+getPRIMWORD (L _ (ITprimword _ x)) = x+getPRIMFLOAT (L _ (ITprimfloat x)) = x+getPRIMDOUBLE (L _ (ITprimdouble x)) = x+getINLINE (L _ (ITinline_prag _ inl conl)) = (inl,conl)+getSPEC_INLINE (L _ (ITspec_inline_prag _ True)) = (Inline, FunLike)+getSPEC_INLINE (L _ (ITspec_inline_prag _ False)) = (NoInline,FunLike)+getCOMPLETE_PRAGs (L _ (ITcomplete_prag x)) = x+getVOCURLY (L (RealSrcSpan l _) ITvocurly) = srcSpanStartCol l++getINTEGERs (L _ (ITinteger (IL src _ _))) = src+getCHARs (L _ (ITchar src _)) = src+getSTRINGs (L _ (ITstring src _)) = src+getPRIMCHARs (L _ (ITprimchar src _)) = src+getPRIMSTRINGs (L _ (ITprimstring src _)) = src+getPRIMINTEGERs (L _ (ITprimint src _)) = src+getPRIMWORDs (L _ (ITprimword src _)) = src++-- See Note [Pragma source text] in "GHC.Types.Basic" for the following+getINLINE_PRAGs (L _ (ITinline_prag src _ _)) = src+getSPEC_PRAGs (L _ (ITspec_prag src)) = src+getSPEC_INLINE_PRAGs (L _ (ITspec_inline_prag src _)) = src+getSOURCE_PRAGs (L _ (ITsource_prag src)) = src+getRULES_PRAGs (L _ (ITrules_prag src)) = src+getWARNING_PRAGs (L _ (ITwarning_prag src)) = src+getDEPRECATED_PRAGs (L _ (ITdeprecated_prag src)) = src+getSCC_PRAGs (L _ (ITscc_prag src)) = src+getUNPACK_PRAGs (L _ (ITunpack_prag src)) = src+getNOUNPACK_PRAGs (L _ (ITnounpack_prag src)) = src+getANN_PRAGs (L _ (ITann_prag src)) = src+getMINIMAL_PRAGs (L _ (ITminimal_prag src)) = src+getOVERLAPPABLE_PRAGs (L _ (IToverlappable_prag src)) = src+getOVERLAPPING_PRAGs (L _ (IToverlapping_prag src)) = src+getOVERLAPS_PRAGs (L _ (IToverlaps_prag src)) = src+getINCOHERENT_PRAGs (L _ (ITincoherent_prag src)) = src+getCTYPEs (L _ (ITctype src)) = src++getStringLiteral l = StringLiteral (getSTRINGs l) (getSTRING l) Nothing++isUnicode :: Located Token -> Bool+isUnicode (L _ (ITforall iu)) = iu == UnicodeSyntax+isUnicode (L _ (ITdarrow iu)) = iu == UnicodeSyntax+isUnicode (L _ (ITdcolon iu)) = iu == UnicodeSyntax+isUnicode (L _ (ITlarrow iu)) = iu == UnicodeSyntax+isUnicode (L _ (ITrarrow iu)) = iu == UnicodeSyntax+isUnicode (L _ (ITlarrowtail iu)) = iu == UnicodeSyntax+isUnicode (L _ (ITrarrowtail iu)) = iu == UnicodeSyntax+isUnicode (L _ (ITLarrowtail iu)) = iu == UnicodeSyntax+isUnicode (L _ (ITRarrowtail iu)) = iu == UnicodeSyntax+isUnicode (L _ (IToparenbar iu)) = iu == UnicodeSyntax+isUnicode (L _ (ITcparenbar iu)) = iu == UnicodeSyntax+isUnicode (L _ (ITopenExpQuote _ iu)) = iu == UnicodeSyntax+isUnicode (L _ (ITcloseQuote iu)) = iu == UnicodeSyntax+isUnicode (L _ (ITstar iu)) = iu == UnicodeSyntax+isUnicode (L _ ITlolly) = True+isUnicode _ = False++hasE :: Located Token -> Bool+hasE (L _ (ITopenExpQuote HasE _)) = True+hasE (L _ (ITopenTExpQuote HasE)) = True+hasE _ = False++getSCC :: Located Token -> P FastString+getSCC lt = do let s = getSTRING lt+ -- We probably actually want to be more restrictive than this+ if ' ' `elem` unpackFS s+ then addFatalError $ PsError PsErrSpaceInSCC [] (getLoc lt)+ else return s++-- Utilities for combining source spans+comb2 :: Located a -> Located b -> SrcSpan+comb2 a b = a `seq` b `seq` combineLocs a b++-- Utilities for combining source spans+comb2A :: Located a -> LocatedAn t b -> SrcSpan+comb2A a b = a `seq` b `seq` combineLocs a (reLoc b)++comb2N :: Located a -> LocatedN b -> SrcSpan+comb2N a b = a `seq` b `seq` combineLocs a (reLocN b)++comb2Al :: LocatedAn t a -> Located b -> SrcSpan+comb2Al a b = a `seq` b `seq` combineLocs (reLoc a) b++comb3 :: Located a -> Located b -> Located c -> SrcSpan+comb3 a b c = a `seq` b `seq` c `seq`+ combineSrcSpans (getLoc a) (combineSrcSpans (getLoc b) (getLoc c))++comb3A :: Located a -> Located b -> LocatedAn t c -> SrcSpan+comb3A a b c = a `seq` b `seq` c `seq`+ combineSrcSpans (getLoc a) (combineSrcSpans (getLoc b) (getLocA c))++comb3N :: Located a -> Located b -> LocatedN c -> SrcSpan+comb3N a b c = a `seq` b `seq` c `seq`+ combineSrcSpans (getLoc a) (combineSrcSpans (getLoc b) (getLocA c))++comb4 :: Located a -> Located b -> Located c -> Located d -> SrcSpan+comb4 a b c d = a `seq` b `seq` c `seq` d `seq`+ (combineSrcSpans (getLoc a) $ combineSrcSpans (getLoc b) $+ combineSrcSpans (getLoc c) (getLoc d))++comb5 :: Located a -> Located b -> Located c -> Located d -> Located e -> SrcSpan+comb5 a b c d e = a `seq` b `seq` c `seq` d `seq` e `seq`+ (combineSrcSpans (getLoc a) $ combineSrcSpans (getLoc b) $+ combineSrcSpans (getLoc c) $ combineSrcSpans (getLoc d) (getLoc e))++-- strict constructor version:+{-# INLINE sL #-}+sL :: l -> a -> GenLocated l a+sL loc a = loc `seq` a `seq` L loc a++-- See Note [Adding location info] for how these utility functions are used++-- replaced last 3 CPP macros in this file+{-# INLINE sL0 #-}+sL0 :: a -> Located a+sL0 = L noSrcSpan -- #define L0 L noSrcSpan++{-# INLINE sL1 #-}+sL1 :: GenLocated l a -> b -> GenLocated l b+sL1 x = sL (getLoc x) -- #define sL1 sL (getLoc $1)++{-# INLINE sL1A #-}+sL1A :: LocatedAn t a -> b -> Located b+sL1A x = sL (getLocA x) -- #define sL1 sL (getLoc $1)++{-# INLINE sL1N #-}+sL1N :: LocatedN a -> b -> Located b+sL1N x = sL (getLocA x) -- #define sL1 sL (getLoc $1)++{-# INLINE sL1a #-}+sL1a :: Located a -> b -> LocatedAn t b+sL1a x = sL (noAnnSrcSpan $ getLoc x) -- #define sL1 sL (getLoc $1)++{-# INLINE sL1n #-}+sL1n :: Located a -> b -> LocatedN b+sL1n x = L (noAnnSrcSpan $ getLoc x) -- #define sL1 sL (getLoc $1)++{-# INLINE sLL #-}+sLL :: Located a -> Located b -> c -> Located c+sLL x y = sL (comb2 x y) -- #define LL sL (comb2 $1 $>)++{-# INLINE sLLa #-}+sLLa :: Located a -> Located b -> c -> LocatedAn t c+sLLa x y = sL (noAnnSrcSpan $ comb2 x y) -- #define LL sL (comb2 $1 $>)++{-# INLINE sLLlA #-}+sLLlA :: Located a -> LocatedAn t b -> c -> Located c+sLLlA x y = sL (comb2A x y) -- #define LL sL (comb2 $1 $>)++{-# INLINE sLLAl #-}+sLLAl :: LocatedAn t a -> Located b -> c -> Located c+sLLAl x y = sL (comb2A y x) -- #define LL sL (comb2 $1 $>)++{-# INLINE sLLAA #-}+sLLAA :: LocatedAn t a -> LocatedAn u b -> c -> Located c+sLLAA x y = sL (comb2 (reLoc y) (reLoc x)) -- #define LL sL (comb2 $1 $>)+++{- Note [Adding location info]+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~++This is done using the three functions below, sL0, sL1+and sLL. Note that these functions were mechanically+converted from the three macros that used to exist before,+namely L0, L1 and LL.++They each add a SrcSpan to their argument.++ sL0 adds 'noSrcSpan', used for empty productions+ -- This doesn't seem to work anymore -=chak++ sL1 for a production with a single token on the lhs. Grabs the SrcSpan+ from that token.++ sLL for a production with >1 token on the lhs. Makes up a SrcSpan from+ the first and last tokens.++These suffice for the majority of cases. However, we must be+especially careful with empty productions: sLL won't work if the first+or last token on the lhs can represent an empty span. In these cases,+we have to calculate the span using more of the tokens from the lhs, eg.++ | 'newtype' tycl_hdr '=' newconstr deriving+ { L (comb3 $1 $4 $5)+ (mkTyData NewType (unLoc $2) $4 (unLoc $5)) }++We provide comb3 and comb4 functions which are useful in such cases.++Be careful: there's no checking that you actually got this right, the+only symptom will be that the SrcSpans of your syntax will be+incorrect.++-}++-- Make a source location for the file. We're a bit lazy here and just+-- make a point SrcSpan at line 1, column 0. Strictly speaking we should+-- try to find the span of the whole file (ToDo).+fileSrcSpan :: P SrcSpan+fileSrcSpan = do+ l <- getRealSrcLoc;+ let loc = mkSrcLoc (srcLocFile l) 1 1;+ return (mkSrcSpan loc loc)++-- Hint about linear types+hintLinear :: MonadP m => SrcSpan -> m ()+hintLinear span = do+ linearEnabled <- getBit LinearTypesBit+ unless linearEnabled $ addError $ PsError PsErrLinearFunction [] span++-- Does this look like (a %m)?+looksLikeMult :: LHsType GhcPs -> LocatedN RdrName -> LHsType GhcPs -> Bool+looksLikeMult ty1 l_op ty2+ | Unqual op_name <- unLoc l_op+ , occNameFS op_name == fsLit "%"+ , Just ty1_pos <- getBufSpan (getLocA ty1)+ , Just pct_pos <- getBufSpan (getLocA l_op)+ , Just ty2_pos <- getBufSpan (getLocA ty2)+ , bufSpanEnd ty1_pos /= bufSpanStart pct_pos+ , bufSpanEnd pct_pos == bufSpanStart ty2_pos+ = True+ | otherwise = False++-- Hint about the MultiWayIf extension+hintMultiWayIf :: SrcSpan -> P ()+hintMultiWayIf span = do+ mwiEnabled <- getBit MultiWayIfBit+ unless mwiEnabled $ addError $ PsError PsErrMultiWayIf [] span++-- Hint about explicit-forall+hintExplicitForall :: Located Token -> P ()+hintExplicitForall tok = do+ forall <- getBit ExplicitForallBit+ rulePrag <- getBit InRulePragBit+ unless (forall || rulePrag) $ addError $ PsError (PsErrExplicitForall (isUnicode tok)) [] (getLoc tok)++-- Hint about qualified-do+hintQualifiedDo :: Located Token -> P ()+hintQualifiedDo tok = do+ qualifiedDo <- getBit QualifiedDoBit+ case maybeQDoDoc of+ Just qdoDoc | not qualifiedDo ->+ addError $ PsError (PsErrIllegalQualifiedDo qdoDoc) [] (getLoc tok)+ _ -> return ()+ where+ maybeQDoDoc = case unLoc tok of+ ITdo (Just m) -> Just $ ftext m <> text ".do"+ ITmdo (Just m) -> Just $ ftext m <> text ".mdo"+ t -> Nothing++-- When two single quotes don't followed by tyvar or gtycon, we report the+-- error as empty character literal, or TH quote that missing proper type+-- variable or constructor. See #13450.+reportEmptyDoubleQuotes :: SrcSpan -> P a+reportEmptyDoubleQuotes span = do+ thQuotes <- getBit ThQuotesBit+ addFatalError $ PsError (PsErrEmptyDoubleQuotes thQuotes) [] span++{-+%************************************************************************+%* *+ Helper functions for generating annotations in the parser+%* *+%************************************************************************++For the general principles of the following routines, see Note [exact print annotations]+in GHC.Parser.Annotation++-}++-- |Construct an AddEpAnn from the annotation keyword and the location+-- of the keyword itself+mj :: AnnKeywordId -> Located e -> AddEpAnn+mj a l = AddEpAnn a (EpaSpan $ rs $ gl l)++mjN :: AnnKeywordId -> LocatedN e -> AddEpAnn+mjN a l = AddEpAnn a (EpaSpan $ rs $ glN l)++-- |Construct an AddEpAnn from the annotation keyword and the location+-- of the keyword itself, provided the span is not zero width+mz :: AnnKeywordId -> Located e -> [AddEpAnn]+mz a l = if isZeroWidthSpan (gl l) then [] else [AddEpAnn a (EpaSpan $ rs $ gl l)]++msemi :: Located e -> [TrailingAnn]+msemi l = if isZeroWidthSpan (gl l) then [] else [AddSemiAnn (EpaSpan $ rs $ gl l)]++msemim :: Located e -> Maybe EpaLocation+msemim l = if isZeroWidthSpan (gl l) then Nothing else Just (EpaSpan $ rs $ gl l)++-- |Construct an AddEpAnn from the annotation keyword and the Located Token. If+-- the token has a unicode equivalent and this has been used, provide the+-- unicode variant of the annotation.+mu :: AnnKeywordId -> Located Token -> AddEpAnn+mu a lt@(L l t) = AddEpAnn (toUnicodeAnn a lt) (EpaSpan $ rs l)++mau :: Located Token -> TrailingAnn+mau lt@(L l t) = if isUnicode lt then AddRarrowAnnU (EpaSpan $ rs l)+ else AddRarrowAnn (EpaSpan $ rs l)++mlu :: Located Token -> TrailingAnn+mlu lt@(L l t) = AddLollyAnnU (EpaSpan $ rs l)++-- | If the 'Token' is using its unicode variant return the unicode variant of+-- the annotation+toUnicodeAnn :: AnnKeywordId -> Located Token -> AnnKeywordId+toUnicodeAnn a t = if isUnicode t then unicodeAnn a else a++toUnicode :: Located Token -> IsUnicodeSyntax+toUnicode t = if isUnicode t then UnicodeSyntax else NormalSyntax++gl :: GenLocated l a -> l+gl = getLoc++glA :: LocatedAn t a -> SrcSpan+glA = getLocA++glN :: LocatedN a -> SrcSpan+glN = getLocA++glR :: Located a -> Anchor+glR la = Anchor (realSrcSpan $ getLoc la) UnchangedAnchor++glAA :: Located a -> EpaLocation+glAA = EpaSpan <$> realSrcSpan . getLoc++glRR :: Located a -> RealSrcSpan+glRR = realSrcSpan . getLoc++glAR :: LocatedAn t a -> Anchor+glAR la = Anchor (realSrcSpan $ getLocA la) UnchangedAnchor++glNR :: LocatedN a -> Anchor+glNR ln = Anchor (realSrcSpan $ getLocA ln) UnchangedAnchor++glNRR :: LocatedN a -> EpaLocation+glNRR = EpaSpan <$> realSrcSpan . getLocA++anc :: RealSrcSpan -> Anchor+anc r = Anchor r UnchangedAnchor++acs :: MonadP m => (EpAnnComments -> Located a) -> m (Located a)+acs a = do+ let (L l _) = a emptyComments+ cs <- getCommentsFor l+ return (a cs)++-- Called at the very end to pick up the EOF position, as well as any comments not allocated yet.+acsFinal :: (EpAnnComments -> Located a) -> P (Located a)+acsFinal a = do+ let (L l _) = a emptyComments+ cs <- getCommentsFor l+ csf <- getFinalCommentsFor l+ meof <- getEofPos+ let ce = case meof of+ Nothing -> EpaComments []+ Just (pos, gap) -> EpaCommentsBalanced [] [L (realSpanAsAnchor pos) (EpaComment EpaEofComment gap)]+ return (a (cs Semi.<> csf Semi.<> ce))++acsa :: MonadP m => (EpAnnComments -> LocatedAn t a) -> m (LocatedAn t a)+acsa a = do+ let (L l _) = a emptyComments+ cs <- getCommentsFor (locA l)+ return (a cs)++acsA :: MonadP m => (EpAnnComments -> Located a) -> m (LocatedAn t a)+acsA a = reLocA <$> acs a++acsExpr :: (EpAnnComments -> LHsExpr GhcPs) -> P ECP+acsExpr a = do { expr :: (LHsExpr GhcPs) <- runPV $ acsa a+ ; return (ecpFromExp $ expr) }++amsA :: MonadP m => LocatedA a -> [TrailingAnn] -> m (LocatedA a)+amsA (L l a) bs = do+ cs <- getCommentsFor (locA l)+ return (L (addAnnsA l bs cs) a)++amsAl :: MonadP m => LocatedA a -> SrcSpan -> [TrailingAnn] -> m (LocatedA a)+amsAl (L l a) loc bs = do+ cs <- getCommentsFor loc+ return (L (addAnnsA l bs cs) a)++amsrc :: MonadP m => Located a -> AnnContext -> m (LocatedC a)+amsrc a@(L l _) bs = do+ cs <- getCommentsFor l+ return (reAnnC bs cs a)++amsrl :: MonadP m => Located a -> AnnList -> m (LocatedL a)+amsrl a@(L l _) bs = do+ cs <- getCommentsFor l+ return (reAnnL bs cs a)++amsrp :: MonadP m => Located a -> AnnPragma -> m (LocatedP a)+amsrp a@(L l _) bs = do+ cs <- getCommentsFor l+ return (reAnnL bs cs a)++amsrn :: MonadP m => Located a -> NameAnn -> m (LocatedN a)+amsrn (L l a) an = do+ cs <- getCommentsFor l+ let ann = (EpAnn (spanAsAnchor l) an cs)+ return (L (SrcSpanAnn ann l) a)++-- |Synonyms for AddEpAnn versions of AnnOpen and AnnClose+mo,mc :: Located Token -> AddEpAnn+mo ll = mj AnnOpen ll+mc ll = mj AnnClose ll++moc,mcc :: Located Token -> AddEpAnn+moc ll = mj AnnOpenC ll+mcc ll = mj AnnCloseC ll++mop,mcp :: Located Token -> AddEpAnn+mop ll = mj AnnOpenP ll+mcp ll = mj AnnCloseP ll++moh,mch :: Located Token -> AddEpAnn+moh ll = mj AnnOpenPH ll+mch ll = mj AnnClosePH ll++mos,mcs :: Located Token -> AddEpAnn+mos ll = mj AnnOpenS ll+mcs ll = mj AnnCloseS ll++pvA :: MonadP m => m (Located a) -> m (LocatedAn t a)+pvA a = do { av <- a+ ; return (reLocA av) }++pvN :: MonadP m => m (Located a) -> m (LocatedN a)+pvN a = do { (L l av) <- a+ ; return (L (noAnnSrcSpan l) av) }++pvL :: MonadP m => m (LocatedAn t a) -> m (Located a)+pvL a = do { av <- a+ ; return (reLoc av) }++-- | Parse a Haskell module with Haddock comments.+-- This is done in two steps:+--+-- * 'parseModuleNoHaddock' to build the AST+-- * 'addHaddockToModule' to insert Haddock comments into it+--+-- This is the only parser entry point that deals with Haddock comments.+-- The other entry points ('parseDeclaration', 'parseExpression', etc) do+-- not insert them into the AST.+parseModule :: P (Located HsModule)+parseModule = parseModuleNoHaddock >>= addHaddockToModule++commentsA :: (Monoid ann) => SrcSpan -> EpAnnComments -> SrcSpanAnn' (EpAnn ann)+commentsA loc cs = SrcSpanAnn (EpAnn (Anchor (rs loc) UnchangedAnchor) mempty cs) loc++-- | Instead of getting the *enclosed* comments, this includes the+-- *preceding* ones. It is used at the top level to get comments+-- between top level declarations.+commentsPA :: (Monoid ann) => LocatedAn ann a -> P (LocatedAn ann a)+commentsPA la@(L l a) = do+ cs <- getPriorCommentsFor (getLocA la)+ return (L (addCommentsToSrcAnn l cs) a)++rs :: SrcSpan -> RealSrcSpan+rs (RealSrcSpan l _) = l+rs _ = panic "Parser should only have RealSrcSpan"++hsDoAnn :: Located a -> LocatedAn t b -> AnnKeywordId -> AnnList+hsDoAnn (L l _) (L ll _) kw+ = AnnList (Just $ spanAsAnchor (locA ll)) Nothing Nothing [AddEpAnn kw (EpaSpan $ rs l)] []++listAsAnchor :: [LocatedAn t a] -> Anchor+listAsAnchor [] = spanAsAnchor noSrcSpan+listAsAnchor (L l _:_) = spanAsAnchor (locA l)++-- -------------------------------------++addTrailingCommaFBind :: MonadP m => Fbind b -> SrcSpan -> m (Fbind b)+addTrailingCommaFBind (Left b) l = fmap Left (addTrailingCommaA b l)+addTrailingCommaFBind (Right b) l = fmap Right (addTrailingCommaA b l)++addTrailingVbarA :: MonadP m => LocatedA a -> SrcSpan -> m (LocatedA a)+addTrailingVbarA la span = addTrailingAnnA la span AddVbarAnn++addTrailingSemiA :: MonadP m => LocatedA a -> SrcSpan -> m (LocatedA a)+addTrailingSemiA la span = addTrailingAnnA la span AddSemiAnn++addTrailingCommaA :: MonadP m => LocatedA a -> SrcSpan -> m (LocatedA a)+addTrailingCommaA la span = addTrailingAnnA la span AddCommaAnn++addTrailingAnnA :: MonadP m => LocatedA a -> SrcSpan -> (EpaLocation -> TrailingAnn) -> m (LocatedA a)+addTrailingAnnA (L (SrcSpanAnn anns l) a) ss ta = do+ -- cs <- getCommentsFor l+ let cs = emptyComments+ -- AZ:TODO: generalise updating comments into an annotation+ let+ anns' = if isZeroWidthSpan ss+ then anns+ else addTrailingAnnToA l (ta (EpaSpan $ rs ss)) cs anns+ return (L (SrcSpanAnn anns' l) a)++-- -------------------------------------++addTrailingVbarL :: MonadP m => LocatedL a -> SrcSpan -> m (LocatedL a)+addTrailingVbarL la span = addTrailingAnnL la (AddVbarAnn (EpaSpan $ rs span))++addTrailingCommaL :: MonadP m => LocatedL a -> SrcSpan -> m (LocatedL a)+addTrailingCommaL la span = addTrailingAnnL la (AddCommaAnn (EpaSpan $ rs span))++addTrailingAnnL :: MonadP m => LocatedL a -> TrailingAnn -> m (LocatedL a)+addTrailingAnnL (L (SrcSpanAnn anns l) a) ta = do+ cs <- getCommentsFor l+ let anns' = addTrailingAnnToL l ta cs anns+ return (L (SrcSpanAnn anns' l) a)++-- -------------------------------------++-- Mostly use to add AnnComma, special case it to NOP if adding a zero-width annotation+addTrailingCommaN :: MonadP m => LocatedN a -> SrcSpan -> m (LocatedN a)+addTrailingCommaN (L (SrcSpanAnn anns l) a) span = do+ -- cs <- getCommentsFor l+ let cs = emptyComments+ -- AZ:TODO: generalise updating comments into an annotation+ let anns' = if isZeroWidthSpan span+ then anns+ else addTrailingCommaToN l anns (EpaSpan $ rs span)+ return (L (SrcSpanAnn anns' l) a)++addTrailingCommaS :: Located StringLiteral -> EpaLocation -> Located StringLiteral+addTrailingCommaS (L l sl) span = L l (sl { sl_tc = Just (epaLocationRealSrcSpan span) })++-- -------------------------------------++addTrailingDarrowC :: LocatedC a -> Located Token -> EpAnnComments -> LocatedC a+addTrailingDarrowC (L (SrcSpanAnn EpAnnNotUsed l) a) lt cs =+ let+ u = if (isUnicode lt) then UnicodeSyntax else NormalSyntax+ in L (SrcSpanAnn (EpAnn (spanAsAnchor l) (AnnContext (Just (u,glAA lt)) [] []) cs) l) a+addTrailingDarrowC (L (SrcSpanAnn (EpAnn lr (AnnContext _ o c) csc) l) a) lt cs =+ let+ u = if (isUnicode lt) then UnicodeSyntax else NormalSyntax+ in L (SrcSpanAnn (EpAnn lr (AnnContext (Just (u,glAA lt)) o c) (cs Semi.<> csc)) l) a++-- -------------------------------------++-- We need a location for the where binds, when computing the SrcSpan+-- for the AST element using them. Where there is a span, we return+-- it, else noLoc, which is ignored in the comb2 call.+adaptWhereBinds :: Maybe (Located (HsLocalBinds GhcPs, Maybe EpAnnComments))+ -> Located (HsLocalBinds GhcPs, EpAnnComments)+adaptWhereBinds Nothing = noLoc (EmptyLocalBinds noExtField, emptyComments)+adaptWhereBinds (Just (L l (b, mc))) = L l (b, maybe emptyComments id mc)++}
+ compiler/GHC/Parser/Lexer.x view
@@ -0,0 +1,3526 @@+-----------------------------------------------------------------------------+-- (c) The University of Glasgow, 2006+--+-- GHC's lexer for Haskell 2010 [1].+--+-- This is a combination of an Alex-generated lexer [2] from a regex+-- definition, with some hand-coded bits. [3]+--+-- Completely accurate information about token-spans within the source+-- file is maintained. Every token has a start and end RealSrcLoc+-- attached to it.+--+-- References:+-- [1] https://www.haskell.org/onlinereport/haskell2010/haskellch2.html+-- [2] http://www.haskell.org/alex/+-- [3] https://gitlab.haskell.org/ghc/ghc/wikis/commentary/compiler/parser+--+-----------------------------------------------------------------------------++-- ToDo / known bugs:+-- - parsing integers is a bit slow+-- - readRational is a bit slow+--+-- Known bugs, that were also in the previous version:+-- - M... should be 3 tokens, not 1.+-- - pragma-end should be only valid in a pragma++-- qualified operator NOTES.+--+-- - If M.(+) is a single lexeme, then..+-- - Probably (+) should be a single lexeme too, for consistency.+-- Otherwise ( + ) would be a prefix operator, but M.( + ) would not be.+-- - But we have to rule out reserved operators, otherwise (..) becomes+-- a different lexeme.+-- - Should we therefore also rule out reserved operators in the qualified+-- form? This is quite difficult to achieve. We don't do it for+-- qualified varids.+++-- -----------------------------------------------------------------------------+-- Alex "Haskell code fragment top"++{+{-# LANGUAGE BangPatterns #-}+{-# LANGUAGE DeriveDataTypeable #-}+{-# LANGUAGE LambdaCase #-}+{-# LANGUAGE MultiWayIf #-}++{-# OPTIONS_GHC -funbox-strict-fields #-}+{-# OPTIONS_GHC -Wno-incomplete-uni-patterns #-}++module GHC.Parser.Lexer (+ Token(..), lexer, lexerDbg,+ ParserOpts(..), mkParserOpts,+ PState (..), initParserState, initPragState,+ P(..), ParseResult(..),+ allocateComments, allocatePriorComments, allocateFinalComments,+ MonadP(..),+ getRealSrcLoc, getPState,+ failMsgP, failLocMsgP, srcParseFail,+ getErrorMessages, getMessages,+ popContext, pushModuleContext, setLastToken, setSrcLoc,+ activeContext, nextIsEOF,+ getLexState, popLexState, pushLexState,+ ExtBits(..),+ xtest, xunset, xset,+ lexTokenStream,+ mkParensEpAnn,+ getCommentsFor, getPriorCommentsFor, getFinalCommentsFor,+ getEofPos,+ commentToAnnotation,+ HdkComment(..),+ warnopt,+ ) where++import GHC.Prelude++-- base+import Control.Monad+import Data.Char+import Data.List (stripPrefix, isInfixOf, partition)+import Data.Maybe+import Data.Word++import GHC.Data.EnumSet as EnumSet++-- ghc-boot+import qualified GHC.LanguageExtensions as LangExt++-- bytestring+import Data.ByteString (ByteString)++-- containers+import Data.Map (Map)+import qualified Data.Map as Map++-- compiler+import GHC.Data.Bag+import GHC.Utils.Outputable+import GHC.Utils.Panic+import GHC.Data.StringBuffer+import GHC.Data.FastString+import GHC.Types.Unique.FM+import GHC.Data.Maybe+import GHC.Data.OrdList+import GHC.Utils.Misc ( readSignificandExponentPair, readHexSignificandExponentPair )++import GHC.Types.SrcLoc+import GHC.Types.SourceText+import GHC.Types.Basic ( InlineSpec(..), RuleMatchInfo(..))+import GHC.Hs.Doc++import GHC.Parser.CharClass++import GHC.Parser.Annotation+import GHC.Driver.Flags+import GHC.Parser.Errors+}++-- -----------------------------------------------------------------------------+-- Alex "Character set macros"++-- NB: The logic behind these definitions is also reflected in "GHC.Utils.Lexeme"+-- Any changes here should likely be reflected there.+$unispace = \x05 -- Trick Alex into handling Unicode. See [Unicode in Alex].+$nl = [\n\r\f]+$whitechar = [$nl\v\ $unispace]+$white_no_nl = $whitechar # \n -- TODO #8424+$tab = \t++$ascdigit = 0-9+$unidigit = \x03 -- Trick Alex into handling Unicode. See [Unicode in Alex].+$decdigit = $ascdigit -- for now, should really be $digit (ToDo)+$digit = [$ascdigit $unidigit]++$special = [\(\)\,\;\[\]\`\{\}]+$ascsymbol = [\!\#\$\%\&\*\+\.\/\<\=\>\?\@\\\^\|\-\~\:]+$unisymbol = \x04 -- Trick Alex into handling Unicode. See [Unicode in Alex].+$symbol = [$ascsymbol $unisymbol] # [$special \_\"\']++$unilarge = \x01 -- Trick Alex into handling Unicode. See [Unicode in Alex].+$asclarge = [A-Z]+$large = [$asclarge $unilarge]++$unismall = \x02 -- Trick Alex into handling Unicode. See [Unicode in Alex].+$ascsmall = [a-z]+$small = [$ascsmall $unismall \_]++$unigraphic = \x06 -- Trick Alex into handling Unicode. See [Unicode in Alex].+$graphic = [$small $large $symbol $digit $special $unigraphic \"\']++$binit = 0-1+$octit = 0-7+$hexit = [$decdigit A-F a-f]++$uniidchar = \x07 -- Trick Alex into handling Unicode. See [Unicode in Alex].+$idchar = [$small $large $digit $uniidchar \']++$pragmachar = [$small $large $digit]++$docsym = [\| \^ \* \$]+++-- -----------------------------------------------------------------------------+-- Alex "Regular expression macros"++@varid = $small $idchar* -- variable identifiers+@conid = $large $idchar* -- constructor identifiers++@varsym = ($symbol # \:) $symbol* -- variable (operator) symbol+@consym = \: $symbol* -- constructor (operator) symbol++-- See Note [Lexing NumericUnderscores extension] and #14473+@numspc = _* -- numeric spacer (#14473)+@decimal = $decdigit(@numspc $decdigit)*+@binary = $binit(@numspc $binit)*+@octal = $octit(@numspc $octit)*+@hexadecimal = $hexit(@numspc $hexit)*+@exponent = @numspc [eE] [\-\+]? @decimal+@bin_exponent = @numspc [pP] [\-\+]? @decimal++@qual = (@conid \.)++@qvarid = @qual @varid+@qconid = @qual @conid+@qvarsym = @qual @varsym+@qconsym = @qual @consym++-- QualifiedDo needs to parse "M.do" not as a variable, so as to keep the+-- layout rules.+@qdo = @qual "do"+@qmdo = @qual "mdo"++@floating_point = @numspc @decimal \. @decimal @exponent? | @numspc @decimal @exponent+@hex_floating_point = @numspc @hexadecimal \. @hexadecimal @bin_exponent? | @numspc @hexadecimal @bin_exponent++-- normal signed numerical literals can only be explicitly negative,+-- not explicitly positive (contrast @exponent)+@negative = \-+++-- -----------------------------------------------------------------------------+-- Alex "Identifier"++haskell :-+++-- -----------------------------------------------------------------------------+-- Alex "Rules"++-- everywhere: skip whitespace+$white_no_nl+ ;+$tab { warnTab }++-- Everywhere: deal with nested comments. We explicitly rule out+-- pragmas, "{-#", so that we don't accidentally treat them as comments.+-- (this can happen even though pragmas will normally take precedence due to+-- longest-match, because pragmas aren't valid in every state, but comments+-- are). We also rule out nested Haddock comments, if the -haddock flag is+-- set.++"{-" / { isNormalComment } { nested_comment lexToken }++-- Single-line comments are a bit tricky. Haskell 98 says that two or+-- more dashes followed by a symbol should be parsed as a varsym, so we+-- have to exclude those.++-- Since Haddock comments aren't valid in every state, we need to rule them+-- out here.++-- The following two rules match comments that begin with two dashes, but+-- continue with a different character. The rules test that this character+-- is not a symbol (in which case we'd have a varsym), and that it's not a+-- space followed by a Haddock comment symbol (docsym) (in which case we'd+-- have a Haddock comment). The rules then munch the rest of the line.++"-- " ~$docsym .* { lineCommentToken }+"--" [^$symbol \ ] .* { lineCommentToken }++-- Next, match Haddock comments if no -haddock flag++"-- " $docsym .* / { alexNotPred (ifExtension HaddockBit) } { lineCommentToken }++-- Now, when we've matched comments that begin with 2 dashes and continue+-- with a different character, we need to match comments that begin with three+-- or more dashes (which clearly can't be Haddock comments). We only need to+-- make sure that the first non-dash character isn't a symbol, and munch the+-- rest of the line.++"---"\-* ~$symbol .* { lineCommentToken }++-- Since the previous rules all match dashes followed by at least one+-- character, we also need to match a whole line filled with just dashes.++"--"\-* / { atEOL } { lineCommentToken }++-- We need this rule since none of the other single line comment rules+-- actually match this case.++"-- " / { atEOL } { lineCommentToken }++-- 'bol' state: beginning of a line. Slurp up all the whitespace (including+-- blank lines) until we find a non-whitespace character, then do layout+-- processing.+--+-- One slight wibble here: what if the line begins with {-#? In+-- theory, we have to lex the pragma to see if it's one we recognise,+-- and if it is, then we backtrack and do_bol, otherwise we treat it+-- as a nested comment. We don't bother with this: if the line begins+-- with {-#, then we'll assume it's a pragma we know about and go for do_bol.+<bol> {+ \n ;+ ^\# line { begin line_prag1 }+ ^\# / { followedByDigit } { begin line_prag1 }+ ^\# pragma .* \n ; -- GCC 3.3 CPP generated, apparently+ ^\# \! .* \n ; -- #!, for scripts+ () { do_bol }+}++-- after a layout keyword (let, where, do, of), we begin a new layout+-- context if the curly brace is missing.+-- Careful! This stuff is quite delicate.+<layout, layout_do, layout_if> {+ \{ / { notFollowedBy '-' } { hopefully_open_brace }+ -- we might encounter {-# here, but {- has been handled already+ \n ;+ ^\# (line)? { begin line_prag1 }+}++-- after an 'if', a vertical bar starts a layout context for MultiWayIf+<layout_if> {+ \| / { notFollowedBySymbol } { new_layout_context True dontGenerateSemic ITvbar }+ () { pop }+}++-- do is treated in a subtly different way, see new_layout_context+<layout> () { new_layout_context True generateSemic ITvocurly }+<layout_do> () { new_layout_context False generateSemic ITvocurly }++-- after a new layout context which was found to be to the left of the+-- previous context, we have generated a '{' token, and we now need to+-- generate a matching '}' token.+<layout_left> () { do_layout_left }++<0,option_prags> \n { begin bol }++"{-#" $whitechar* $pragmachar+ / { known_pragma linePrags }+ { dispatch_pragmas linePrags }++-- single-line line pragmas, of the form+-- # <line> "<file>" <extra-stuff> \n+<line_prag1> {+ @decimal $white_no_nl+ \" [$graphic \ ]* \" { setLineAndFile line_prag1a }+ () { failLinePrag1 }+}+<line_prag1a> .* { popLinePrag1 }++-- Haskell-style line pragmas, of the form+-- {-# LINE <line> "<file>" #-}+<line_prag2> {+ @decimal $white_no_nl+ \" [$graphic \ ]* \" { setLineAndFile line_prag2a }+}+<line_prag2a> "#-}"|"-}" { pop }+ -- NOTE: accept -} at the end of a LINE pragma, for compatibility+ -- with older versions of GHC which generated these.++-- Haskell-style column pragmas, of the form+-- {-# COLUMN <column> #-}+<column_prag> @decimal $whitechar* "#-}" { setColumn }++<0,option_prags> {+ "{-#" $whitechar* $pragmachar++ $whitechar+ $pragmachar+ / { known_pragma twoWordPrags }+ { dispatch_pragmas twoWordPrags }++ "{-#" $whitechar* $pragmachar+ / { known_pragma oneWordPrags }+ { dispatch_pragmas oneWordPrags }++ -- We ignore all these pragmas, but don't generate a warning for them+ "{-#" $whitechar* $pragmachar+ / { known_pragma ignoredPrags }+ { dispatch_pragmas ignoredPrags }++ -- ToDo: should only be valid inside a pragma:+ "#-}" { endPrag }+}++<option_prags> {+ "{-#" $whitechar* $pragmachar+ / { known_pragma fileHeaderPrags }+ { dispatch_pragmas fileHeaderPrags }+}++<0> {+ -- In the "0" mode we ignore these pragmas+ "{-#" $whitechar* $pragmachar+ / { known_pragma fileHeaderPrags }+ { nested_comment lexToken }+}++<0,option_prags> {+ "{-#" { warnThen Opt_WarnUnrecognisedPragmas PsWarnUnrecognisedPragma+ (nested_comment lexToken) }+}++-- '0' state: ordinary lexemes++-- Haddock comments++"-- " $docsym / { ifExtension HaddockBit } { multiline_doc_comment }+"{-" \ ? $docsym / { ifExtension HaddockBit } { nested_doc_comment }++-- "special" symbols++<0> {++ -- Don't check ThQuotesBit here as the renamer can produce a better+ -- error message than the lexer (see the thQuotesEnabled check in rnBracket).+ "[|" { token (ITopenExpQuote NoE NormalSyntax) }+ "[||" { token (ITopenTExpQuote NoE) }+ "|]" { token (ITcloseQuote NormalSyntax) }+ "||]" { token ITcloseTExpQuote }++ -- Check ThQuotesBit here as to not steal syntax.+ "[e|" / { ifExtension ThQuotesBit } { token (ITopenExpQuote HasE NormalSyntax) }+ "[e||" / { ifExtension ThQuotesBit } { token (ITopenTExpQuote HasE) }+ "[p|" / { ifExtension ThQuotesBit } { token ITopenPatQuote }+ "[d|" / { ifExtension ThQuotesBit } { layout_token ITopenDecQuote }+ "[t|" / { ifExtension ThQuotesBit } { token ITopenTypQuote }++ "[" @varid "|" / { ifExtension QqBit } { lex_quasiquote_tok }++ -- qualified quasi-quote (#5555)+ "[" @qvarid "|" / { ifExtension QqBit } { lex_qquasiquote_tok }++ $unigraphic -- ⟦+ / { ifCurrentChar '⟦' `alexAndPred`+ ifExtension UnicodeSyntaxBit `alexAndPred`+ ifExtension ThQuotesBit }+ { token (ITopenExpQuote NoE UnicodeSyntax) }+ $unigraphic -- ⟧+ / { ifCurrentChar '⟧' `alexAndPred`+ ifExtension UnicodeSyntaxBit `alexAndPred`+ ifExtension ThQuotesBit }+ { token (ITcloseQuote UnicodeSyntax) }+}++<0> {+ "(|"+ / { ifExtension ArrowsBit `alexAndPred`+ notFollowedBySymbol }+ { special (IToparenbar NormalSyntax) }+ "|)"+ / { ifExtension ArrowsBit }+ { special (ITcparenbar NormalSyntax) }++ $unigraphic -- ⦇+ / { ifCurrentChar '⦇' `alexAndPred`+ ifExtension UnicodeSyntaxBit `alexAndPred`+ ifExtension ArrowsBit }+ { special (IToparenbar UnicodeSyntax) }+ $unigraphic -- ⦈+ / { ifCurrentChar '⦈' `alexAndPred`+ ifExtension UnicodeSyntaxBit `alexAndPred`+ ifExtension ArrowsBit }+ { special (ITcparenbar UnicodeSyntax) }+}++<0> {+ \? @varid / { ifExtension IpBit } { skip_one_varid ITdupipvarid }+}++<0> {+ "#" @varid / { ifExtension OverloadedLabelsBit } { skip_one_varid ITlabelvarid }+}++<0> {+ "(#" / { ifExtension UnboxedTuplesBit `alexOrPred`+ ifExtension UnboxedSumsBit }+ { token IToubxparen }+ "#)" / { ifExtension UnboxedTuplesBit `alexOrPred`+ ifExtension UnboxedSumsBit }+ { token ITcubxparen }+}++<0,option_prags> {+ \( { special IToparen }+ \) { special ITcparen }+ \[ { special ITobrack }+ \] { special ITcbrack }+ \, { special ITcomma }+ \; { special ITsemi }+ \` { special ITbackquote }++ \{ { open_brace }+ \} { close_brace }+}++<0,option_prags> {+ @qdo { qdo_token ITdo }+ @qmdo / { ifExtension RecursiveDoBit } { qdo_token ITmdo }+ @qvarid { idtoken qvarid }+ @qconid { idtoken qconid }+ @varid { varid }+ @conid { idtoken conid }+}++<0> {+ @qvarid "#"+ / { ifExtension MagicHashBit } { idtoken qvarid }+ @qconid "#"+ / { ifExtension MagicHashBit } { idtoken qconid }+ @varid "#"+ / { ifExtension MagicHashBit } { varid }+ @conid "#"+ / { ifExtension MagicHashBit } { idtoken conid }+}++-- Operators classified into prefix, suffix, tight infix, and loose infix.+-- See Note [Whitespace-sensitive operator parsing]+<0> {+ @varsym / { precededByClosingToken `alexAndPred` followedByOpeningToken } { varsym_tight_infix }+ @varsym / { followedByOpeningToken } { varsym_prefix }+ @varsym / { precededByClosingToken } { varsym_suffix }+ @varsym { varsym_loose_infix }+}++-- ToDo: - move `var` and (sym) into lexical syntax?+-- - remove backquote from $special?+<0> {+ @qvarsym { idtoken qvarsym }+ @qconsym { idtoken qconsym }+ @consym { consym }+}++-- For the normal boxed literals we need to be careful+-- when trying to be close to Haskell98++-- Note [Lexing NumericUnderscores extension] (#14473)+--+-- NumericUnderscores extension allows underscores in numeric literals.+-- Multiple underscores are represented with @numspc macro.+-- To be simpler, we have only the definitions with underscores.+-- And then we have a separate function (tok_integral and tok_frac)+-- that validates the literals.+-- If extensions are not enabled, check that there are no underscores.+--+<0> {+ -- Normal integral literals (:: Num a => a, from Integer)+ @decimal { tok_num positive 0 0 decimal }+ 0[bB] @numspc @binary / { ifExtension BinaryLiteralsBit } { tok_num positive 2 2 binary }+ 0[oO] @numspc @octal { tok_num positive 2 2 octal }+ 0[xX] @numspc @hexadecimal { tok_num positive 2 2 hexadecimal }+ @negative @decimal / { negLitPred } { tok_num negative 1 1 decimal }+ @negative 0[bB] @numspc @binary / { negLitPred `alexAndPred`+ ifExtension BinaryLiteralsBit } { tok_num negative 3 3 binary }+ @negative 0[oO] @numspc @octal / { negLitPred } { tok_num negative 3 3 octal }+ @negative 0[xX] @numspc @hexadecimal / { negLitPred } { tok_num negative 3 3 hexadecimal }++ -- Normal rational literals (:: Fractional a => a, from Rational)+ @floating_point { tok_frac 0 tok_float }+ @negative @floating_point / { negLitPred } { tok_frac 0 tok_float }+ 0[xX] @numspc @hex_floating_point / { ifExtension HexFloatLiteralsBit } { tok_frac 0 tok_hex_float }+ @negative 0[xX] @numspc @hex_floating_point+ / { ifExtension HexFloatLiteralsBit `alexAndPred`+ negLitPred } { tok_frac 0 tok_hex_float }+}++<0> {+ -- Unboxed ints (:: Int#) and words (:: Word#)+ -- It's simpler (and faster?) to give separate cases to the negatives,+ -- especially considering octal/hexadecimal prefixes.+ @decimal \# / { ifExtension MagicHashBit } { tok_primint positive 0 1 decimal }+ 0[bB] @numspc @binary \# / { ifExtension MagicHashBit `alexAndPred`+ ifExtension BinaryLiteralsBit } { tok_primint positive 2 3 binary }+ 0[oO] @numspc @octal \# / { ifExtension MagicHashBit } { tok_primint positive 2 3 octal }+ 0[xX] @numspc @hexadecimal \# / { ifExtension MagicHashBit } { tok_primint positive 2 3 hexadecimal }+ @negative @decimal \# / { negHashLitPred } { tok_primint negative 1 2 decimal }+ @negative 0[bB] @numspc @binary \# / { negHashLitPred `alexAndPred`+ ifExtension BinaryLiteralsBit } { tok_primint negative 3 4 binary }+ @negative 0[oO] @numspc @octal \# / { negHashLitPred } { tok_primint negative 3 4 octal }+ @negative 0[xX] @numspc @hexadecimal \#+ / { negHashLitPred } { tok_primint negative 3 4 hexadecimal }++ @decimal \# \# / { ifExtension MagicHashBit } { tok_primword 0 2 decimal }+ 0[bB] @numspc @binary \# \# / { ifExtension MagicHashBit `alexAndPred`+ ifExtension BinaryLiteralsBit } { tok_primword 2 4 binary }+ 0[oO] @numspc @octal \# \# / { ifExtension MagicHashBit } { tok_primword 2 4 octal }+ 0[xX] @numspc @hexadecimal \# \# / { ifExtension MagicHashBit } { tok_primword 2 4 hexadecimal }++ -- Unboxed floats and doubles (:: Float#, :: Double#)+ -- prim_{float,double} work with signed literals+ @floating_point \# / { ifExtension MagicHashBit } { tok_frac 1 tok_primfloat }+ @floating_point \# \# / { ifExtension MagicHashBit } { tok_frac 2 tok_primdouble }++ @negative @floating_point \# / { negHashLitPred } { tok_frac 1 tok_primfloat }+ @negative @floating_point \# \# / { negHashLitPred } { tok_frac 2 tok_primdouble }+}++-- Strings and chars are lexed by hand-written code. The reason is+-- that even if we recognise the string or char here in the regex+-- lexer, we would still have to parse the string afterward in order+-- to convert it to a String.+<0> {+ \' { lex_char_tok }+ \" { lex_string_tok }+}++-- Note [Whitespace-sensitive operator parsing]+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+-- In accord with GHC Proposal #229 https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0229-whitespace-bang-patterns.rst+-- we classify operator occurrences into four categories:+--+-- a ! b -- a loose infix occurrence+-- a!b -- a tight infix occurrence+-- a !b -- a prefix occurrence+-- a! b -- a suffix occurrence+--+-- The rules are a bit more elaborate than simply checking for whitespace, in+-- order to accommodate the following use cases:+--+-- f (!a) = ... -- prefix occurrence+-- g (a !) -- loose infix occurrence+-- g (! a) -- loose infix occurrence+--+-- The precise rules are as follows:+--+-- * Identifiers, literals, and opening brackets (, (#, (|, [, [|, [||, [p|,+-- [e|, [t|, {, ⟦, ⦇, are considered "opening tokens". The function+-- followedByOpeningToken tests whether the next token is an opening token.+--+-- * Identifiers, literals, and closing brackets ), #), |), ], |], }, ⟧, ⦈,+-- are considered "closing tokens". The function precededByClosingToken tests+-- whether the previous token is a closing token.+--+-- * Whitespace, comments, separators, and other tokens, are considered+-- neither opening nor closing.+--+-- * Any unqualified operator occurrence is classified as prefix, suffix, or+-- tight/loose infix, based on preceding and following tokens:+--+-- precededByClosingToken | followedByOpeningToken | Occurrence+-- ------------------------+------------------------+------------+-- False | True | prefix+-- True | False | suffix+-- True | True | tight infix+-- False | False | loose infix+-- ------------------------+------------------------+------------+--+-- A loose infix occurrence is always considered an operator. Other types of+-- occurrences may be assigned a special per-operator meaning override:+--+-- Operator | Occurrence | Token returned+-- ----------+---------------+------------------------------------------+-- ! | prefix | ITbang+-- | | strictness annotation or bang pattern,+-- | | e.g. f !x = rhs, data T = MkT !a+-- | not prefix | ITvarsym "!"+-- | | ordinary operator or type operator,+-- | | e.g. xs ! 3, (! x), Int ! Bool+-- ----------+---------------+------------------------------------------+-- ~ | prefix | ITtilde+-- | | laziness annotation or lazy pattern,+-- | | e.g. f ~x = rhs, data T = MkT ~a+-- | not prefix | ITvarsym "~"+-- | | ordinary operator or type operator,+-- | | e.g. xs ~ 3, (~ x), Int ~ Bool+-- ----------+---------------+------------------------------------------+-- . | prefix | ITproj True+-- | | field projection,+-- | | e.g. .x+-- | tight infix | ITproj False+-- | | field projection,+-- | | e.g. r.x+-- | suffix | ITdot+-- | | function composition,+-- | | e.g. f. g+-- | loose infix | ITdot+-- | | function composition,+-- | | e.g. f . g+-- ----------+---------------+------------------------------------------+-- $ $$ | prefix | ITdollar, ITdollardollar+-- | | untyped or typed Template Haskell splice,+-- | | e.g. $(f x), $$(f x), $$"str"+-- | not prefix | ITvarsym "$", ITvarsym "$$"+-- | | ordinary operator or type operator,+-- | | e.g. f $ g x, a $$ b+-- ----------+---------------+------------------------------------------+-- @ | prefix | ITtypeApp+-- | | type application, e.g. fmap @Maybe+-- | tight infix | ITat+-- | | as-pattern, e.g. f p@(a,b) = rhs+-- | suffix | parse error+-- | | e.g. f p@ x = rhs+-- | loose infix | ITvarsym "@"+-- | | ordinary operator or type operator,+-- | | e.g. f @ g, (f @)+-- ----------+---------------+------------------------------------------+--+-- Also, some of these overrides are guarded behind language extensions.+-- According to the specification, we must determine the occurrence based on+-- surrounding *tokens* (see the proposal for the exact rules). However, in+-- the implementation we cheat a little and do the classification based on+-- characters, for reasons of both simplicity and efficiency (see+-- 'followedByOpeningToken' and 'precededByClosingToken')+--+-- When an operator is subject to a meaning override, it is mapped to special+-- token: ITbang, ITtilde, ITat, ITdollar, ITdollardollar. Otherwise, it is+-- returned as ITvarsym.+--+-- For example, this is how we process the (!):+--+-- precededByClosingToken | followedByOpeningToken | Token+-- ------------------------+------------------------+-------------+-- False | True | ITbang+-- True | False | ITvarsym "!"+-- True | True | ITvarsym "!"+-- False | False | ITvarsym "!"+-- ------------------------+------------------------+-------------+--+-- And this is how we process the (@):+--+-- precededByClosingToken | followedByOpeningToken | Token+-- ------------------------+------------------------+-------------+-- False | True | ITtypeApp+-- True | False | parse error+-- True | True | ITat+-- False | False | ITvarsym "@"+-- ------------------------+------------------------+-------------++-- -----------------------------------------------------------------------------+-- Alex "Haskell code fragment bottom"++{++-- -----------------------------------------------------------------------------+-- The token type++data Token+ = ITas -- Haskell keywords+ | ITcase+ | ITclass+ | ITdata+ | ITdefault+ | ITderiving+ | ITdo (Maybe FastString)+ | ITelse+ | IThiding+ | ITforeign+ | ITif+ | ITimport+ | ITin+ | ITinfix+ | ITinfixl+ | ITinfixr+ | ITinstance+ | ITlet+ | ITmodule+ | ITnewtype+ | ITof+ | ITqualified+ | ITthen+ | ITtype+ | ITwhere++ | ITforall IsUnicodeSyntax -- GHC extension keywords+ | ITexport+ | ITlabel+ | ITdynamic+ | ITsafe+ | ITinterruptible+ | ITunsafe+ | ITstdcallconv+ | ITccallconv+ | ITcapiconv+ | ITprimcallconv+ | ITjavascriptcallconv+ | ITmdo (Maybe FastString)+ | ITfamily+ | ITrole+ | ITgroup+ | ITby+ | ITusing+ | ITpattern+ | ITstatic+ | ITstock+ | ITanyclass+ | ITvia++ -- Backpack tokens+ | ITunit+ | ITsignature+ | ITdependency+ | ITrequires++ -- Pragmas, see note [Pragma source text] in "GHC.Types.Basic"+ | ITinline_prag SourceText InlineSpec RuleMatchInfo+ | ITspec_prag SourceText -- SPECIALISE+ | ITspec_inline_prag SourceText Bool -- SPECIALISE INLINE (or NOINLINE)+ | ITsource_prag SourceText+ | ITrules_prag SourceText+ | ITwarning_prag SourceText+ | ITdeprecated_prag SourceText+ | ITline_prag SourceText -- not usually produced, see 'UsePosPragsBit'+ | ITcolumn_prag SourceText -- not usually produced, see 'UsePosPragsBit'+ | ITscc_prag SourceText+ | ITunpack_prag SourceText+ | ITnounpack_prag SourceText+ | ITann_prag SourceText+ | ITcomplete_prag SourceText+ | ITclose_prag+ | IToptions_prag String+ | ITinclude_prag String+ | ITlanguage_prag+ | ITminimal_prag SourceText+ | IToverlappable_prag SourceText -- instance overlap mode+ | IToverlapping_prag SourceText -- instance overlap mode+ | IToverlaps_prag SourceText -- instance overlap mode+ | ITincoherent_prag SourceText -- instance overlap mode+ | ITctype SourceText+ | ITcomment_line_prag -- See Note [Nested comment line pragmas]++ | ITdotdot -- reserved symbols+ | ITcolon+ | ITdcolon IsUnicodeSyntax+ | ITequal+ | ITlam+ | ITlcase+ | ITvbar+ | ITlarrow IsUnicodeSyntax+ | ITrarrow IsUnicodeSyntax+ | ITdarrow IsUnicodeSyntax+ | ITlolly -- The (⊸) arrow (for LinearTypes)+ | ITminus -- See Note [Minus tokens]+ | ITprefixminus -- See Note [Minus tokens]+ | ITbang -- Prefix (!) only, e.g. f !x = rhs+ | ITtilde -- Prefix (~) only, e.g. f ~x = rhs+ | ITat -- Tight infix (@) only, e.g. f x@pat = rhs+ | ITtypeApp -- Prefix (@) only, e.g. f @t+ | ITpercent -- Prefix (%) only, e.g. a %1 -> b+ | ITstar IsUnicodeSyntax+ | ITdot+ | ITproj Bool -- Extension: OverloadedRecordDotBit++ | ITbiglam -- GHC-extension symbols++ | ITocurly -- special symbols+ | ITccurly+ | ITvocurly+ | ITvccurly+ | ITobrack+ | ITopabrack -- [:, for parallel arrays with -XParallelArrays+ | ITcpabrack -- :], for parallel arrays with -XParallelArrays+ | ITcbrack+ | IToparen+ | ITcparen+ | IToubxparen+ | ITcubxparen+ | ITsemi+ | ITcomma+ | ITunderscore+ | ITbackquote+ | ITsimpleQuote -- '++ | ITvarid FastString -- identifiers+ | ITconid FastString+ | ITvarsym FastString+ | ITconsym FastString+ | ITqvarid (FastString,FastString)+ | ITqconid (FastString,FastString)+ | ITqvarsym (FastString,FastString)+ | ITqconsym (FastString,FastString)++ | ITdupipvarid FastString -- GHC extension: implicit param: ?x+ | ITlabelvarid FastString -- Overloaded label: #x++ | ITchar SourceText Char -- Note [Literal source text] in "GHC.Types.Basic"+ | ITstring SourceText FastString -- Note [Literal source text] in "GHC.Types.Basic"+ | ITinteger IntegralLit -- Note [Literal source text] in "GHC.Types.Basic"+ | ITrational FractionalLit++ | ITprimchar SourceText Char -- Note [Literal source text] in "GHC.Types.Basic"+ | ITprimstring SourceText ByteString -- Note [Literal source text] in "GHC.Types.Basic"+ | ITprimint SourceText Integer -- Note [Literal source text] in "GHC.Types.Basic"+ | ITprimword SourceText Integer -- Note [Literal source text] in "GHC.Types.Basic"+ | ITprimfloat FractionalLit+ | ITprimdouble FractionalLit++ -- Template Haskell extension tokens+ | ITopenExpQuote HasE IsUnicodeSyntax -- [| or [e|+ | ITopenPatQuote -- [p|+ | ITopenDecQuote -- [d|+ | ITopenTypQuote -- [t|+ | ITcloseQuote IsUnicodeSyntax -- |]+ | ITopenTExpQuote HasE -- [|| or [e||+ | ITcloseTExpQuote -- ||]+ | ITdollar -- prefix $+ | ITdollardollar -- prefix $$+ | ITtyQuote -- ''+ | ITquasiQuote (FastString,FastString,PsSpan)+ -- ITquasiQuote(quoter, quote, loc)+ -- represents a quasi-quote of the form+ -- [quoter| quote |]+ | ITqQuasiQuote (FastString,FastString,FastString,PsSpan)+ -- ITqQuasiQuote(Qual, quoter, quote, loc)+ -- represents a qualified quasi-quote of the form+ -- [Qual.quoter| quote |]++ -- Arrow notation extension+ | ITproc+ | ITrec+ | IToparenbar IsUnicodeSyntax -- ^ @(|@+ | ITcparenbar IsUnicodeSyntax -- ^ @|)@+ | ITlarrowtail IsUnicodeSyntax -- ^ @-<@+ | ITrarrowtail IsUnicodeSyntax -- ^ @>-@+ | ITLarrowtail IsUnicodeSyntax -- ^ @-<<@+ | ITRarrowtail IsUnicodeSyntax -- ^ @>>-@++ | ITunknown String -- ^ Used when the lexer can't make sense of it+ | ITeof -- ^ end of file token++ -- Documentation annotations. See Note [PsSpan in Comments]+ | ITdocCommentNext String PsSpan -- ^ something beginning @-- |@+ | ITdocCommentPrev String PsSpan -- ^ something beginning @-- ^@+ | ITdocCommentNamed String PsSpan -- ^ something beginning @-- $@+ | ITdocSection Int String PsSpan -- ^ a section heading+ | ITdocOptions String PsSpan -- ^ doc options (prune, ignore-exports, etc)+ | ITlineComment String PsSpan -- ^ comment starting by "--"+ | ITblockComment String PsSpan -- ^ comment in {- -}++ deriving Show++instance Outputable Token where+ ppr x = text (show x)++{- Note [PsSpan in Comments]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~+When using the Api Annotations to exact print a modified AST, managing+the space before a comment is important. The PsSpan in the comment+token allows this to happen.++We also need to track the space before the end of file. The normal+mechanism of using the previous token does not work, as the ITeof is+synthesised to come at the same location of the last token, and the+normal previous token updating has by then updated the required+location.++We track this using a 2-back location, prev_loc2. This adds extra+processing to every single token, which is a performance hit for+something needed only at the end of the file. This needs+improving. Perhaps a backward scan on eof?+-}++{- Note [Minus tokens]+~~~~~~~~~~~~~~~~~~~~~~+A minus sign can be used in prefix form (-x) and infix form (a - b).++When LexicalNegation is on:+ * ITprefixminus represents the prefix form+ * ITvarsym "-" represents the infix form+ * ITminus is not used++When LexicalNegation is off:+ * ITminus represents all forms+ * ITprefixminus is not used+ * ITvarsym "-" is not used+-}++{- Note [Why not LexicalNegationBit]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+One might wonder why we define NoLexicalNegationBit instead of+LexicalNegationBit. The problem lies in the following line in reservedSymsFM:++ ,("-", ITminus, NormalSyntax, xbit NoLexicalNegationBit)++We want to generate ITminus only when LexicalNegation is off. How would one+do it if we had LexicalNegationBit? I (int-index) tried to use bitwise+complement:++ ,("-", ITminus, NormalSyntax, complement (xbit LexicalNegationBit))++This did not work, so I opted for NoLexicalNegationBit instead.+-}+++-- the bitmap provided as the third component indicates whether the+-- corresponding extension keyword is valid under the extension options+-- provided to the compiler; if the extension corresponding to *any* of the+-- bits set in the bitmap is enabled, the keyword is valid (this setup+-- facilitates using a keyword in two different extensions that can be+-- activated independently)+--+reservedWordsFM :: UniqFM FastString (Token, ExtsBitmap)+reservedWordsFM = listToUFM $+ map (\(x, y, z) -> (mkFastString x, (y, z)))+ [( "_", ITunderscore, 0 ),+ ( "as", ITas, 0 ),+ ( "case", ITcase, 0 ),+ ( "class", ITclass, 0 ),+ ( "data", ITdata, 0 ),+ ( "default", ITdefault, 0 ),+ ( "deriving", ITderiving, 0 ),+ ( "do", ITdo Nothing, 0 ),+ ( "else", ITelse, 0 ),+ ( "hiding", IThiding, 0 ),+ ( "if", ITif, 0 ),+ ( "import", ITimport, 0 ),+ ( "in", ITin, 0 ),+ ( "infix", ITinfix, 0 ),+ ( "infixl", ITinfixl, 0 ),+ ( "infixr", ITinfixr, 0 ),+ ( "instance", ITinstance, 0 ),+ ( "let", ITlet, 0 ),+ ( "module", ITmodule, 0 ),+ ( "newtype", ITnewtype, 0 ),+ ( "of", ITof, 0 ),+ ( "qualified", ITqualified, 0 ),+ ( "then", ITthen, 0 ),+ ( "type", ITtype, 0 ),+ ( "where", ITwhere, 0 ),++ ( "forall", ITforall NormalSyntax, 0),+ ( "mdo", ITmdo Nothing, xbit RecursiveDoBit),+ -- See Note [Lexing type pseudo-keywords]+ ( "family", ITfamily, 0 ),+ ( "role", ITrole, 0 ),+ ( "pattern", ITpattern, xbit PatternSynonymsBit),+ ( "static", ITstatic, xbit StaticPointersBit ),+ ( "stock", ITstock, 0 ),+ ( "anyclass", ITanyclass, 0 ),+ ( "via", ITvia, 0 ),+ ( "group", ITgroup, xbit TransformComprehensionsBit),+ ( "by", ITby, xbit TransformComprehensionsBit),+ ( "using", ITusing, xbit TransformComprehensionsBit),++ ( "foreign", ITforeign, xbit FfiBit),+ ( "export", ITexport, xbit FfiBit),+ ( "label", ITlabel, xbit FfiBit),+ ( "dynamic", ITdynamic, xbit FfiBit),+ ( "safe", ITsafe, xbit FfiBit .|.+ xbit SafeHaskellBit),+ ( "interruptible", ITinterruptible, xbit InterruptibleFfiBit),+ ( "unsafe", ITunsafe, xbit FfiBit),+ ( "stdcall", ITstdcallconv, xbit FfiBit),+ ( "ccall", ITccallconv, xbit FfiBit),+ ( "capi", ITcapiconv, xbit CApiFfiBit),+ ( "prim", ITprimcallconv, xbit FfiBit),+ ( "javascript", ITjavascriptcallconv, xbit FfiBit),++ ( "unit", ITunit, 0 ),+ ( "dependency", ITdependency, 0 ),+ ( "signature", ITsignature, 0 ),++ ( "rec", ITrec, xbit ArrowsBit .|.+ xbit RecursiveDoBit),+ ( "proc", ITproc, xbit ArrowsBit)+ ]++{-----------------------------------+Note [Lexing type pseudo-keywords]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~++One might think that we wish to treat 'family' and 'role' as regular old+varids whenever -XTypeFamilies and -XRoleAnnotations are off, respectively.+But, there is no need to do so. These pseudo-keywords are not stolen syntax:+they are only used after the keyword 'type' at the top-level, where varids are+not allowed. Furthermore, checks further downstream (GHC.Tc.TyCl) ensure that+type families and role annotations are never declared without their extensions+on. In fact, by unconditionally lexing these pseudo-keywords as special, we+can get better error messages.++Also, note that these are included in the `varid` production in the parser --+a key detail to make all this work.+-------------------------------------}++reservedSymsFM :: UniqFM FastString (Token, IsUnicodeSyntax, ExtsBitmap)+reservedSymsFM = listToUFM $+ map (\ (x,w,y,z) -> (mkFastString x,(w,y,z)))+ [ ("..", ITdotdot, NormalSyntax, 0 )+ -- (:) is a reserved op, meaning only list cons+ ,(":", ITcolon, NormalSyntax, 0 )+ ,("::", ITdcolon NormalSyntax, NormalSyntax, 0 )+ ,("=", ITequal, NormalSyntax, 0 )+ ,("\\", ITlam, NormalSyntax, 0 )+ ,("|", ITvbar, NormalSyntax, 0 )+ ,("<-", ITlarrow NormalSyntax, NormalSyntax, 0 )+ ,("->", ITrarrow NormalSyntax, NormalSyntax, 0 )+ ,("=>", ITdarrow NormalSyntax, NormalSyntax, 0 )+ ,("-", ITminus, NormalSyntax, xbit NoLexicalNegationBit)++ ,("*", ITstar NormalSyntax, NormalSyntax, xbit StarIsTypeBit)++ -- For 'forall a . t'+ ,(".", ITdot, NormalSyntax, 0 )++ ,("-<", ITlarrowtail NormalSyntax, NormalSyntax, xbit ArrowsBit)+ ,(">-", ITrarrowtail NormalSyntax, NormalSyntax, xbit ArrowsBit)+ ,("-<<", ITLarrowtail NormalSyntax, NormalSyntax, xbit ArrowsBit)+ ,(">>-", ITRarrowtail NormalSyntax, NormalSyntax, xbit ArrowsBit)++ ,("∷", ITdcolon UnicodeSyntax, UnicodeSyntax, 0 )+ ,("⇒", ITdarrow UnicodeSyntax, UnicodeSyntax, 0 )+ ,("∀", ITforall UnicodeSyntax, UnicodeSyntax, 0 )+ ,("→", ITrarrow UnicodeSyntax, UnicodeSyntax, 0 )+ ,("←", ITlarrow UnicodeSyntax, UnicodeSyntax, 0 )++ ,("⊸", ITlolly, UnicodeSyntax, 0)++ ,("⤙", ITlarrowtail UnicodeSyntax, UnicodeSyntax, xbit ArrowsBit)+ ,("⤚", ITrarrowtail UnicodeSyntax, UnicodeSyntax, xbit ArrowsBit)+ ,("⤛", ITLarrowtail UnicodeSyntax, UnicodeSyntax, xbit ArrowsBit)+ ,("⤜", ITRarrowtail UnicodeSyntax, UnicodeSyntax, xbit ArrowsBit)++ ,("★", ITstar UnicodeSyntax, UnicodeSyntax, xbit StarIsTypeBit)++ -- ToDo: ideally, → and ∷ should be "specials", so that they cannot+ -- form part of a large operator. This would let us have a better+ -- syntax for kinds: ɑ∷*→* would be a legal kind signature. (maybe).+ ]++-- -----------------------------------------------------------------------------+-- Lexer actions++type Action = PsSpan -> StringBuffer -> Int -> P (PsLocated Token)++special :: Token -> Action+special tok span _buf _len = return (L span tok)++token, layout_token :: Token -> Action+token t span _buf _len = return (L span t)+layout_token t span _buf _len = pushLexState layout >> return (L span t)++idtoken :: (StringBuffer -> Int -> Token) -> Action+idtoken f span buf len = return (L span $! (f buf len))++qdo_token :: (Maybe FastString -> Token) -> Action+qdo_token con span buf len = do+ maybe_layout token+ return (L span $! token)+ where+ !token = con $! Just $! fst $! splitQualName buf len False++skip_one_varid :: (FastString -> Token) -> Action+skip_one_varid f span buf len+ = return (L span $! f (lexemeToFastString (stepOn buf) (len-1)))++skip_two_varid :: (FastString -> Token) -> Action+skip_two_varid f span buf len+ = return (L span $! f (lexemeToFastString (stepOn (stepOn buf)) (len-2)))++strtoken :: (String -> Token) -> Action+strtoken f span buf len =+ return (L span $! (f $! lexemeToString buf len))++begin :: Int -> Action+begin code _span _str _len = do pushLexState code; lexToken++pop :: Action+pop _span _buf _len = do _ <- popLexState+ lexToken+-- See Note [Nested comment line pragmas]+failLinePrag1 :: Action+failLinePrag1 span _buf _len = do+ b <- getBit InNestedCommentBit+ if b then return (L span ITcomment_line_prag)+ else lexError LexErrorInPragma++-- See Note [Nested comment line pragmas]+popLinePrag1 :: Action+popLinePrag1 span _buf _len = do+ b <- getBit InNestedCommentBit+ if b then return (L span ITcomment_line_prag) else do+ _ <- popLexState+ lexToken++hopefully_open_brace :: Action+hopefully_open_brace span buf len+ = do relaxed <- getBit RelaxedLayoutBit+ ctx <- getContext+ (AI l _) <- getInput+ let offset = srcLocCol (psRealLoc l)+ isOK = relaxed ||+ case ctx of+ Layout prev_off _ : _ -> prev_off < offset+ _ -> True+ if isOK then pop_and open_brace span buf len+ else addFatalError $ PsError PsErrMissingBlock [] (mkSrcSpanPs span)++pop_and :: Action -> Action+pop_and act span buf len = do _ <- popLexState+ act span buf len++-- See Note [Whitespace-sensitive operator parsing]+followedByOpeningToken :: AlexAccPred ExtsBitmap+followedByOpeningToken _ _ _ (AI _ buf)+ | atEnd buf = False+ | otherwise =+ case nextChar buf of+ ('{', buf') -> nextCharIsNot buf' (== '-')+ ('(', _) -> True+ ('[', _) -> True+ ('\"', _) -> True+ ('\'', _) -> True+ ('_', _) -> True+ ('⟦', _) -> True+ ('⦇', _) -> True+ (c, _) -> isAlphaNum c++-- See Note [Whitespace-sensitive operator parsing]+precededByClosingToken :: AlexAccPred ExtsBitmap+precededByClosingToken _ (AI _ buf) _ _ =+ case prevChar buf '\n' of+ '}' -> decodePrevNChars 1 buf /= "-"+ ')' -> True+ ']' -> True+ '\"' -> True+ '\'' -> True+ '_' -> True+ '⟧' -> True+ '⦈' -> True+ c -> isAlphaNum c++{-# INLINE nextCharIs #-}+nextCharIs :: StringBuffer -> (Char -> Bool) -> Bool+nextCharIs buf p = not (atEnd buf) && p (currentChar buf)++{-# INLINE nextCharIsNot #-}+nextCharIsNot :: StringBuffer -> (Char -> Bool) -> Bool+nextCharIsNot buf p = not (nextCharIs buf p)++notFollowedBy :: Char -> AlexAccPred ExtsBitmap+notFollowedBy char _ _ _ (AI _ buf)+ = nextCharIsNot buf (== char)++notFollowedBySymbol :: AlexAccPred ExtsBitmap+notFollowedBySymbol _ _ _ (AI _ buf)+ = nextCharIsNot buf (`elem` "!#$%&*+./<=>?@\\^|-~")++followedByDigit :: AlexAccPred ExtsBitmap+followedByDigit _ _ _ (AI _ buf)+ = afterOptionalSpace buf (\b -> nextCharIs b (`elem` ['0'..'9']))++ifCurrentChar :: Char -> AlexAccPred ExtsBitmap+ifCurrentChar char _ (AI _ buf) _ _+ = nextCharIs buf (== char)++-- We must reject doc comments as being ordinary comments everywhere.+-- In some cases the doc comment will be selected as the lexeme due to+-- maximal munch, but not always, because the nested comment rule is+-- valid in all states, but the doc-comment rules are only valid in+-- the non-layout states.+isNormalComment :: AlexAccPred ExtsBitmap+isNormalComment bits _ _ (AI _ buf)+ | HaddockBit `xtest` bits = notFollowedByDocOrPragma+ | otherwise = nextCharIsNot buf (== '#')+ where+ notFollowedByDocOrPragma+ = afterOptionalSpace buf (\b -> nextCharIsNot b (`elem` "|^*$#"))++afterOptionalSpace :: StringBuffer -> (StringBuffer -> Bool) -> Bool+afterOptionalSpace buf p+ = if nextCharIs buf (== ' ')+ then p (snd (nextChar buf))+ else p buf++atEOL :: AlexAccPred ExtsBitmap+atEOL _ _ _ (AI _ buf) = atEnd buf || currentChar buf == '\n'++-- Check if we should parse a negative literal (e.g. -123) as a single token.+negLitPred :: AlexAccPred ExtsBitmap+negLitPred =+ prefix_minus `alexAndPred`+ (negative_literals `alexOrPred` lexical_negation)+ where+ negative_literals = ifExtension NegativeLiteralsBit++ lexical_negation =+ -- See Note [Why not LexicalNegationBit]+ alexNotPred (ifExtension NoLexicalNegationBit)++ prefix_minus =+ -- Note [prefix_minus in negLitPred and negHashLitPred]+ alexNotPred precededByClosingToken++-- Check if we should parse an unboxed negative literal (e.g. -123#) as a single token.+negHashLitPred :: AlexAccPred ExtsBitmap+negHashLitPred = prefix_minus `alexAndPred` magic_hash+ where+ magic_hash = ifExtension MagicHashBit+ prefix_minus =+ -- Note [prefix_minus in negLitPred and negHashLitPred]+ alexNotPred precededByClosingToken++{- Note [prefix_minus in negLitPred and negHashLitPred]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+We want to parse -1 as a single token, but x-1 as three tokens.+So in negLitPred (and negHashLitPred) we require that we have a prefix+occurrence of the minus sign. See Note [Whitespace-sensitive operator parsing]+for a detailed definition of a prefix occurrence.++The condition for a prefix occurrence of an operator is:++ not precededByClosingToken && followedByOpeningToken++but we don't check followedByOpeningToken when parsing a negative literal.+It holds simply because we immediately lex a literal after the minus.+-}++ifExtension :: ExtBits -> AlexAccPred ExtsBitmap+ifExtension extBits bits _ _ _ = extBits `xtest` bits++alexNotPred p userState in1 len in2+ = not (p userState in1 len in2)++alexOrPred p1 p2 userState in1 len in2+ = p1 userState in1 len in2 || p2 userState in1 len in2++multiline_doc_comment :: Action+multiline_doc_comment span buf _len = withLexedDocType (worker "")+ where+ worker commentAcc input docType checkNextLine = case alexGetChar' input of+ Just ('\n', input')+ | checkNextLine -> case checkIfCommentLine input' of+ Just input -> worker ('\n':commentAcc) input docType checkNextLine+ Nothing -> docCommentEnd input commentAcc docType buf span+ | otherwise -> docCommentEnd input commentAcc docType buf span+ Just (c, input) -> worker (c:commentAcc) input docType checkNextLine+ Nothing -> docCommentEnd input commentAcc docType buf span++ -- Check if the next line of input belongs to this doc comment as well.+ -- A doc comment continues onto the next line when the following+ -- conditions are met:+ -- * The line starts with "--"+ -- * The line doesn't start with "---".+ -- * The line doesn't start with "-- $", because that would be the+ -- start of a /new/ named haddock chunk (#10398).+ checkIfCommentLine :: AlexInput -> Maybe AlexInput+ checkIfCommentLine input = check (dropNonNewlineSpace input)+ where+ check input = do+ ('-', input) <- alexGetChar' input+ ('-', input) <- alexGetChar' input+ (c, after_c) <- alexGetChar' input+ case c of+ '-' -> Nothing+ ' ' -> case alexGetChar' after_c of+ Just ('$', _) -> Nothing+ _ -> Just input+ _ -> Just input++ dropNonNewlineSpace input = case alexGetChar' input of+ Just (c, input')+ | isSpace c && c /= '\n' -> dropNonNewlineSpace input'+ | otherwise -> input+ Nothing -> input++lineCommentToken :: Action+lineCommentToken span buf len = do+ b <- getBit RawTokenStreamBit+ if b then do+ lt <- getLastLocComment+ strtoken (\s -> ITlineComment s lt) span buf len+ else lexToken+++{-+ nested comments require traversing by hand, they can't be parsed+ using regular expressions.+-}+nested_comment :: P (PsLocated Token) -> Action+nested_comment cont span buf len = do+ input <- getInput+ go (reverse $ lexemeToString buf len) (1::Int) input+ where+ go commentAcc 0 input = do+ l <- getLastLocComment+ let finalizeComment str = (Nothing, ITblockComment str l)+ commentEnd cont input commentAcc finalizeComment buf span+ go commentAcc n input = case alexGetChar' input of+ Nothing -> errBrace input (psRealSpan span)+ Just ('-',input) -> case alexGetChar' input of+ Nothing -> errBrace input (psRealSpan span)+ Just ('\125',input) -> go ('\125':'-':commentAcc) (n-1) input -- '}'+ Just (_,_) -> go ('-':commentAcc) n input+ Just ('\123',input) -> case alexGetChar' input of -- '{' char+ Nothing -> errBrace input (psRealSpan span)+ Just ('-',input) -> go ('-':'\123':commentAcc) (n+1) input+ Just (_,_) -> go ('\123':commentAcc) n input+ -- See Note [Nested comment line pragmas]+ Just ('\n',input) -> case alexGetChar' input of+ Nothing -> errBrace input (psRealSpan span)+ Just ('#',_) -> do (parsedAcc,input) <- parseNestedPragma input+ go (parsedAcc ++ '\n':commentAcc) n input+ Just (_,_) -> go ('\n':commentAcc) n input+ Just (c,input) -> go (c:commentAcc) n input++nested_doc_comment :: Action+nested_doc_comment span buf _len = withLexedDocType (go "")+ where+ go commentAcc input docType _ = case alexGetChar' input of+ Nothing -> errBrace input (psRealSpan span)+ Just ('-',input) -> case alexGetChar' input of+ Nothing -> errBrace input (psRealSpan span)+ Just ('\125',input) ->+ docCommentEnd input commentAcc docType buf span+ Just (_,_) -> go ('-':commentAcc) input docType False+ Just ('\123', input) -> case alexGetChar' input of+ Nothing -> errBrace input (psRealSpan span)+ Just ('-',input) -> do+ setInput input+ let cont = do input <- getInput; go commentAcc input docType False+ nested_comment cont span buf _len+ Just (_,_) -> go ('\123':commentAcc) input docType False+ -- See Note [Nested comment line pragmas]+ Just ('\n',input) -> case alexGetChar' input of+ Nothing -> errBrace input (psRealSpan span)+ Just ('#',_) -> do (parsedAcc,input) <- parseNestedPragma input+ go (parsedAcc ++ '\n':commentAcc) input docType False+ Just (_,_) -> go ('\n':commentAcc) input docType False+ Just (c,input) -> go (c:commentAcc) input docType False++-- See Note [Nested comment line pragmas]+parseNestedPragma :: AlexInput -> P (String,AlexInput)+parseNestedPragma input@(AI _ buf) = do+ origInput <- getInput+ setInput input+ setExts (.|. xbit InNestedCommentBit)+ pushLexState bol+ lt <- lexToken+ _ <- popLexState+ setExts (.&. complement (xbit InNestedCommentBit))+ postInput@(AI _ postBuf) <- getInput+ setInput origInput+ case unLoc lt of+ ITcomment_line_prag -> do+ let bytes = byteDiff buf postBuf+ diff = lexemeToString buf bytes+ return (reverse diff, postInput)+ lt' -> panic ("parseNestedPragma: unexpected token" ++ (show lt'))++{-+Note [Nested comment line pragmas]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+We used to ignore cpp-preprocessor-generated #line pragmas if they were inside+nested comments.++Now, when parsing a nested comment, if we encounter a line starting with '#' we+call parseNestedPragma, which executes the following:+1. Save the current lexer input (loc, buf) for later+2. Set the current lexer input to the beginning of the line starting with '#'+3. Turn the 'InNestedComment' extension on+4. Push the 'bol' lexer state+5. Lex a token. Due to (2), (3), and (4), this should always lex a single line+ or less and return the ITcomment_line_prag token. This may set source line+ and file location if a #line pragma is successfully parsed+6. Restore lexer input and state to what they were before we did all this+7. Return control to the function parsing a nested comment, informing it of+ what the lexer parsed++Regarding (5) above:+Every exit from the 'bol' lexer state (do_bol, popLinePrag1, failLinePrag1)+checks if the 'InNestedComment' extension is set. If it is, that function will+return control to parseNestedPragma by returning the ITcomment_line_prag token.++See #314 for more background on the bug this fixes.+-}++withLexedDocType :: (AlexInput -> (String -> (HdkComment, Token)) -> Bool -> P (PsLocated Token))+ -> P (PsLocated Token)+withLexedDocType lexDocComment = do+ input@(AI _ buf) <- getInput+ l <- getLastLocComment+ case prevChar buf ' ' of+ -- The `Bool` argument to lexDocComment signals whether or not the next+ -- line of input might also belong to this doc comment.+ '|' -> lexDocComment input (mkHdkCommentNext l) True+ '^' -> lexDocComment input (mkHdkCommentPrev l) True+ '$' -> lexDocComment input (mkHdkCommentNamed l) True+ '*' -> lexDocSection l 1 input+ _ -> panic "withLexedDocType: Bad doc type"+ where+ lexDocSection l n input = case alexGetChar' input of+ Just ('*', input) -> lexDocSection l (n+1) input+ Just (_, _) -> lexDocComment input (mkHdkCommentSection l n) False+ Nothing -> do setInput input; lexToken -- eof reached, lex it normally++mkHdkCommentNext, mkHdkCommentPrev :: PsSpan -> String -> (HdkComment, Token)+mkHdkCommentNext loc str = (HdkCommentNext (mkHsDocString str), ITdocCommentNext str loc)+mkHdkCommentPrev loc str = (HdkCommentPrev (mkHsDocString str), ITdocCommentPrev str loc)++mkHdkCommentNamed :: PsSpan -> String -> (HdkComment, Token)+mkHdkCommentNamed loc str =+ let (name, rest) = break isSpace str+ in (HdkCommentNamed name (mkHsDocString rest), ITdocCommentNamed str loc)++mkHdkCommentSection :: PsSpan -> Int -> String -> (HdkComment, Token)+mkHdkCommentSection loc n str =+ (HdkCommentSection n (mkHsDocString str), ITdocSection n str loc)++-- RULES pragmas turn on the forall and '.' keywords, and we turn them+-- off again at the end of the pragma.+rulePrag :: Action+rulePrag span buf len = do+ setExts (.|. xbit InRulePragBit)+ let !src = lexemeToString buf len+ return (L span (ITrules_prag (SourceText src)))++-- When 'UsePosPragsBit' is not set, it is expected that we emit a token instead+-- of updating the position in 'PState'+linePrag :: Action+linePrag span buf len = do+ usePosPrags <- getBit UsePosPragsBit+ if usePosPrags+ then begin line_prag2 span buf len+ else let !src = lexemeToString buf len+ in return (L span (ITline_prag (SourceText src)))++-- When 'UsePosPragsBit' is not set, it is expected that we emit a token instead+-- of updating the position in 'PState'+columnPrag :: Action+columnPrag span buf len = do+ usePosPrags <- getBit UsePosPragsBit+ let !src = lexemeToString buf len+ if usePosPrags+ then begin column_prag span buf len+ else let !src = lexemeToString buf len+ in return (L span (ITcolumn_prag (SourceText src)))++endPrag :: Action+endPrag span _buf _len = do+ setExts (.&. complement (xbit InRulePragBit))+ return (L span ITclose_prag)++-- docCommentEnd+-------------------------------------------------------------------------------+-- This function is quite tricky. We can't just return a new token, we also+-- need to update the state of the parser. Why? Because the token is longer+-- than what was lexed by Alex, and the lexToken function doesn't know this, so+-- it writes the wrong token length to the parser state. This function is+-- called afterwards, so it can just update the state.++commentEnd :: P (PsLocated Token)+ -> AlexInput+ -> String+ -> (String -> (Maybe HdkComment, Token))+ -> StringBuffer+ -> PsSpan+ -> P (PsLocated Token)+commentEnd cont input commentAcc finalizeComment buf span = do+ setInput input+ let (AI loc nextBuf) = input+ comment = reverse commentAcc+ span' = mkPsSpan (psSpanStart span) loc+ last_len = byteDiff buf nextBuf+ span `seq` setLastToken span' last_len+ let (m_hdk_comment, hdk_token) = finalizeComment comment+ whenIsJust m_hdk_comment $ \hdk_comment ->+ P $ \s -> POk (s {hdk_comments = hdk_comments s `snocOL` L span' hdk_comment}) ()+ b <- getBit RawTokenStreamBit+ if b then return (L span' hdk_token)+ else cont++docCommentEnd :: AlexInput -> String -> (String -> (HdkComment, Token)) -> StringBuffer ->+ PsSpan -> P (PsLocated Token)+docCommentEnd input commentAcc docType buf span = do+ let finalizeComment str =+ let (hdk_comment, token) = docType str+ in (Just hdk_comment, token)+ commentEnd lexToken input commentAcc finalizeComment buf span++errBrace :: AlexInput -> RealSrcSpan -> P a+errBrace (AI end _) span = failLocMsgP (realSrcSpanStart span) (psRealLoc end) (PsError (PsErrLexer LexUnterminatedComment LexErrKind_EOF) [])++open_brace, close_brace :: Action+open_brace span _str _len = do+ ctx <- getContext+ setContext (NoLayout:ctx)+ return (L span ITocurly)+close_brace span _str _len = do+ popContext+ return (L span ITccurly)++qvarid, qconid :: StringBuffer -> Int -> Token+qvarid buf len = ITqvarid $! splitQualName buf len False+qconid buf len = ITqconid $! splitQualName buf len False++splitQualName :: StringBuffer -> Int -> Bool -> (FastString,FastString)+-- takes a StringBuffer and a length, and returns the module name+-- and identifier parts of a qualified name. Splits at the *last* dot,+-- because of hierarchical module names.+--+-- Throws an error if the name is not qualified.+splitQualName orig_buf len parens = split orig_buf orig_buf+ where+ split buf dot_buf+ | orig_buf `byteDiff` buf >= len = done dot_buf+ | c == '.' = found_dot buf'+ | otherwise = split buf' dot_buf+ where+ (c,buf') = nextChar buf++ -- careful, we might get names like M....+ -- so, if the character after the dot is not upper-case, this is+ -- the end of the qualifier part.+ found_dot buf -- buf points after the '.'+ | isUpper c = split buf' buf+ | otherwise = done buf+ where+ (c,buf') = nextChar buf++ done dot_buf+ | qual_size < 1 = error "splitQualName got an unqualified named"+ | otherwise =+ (lexemeToFastString orig_buf (qual_size - 1),+ if parens -- Prelude.(+)+ then lexemeToFastString (stepOn dot_buf) (len - qual_size - 2)+ else lexemeToFastString dot_buf (len - qual_size))+ where+ qual_size = orig_buf `byteDiff` dot_buf++varid :: Action+varid span buf len =+ case lookupUFM reservedWordsFM fs of+ Just (ITcase, _) -> do+ lastTk <- getLastTk+ keyword <- case lastTk of+ Just (L _ ITlam) -> do+ lambdaCase <- getBit LambdaCaseBit+ unless lambdaCase $ do+ pState <- getPState+ addError $ PsError PsErrLambdaCase [] (mkSrcSpanPs (last_loc pState))+ return ITlcase+ _ -> return ITcase+ maybe_layout keyword+ return $ L span keyword+ Just (keyword, 0) -> do+ maybe_layout keyword+ return $ L span keyword+ Just (keyword, i) -> do+ exts <- getExts+ if exts .&. i /= 0+ then do+ maybe_layout keyword+ return $ L span keyword+ else+ return $ L span $ ITvarid fs+ Nothing ->+ return $ L span $ ITvarid fs+ where+ !fs = lexemeToFastString buf len++conid :: StringBuffer -> Int -> Token+conid buf len = ITconid $! lexemeToFastString buf len++qvarsym, qconsym :: StringBuffer -> Int -> Token+qvarsym buf len = ITqvarsym $! splitQualName buf len False+qconsym buf len = ITqconsym $! splitQualName buf len False++-- See Note [Whitespace-sensitive operator parsing]+varsym_prefix :: Action+varsym_prefix = sym $ \span exts s ->+ let warnExtConflict errtok =+ do { addWarning Opt_WarnOperatorWhitespaceExtConflict $+ PsWarnOperatorWhitespaceExtConflict (mkSrcSpanPs span) errtok+ ; return (ITvarsym s) }+ in+ if | s == fsLit "@" ->+ return ITtypeApp -- regardless of TypeApplications for better error messages+ | s == fsLit "%" ->+ if xtest LinearTypesBit exts+ then return ITpercent+ else warnExtConflict OperatorWhitespaceSymbol_PrefixPercent+ | s == fsLit "$" ->+ if xtest ThQuotesBit exts+ then return ITdollar+ else warnExtConflict OperatorWhitespaceSymbol_PrefixDollar+ | s == fsLit "$$" ->+ if xtest ThQuotesBit exts+ then return ITdollardollar+ else warnExtConflict OperatorWhitespaceSymbol_PrefixDollarDollar+ | s == fsLit "-" ->+ return ITprefixminus -- Only when LexicalNegation is on, otherwise we get ITminus+ -- and don't hit this code path. See Note [Minus tokens]+ | s == fsLit ".", OverloadedRecordDotBit `xtest` exts ->+ return (ITproj True) -- e.g. '(.x)'+ | s == fsLit "." -> return ITdot+ | s == fsLit "!" -> return ITbang+ | s == fsLit "~" -> return ITtilde+ | otherwise ->+ do { addWarning Opt_WarnOperatorWhitespace $+ PsWarnOperatorWhitespace (mkSrcSpanPs span) s+ OperatorWhitespaceOccurrence_Prefix+ ; return (ITvarsym s) }++-- See Note [Whitespace-sensitive operator parsing]+varsym_suffix :: Action+varsym_suffix = sym $ \span _ s ->+ if | s == fsLit "@" -> failMsgP (PsError PsErrSuffixAT [])+ | s == fsLit "." -> return ITdot+ | otherwise ->+ do { addWarning Opt_WarnOperatorWhitespace $+ PsWarnOperatorWhitespace (mkSrcSpanPs span) s+ OperatorWhitespaceOccurrence_Suffix+ ; return (ITvarsym s) }++-- See Note [Whitespace-sensitive operator parsing]+varsym_tight_infix :: Action+varsym_tight_infix = sym $ \span exts s ->+ if | s == fsLit "@" -> return ITat+ | s == fsLit ".", OverloadedRecordDotBit `xtest` exts -> return (ITproj False)+ | s == fsLit "." -> return ITdot+ | otherwise ->+ do { addWarning Opt_WarnOperatorWhitespace $+ PsWarnOperatorWhitespace (mkSrcSpanPs span) s+ OperatorWhitespaceOccurrence_TightInfix+ ; return (ITvarsym s) }++-- See Note [Whitespace-sensitive operator parsing]+varsym_loose_infix :: Action+varsym_loose_infix = sym $ \_ _ s ->+ if | s == fsLit "."+ -> return ITdot+ | otherwise+ -> return $ ITvarsym s++consym :: Action+consym = sym (\_span _exts s -> return $ ITconsym s)++sym :: (PsSpan -> ExtsBitmap -> FastString -> P Token) -> Action+sym con span buf len =+ case lookupUFM reservedSymsFM fs of+ Just (keyword, NormalSyntax, 0) -> do+ exts <- getExts+ if fs == fsLit "." &&+ exts .&. (xbit OverloadedRecordDotBit) /= 0 &&+ xtest OverloadedRecordDotBit exts+ then L span <$!> con span exts fs -- Process by varsym_*.+ else return $ L span keyword+ Just (keyword, NormalSyntax, i) -> do+ exts <- getExts+ if exts .&. i /= 0+ then return $ L span keyword+ else L span <$!> con span exts fs+ Just (keyword, UnicodeSyntax, 0) -> do+ exts <- getExts+ if xtest UnicodeSyntaxBit exts+ then return $ L span keyword+ else L span <$!> con span exts fs+ Just (keyword, UnicodeSyntax, i) -> do+ exts <- getExts+ if exts .&. i /= 0 && xtest UnicodeSyntaxBit exts+ then return $ L span keyword+ else L span <$!> con span exts fs+ Nothing -> do+ exts <- getExts+ L span <$!> con span exts fs+ where+ !fs = lexemeToFastString buf len++-- Variations on the integral numeric literal.+tok_integral :: (SourceText -> Integer -> Token)+ -> (Integer -> Integer)+ -> Int -> Int+ -> (Integer, (Char -> Int))+ -> Action+tok_integral itint transint transbuf translen (radix,char_to_int) span buf len = do+ numericUnderscores <- getBit NumericUnderscoresBit -- #14473+ let src = lexemeToString buf len+ when ((not numericUnderscores) && ('_' `elem` src)) $ do+ pState <- getPState+ addError $ PsError (PsErrNumUnderscores NumUnderscore_Integral) [] (mkSrcSpanPs (last_loc pState))+ return $ L span $ itint (SourceText src)+ $! transint $ parseUnsignedInteger+ (offsetBytes transbuf buf) (subtract translen len) radix char_to_int++tok_num :: (Integer -> Integer)+ -> Int -> Int+ -> (Integer, (Char->Int)) -> Action+tok_num = tok_integral $ \case+ st@(SourceText ('-':_)) -> itint st (const True)+ st@(SourceText _) -> itint st (const False)+ st@NoSourceText -> itint st (< 0)+ where+ itint :: SourceText -> (Integer -> Bool) -> Integer -> Token+ itint !st is_negative !val = ITinteger ((IL st $! is_negative val) val)++tok_primint :: (Integer -> Integer)+ -> Int -> Int+ -> (Integer, (Char->Int)) -> Action+tok_primint = tok_integral ITprimint+++tok_primword :: Int -> Int+ -> (Integer, (Char->Int)) -> Action+tok_primword = tok_integral ITprimword positive+positive, negative :: (Integer -> Integer)+positive = id+negative = negate+decimal, octal, hexadecimal :: (Integer, Char -> Int)+decimal = (10,octDecDigit)+binary = (2,octDecDigit)+octal = (8,octDecDigit)+hexadecimal = (16,hexDigit)++-- readSignificandExponentPair can understand negative rationals, exponents, everything.+tok_frac :: Int -> (String -> Token) -> Action+tok_frac drop f span buf len = do+ numericUnderscores <- getBit NumericUnderscoresBit -- #14473+ let src = lexemeToString buf (len-drop)+ when ((not numericUnderscores) && ('_' `elem` src)) $ do+ pState <- getPState+ addError $ PsError (PsErrNumUnderscores NumUnderscore_Float) [] (mkSrcSpanPs (last_loc pState))+ return (L span $! (f $! src))++tok_float, tok_primfloat, tok_primdouble :: String -> Token+tok_float str = ITrational $! readFractionalLit str+tok_hex_float str = ITrational $! readHexFractionalLit str+tok_primfloat str = ITprimfloat $! readFractionalLit str+tok_primdouble str = ITprimdouble $! readFractionalLit str++readFractionalLit, readHexFractionalLit :: String -> FractionalLit+readHexFractionalLit = readFractionalLitX readHexSignificandExponentPair Base2+readFractionalLit = readFractionalLitX readSignificandExponentPair Base10++readFractionalLitX :: (String -> (Integer, Integer))+ -> FractionalExponentBase+ -> String -> FractionalLit+readFractionalLitX readStr b str =+ mkSourceFractionalLit str is_neg i e b+ where+ is_neg = case str of+ '-' : _ -> True+ _ -> False+ (i, e) = readStr str++-- -----------------------------------------------------------------------------+-- Layout processing++-- we're at the first token on a line, insert layout tokens if necessary+do_bol :: Action+do_bol span _str _len = do+ -- See Note [Nested comment line pragmas]+ b <- getBit InNestedCommentBit+ if b then return (L span ITcomment_line_prag) else do+ (pos, gen_semic) <- getOffside+ case pos of+ LT -> do+ --trace "layout: inserting '}'" $ do+ popContext+ -- do NOT pop the lex state, we might have a ';' to insert+ return (L span ITvccurly)+ EQ | gen_semic -> do+ --trace "layout: inserting ';'" $ do+ _ <- popLexState+ return (L span ITsemi)+ _ -> do+ _ <- popLexState+ lexToken++-- certain keywords put us in the "layout" state, where we might+-- add an opening curly brace.+maybe_layout :: Token -> P ()+maybe_layout t = do -- If the alternative layout rule is enabled then+ -- we never create an implicit layout context here.+ -- Layout is handled XXX instead.+ -- The code for closing implicit contexts, or+ -- inserting implicit semi-colons, is therefore+ -- irrelevant as it only applies in an implicit+ -- context.+ alr <- getBit AlternativeLayoutRuleBit+ unless alr $ f t+ where f (ITdo _) = pushLexState layout_do+ f (ITmdo _) = pushLexState layout_do+ f ITof = pushLexState layout+ f ITlcase = pushLexState layout+ f ITlet = pushLexState layout+ f ITwhere = pushLexState layout+ f ITrec = pushLexState layout+ f ITif = pushLexState layout_if+ f _ = return ()++-- Pushing a new implicit layout context. If the indentation of the+-- next token is not greater than the previous layout context, then+-- Haskell 98 says that the new layout context should be empty; that is+-- the lexer must generate {}.+--+-- We are slightly more lenient than this: when the new context is started+-- by a 'do', then we allow the new context to be at the same indentation as+-- the previous context. This is what the 'strict' argument is for.+new_layout_context :: Bool -> Bool -> Token -> Action+new_layout_context strict gen_semic tok span _buf len = do+ _ <- popLexState+ (AI l _) <- getInput+ let offset = srcLocCol (psRealLoc l) - len+ ctx <- getContext+ nondecreasing <- getBit NondecreasingIndentationBit+ let strict' = strict || not nondecreasing+ case ctx of+ Layout prev_off _ : _ |+ (strict' && prev_off >= offset ||+ not strict' && prev_off > offset) -> do+ -- token is indented to the left of the previous context.+ -- we must generate a {} sequence now.+ pushLexState layout_left+ return (L span tok)+ _ -> do setContext (Layout offset gen_semic : ctx)+ return (L span tok)++do_layout_left :: Action+do_layout_left span _buf _len = do+ _ <- popLexState+ pushLexState bol -- we must be at the start of a line+ return (L span ITvccurly)++-- -----------------------------------------------------------------------------+-- LINE pragmas++setLineAndFile :: Int -> Action+setLineAndFile code (PsSpan span _) buf len = do+ let src = lexemeToString buf (len - 1) -- drop trailing quotation mark+ linenumLen = length $ head $ words src+ linenum = parseUnsignedInteger buf linenumLen 10 octDecDigit+ file = mkFastString $ go $ drop 1 $ dropWhile (/= '"') src+ -- skip everything through first quotation mark to get to the filename+ where go ('\\':c:cs) = c : go cs+ go (c:cs) = c : go cs+ go [] = []+ -- decode escapes in the filename. e.g. on Windows+ -- when our filenames have backslashes in, gcc seems to+ -- escape the backslashes. One symptom of not doing this+ -- is that filenames in error messages look a bit strange:+ -- C:\\foo\bar.hs+ -- only the first backslash is doubled, because we apply+ -- System.FilePath.normalise before printing out+ -- filenames and it does not remove duplicate+ -- backslashes after the drive letter (should it?).+ resetAlrLastLoc file+ setSrcLoc (mkRealSrcLoc file (fromIntegral linenum - 1) (srcSpanEndCol span))+ -- subtract one: the line number refers to the *following* line+ addSrcFile file+ _ <- popLexState+ pushLexState code+ lexToken++setColumn :: Action+setColumn (PsSpan span _) buf len = do+ let column =+ case reads (lexemeToString buf len) of+ [(column, _)] -> column+ _ -> error "setColumn: expected integer" -- shouldn't happen+ setSrcLoc (mkRealSrcLoc (srcSpanFile span) (srcSpanEndLine span)+ (fromIntegral (column :: Integer)))+ _ <- popLexState+ lexToken++alrInitialLoc :: FastString -> RealSrcSpan+alrInitialLoc file = mkRealSrcSpan loc loc+ where -- This is a hack to ensure that the first line in a file+ -- looks like it is after the initial location:+ loc = mkRealSrcLoc file (-1) (-1)++-- -----------------------------------------------------------------------------+-- Options, includes and language pragmas.+++lex_string_prag :: (String -> Token) -> Action+lex_string_prag mkTok = lex_string_prag_comment mkTok'+ where+ mkTok' s _ = mkTok s++lex_string_prag_comment :: (String -> PsSpan -> Token) -> Action+lex_string_prag_comment mkTok span _buf _len+ = do input <- getInput+ start <- getParsedLoc+ l <- getLastLocComment+ tok <- go l [] input+ end <- getParsedLoc+ return (L (mkPsSpan start end) tok)+ where go l acc input+ = if isString input "#-}"+ then do setInput input+ return (mkTok (reverse acc) l)+ else case alexGetChar input of+ Just (c,i) -> go l (c:acc) i+ Nothing -> err input+ isString _ [] = True+ isString i (x:xs)+ = case alexGetChar i of+ Just (c,i') | c == x -> isString i' xs+ _other -> False+ err (AI end _) = failLocMsgP (realSrcSpanStart (psRealSpan span)) (psRealLoc end) (PsError (PsErrLexer LexUnterminatedOptions LexErrKind_EOF) [])++-- -----------------------------------------------------------------------------+-- Strings & Chars++-- This stuff is horrible. I hates it.++lex_string_tok :: Action+lex_string_tok span buf _len = do+ tok <- lex_string ""+ (AI end bufEnd) <- getInput+ let+ tok' = case tok of+ ITprimstring _ bs -> ITprimstring (SourceText src) bs+ ITstring _ s -> ITstring (SourceText src) s+ _ -> panic "lex_string_tok"+ src = lexemeToString buf (cur bufEnd - cur buf)+ return (L (mkPsSpan (psSpanStart span) end) tok')++lex_string :: String -> P Token+lex_string s = do+ i <- getInput+ case alexGetChar' i of+ Nothing -> lit_error i++ Just ('"',i) -> do+ setInput i+ let s' = reverse s+ magicHash <- getBit MagicHashBit+ if magicHash+ then do+ i <- getInput+ case alexGetChar' i of+ Just ('#',i) -> do+ setInput i+ when (any (> '\xFF') s') $ do+ pState <- getPState+ let err = PsError PsErrPrimStringInvalidChar [] (mkSrcSpanPs (last_loc pState))+ addError err+ return (ITprimstring (SourceText s') (unsafeMkByteString s'))+ _other ->+ return (ITstring (SourceText s') (mkFastString s'))+ else+ return (ITstring (SourceText s') (mkFastString s'))++ Just ('\\',i)+ | Just ('&',i) <- next -> do+ setInput i; lex_string s+ | Just (c,i) <- next, c <= '\x7f' && is_space c -> do+ -- is_space only works for <= '\x7f' (#3751, #5425)+ setInput i; lex_stringgap s+ where next = alexGetChar' i++ Just (c, i1) -> do+ case c of+ '\\' -> do setInput i1; c' <- lex_escape; lex_string (c':s)+ c | isAny c -> do setInput i1; lex_string (c:s)+ _other -> lit_error i++lex_stringgap :: String -> P Token+lex_stringgap s = do+ i <- getInput+ c <- getCharOrFail i+ case c of+ '\\' -> lex_string s+ c | c <= '\x7f' && is_space c -> lex_stringgap s+ -- is_space only works for <= '\x7f' (#3751, #5425)+ _other -> lit_error i+++lex_char_tok :: Action+-- Here we are basically parsing character literals, such as 'x' or '\n'+-- but we additionally spot 'x and ''T, returning ITsimpleQuote and+-- ITtyQuote respectively, but WITHOUT CONSUMING the x or T part+-- (the parser does that).+-- So we have to do two characters of lookahead: when we see 'x we need to+-- see if there's a trailing quote+lex_char_tok span buf _len = do -- We've seen '+ i1 <- getInput -- Look ahead to first character+ let loc = psSpanStart span+ case alexGetChar' i1 of+ Nothing -> lit_error i1++ Just ('\'', i2@(AI end2 _)) -> do -- We've seen ''+ setInput i2+ return (L (mkPsSpan loc end2) ITtyQuote)++ Just ('\\', i2@(AI _end2 _)) -> do -- We've seen 'backslash+ setInput i2+ lit_ch <- lex_escape+ i3 <- getInput+ mc <- getCharOrFail i3 -- Trailing quote+ if mc == '\'' then finish_char_tok buf loc lit_ch+ else lit_error i3++ Just (c, i2@(AI _end2 _))+ | not (isAny c) -> lit_error i1+ | otherwise ->++ -- We've seen 'x, where x is a valid character+ -- (i.e. not newline etc) but not a quote or backslash+ case alexGetChar' i2 of -- Look ahead one more character+ Just ('\'', i3) -> do -- We've seen 'x'+ setInput i3+ finish_char_tok buf loc c+ _other -> do -- We've seen 'x not followed by quote+ -- (including the possibility of EOF)+ -- Just parse the quote only+ let (AI end _) = i1+ return (L (mkPsSpan loc end) ITsimpleQuote)++finish_char_tok :: StringBuffer -> PsLoc -> Char -> P (PsLocated Token)+finish_char_tok buf loc ch -- We've already seen the closing quote+ -- Just need to check for trailing #+ = do magicHash <- getBit MagicHashBit+ i@(AI end bufEnd) <- getInput+ let src = lexemeToString buf (cur bufEnd - cur buf)+ if magicHash then do+ case alexGetChar' i of+ Just ('#',i@(AI end _)) -> do+ setInput i+ return (L (mkPsSpan loc end)+ (ITprimchar (SourceText src) ch))+ _other ->+ return (L (mkPsSpan loc end)+ (ITchar (SourceText src) ch))+ else do+ return (L (mkPsSpan loc end) (ITchar (SourceText src) ch))++isAny :: Char -> Bool+isAny c | c > '\x7f' = isPrint c+ | otherwise = is_any c++lex_escape :: P Char+lex_escape = do+ i0 <- getInput+ c <- getCharOrFail i0+ case c of+ 'a' -> return '\a'+ 'b' -> return '\b'+ 'f' -> return '\f'+ 'n' -> return '\n'+ 'r' -> return '\r'+ 't' -> return '\t'+ 'v' -> return '\v'+ '\\' -> return '\\'+ '"' -> return '\"'+ '\'' -> return '\''+ '^' -> do i1 <- getInput+ c <- getCharOrFail i1+ if c >= '@' && c <= '_'+ then return (chr (ord c - ord '@'))+ else lit_error i1++ 'x' -> readNum is_hexdigit 16 hexDigit+ 'o' -> readNum is_octdigit 8 octDecDigit+ x | is_decdigit x -> readNum2 is_decdigit 10 octDecDigit (octDecDigit x)++ c1 -> do+ i <- getInput+ case alexGetChar' i of+ Nothing -> lit_error i0+ Just (c2,i2) ->+ case alexGetChar' i2 of+ Nothing -> do lit_error i0+ Just (c3,i3) ->+ let str = [c1,c2,c3] in+ case [ (c,rest) | (p,c) <- silly_escape_chars,+ Just rest <- [stripPrefix p str] ] of+ (escape_char,[]):_ -> do+ setInput i3+ return escape_char+ (escape_char,_:_):_ -> do+ setInput i2+ return escape_char+ [] -> lit_error i0++readNum :: (Char -> Bool) -> Int -> (Char -> Int) -> P Char+readNum is_digit base conv = do+ i <- getInput+ c <- getCharOrFail i+ if is_digit c+ then readNum2 is_digit base conv (conv c)+ else lit_error i++readNum2 :: (Char -> Bool) -> Int -> (Char -> Int) -> Int -> P Char+readNum2 is_digit base conv i = do+ input <- getInput+ read i input+ where read i input = do+ case alexGetChar' input of+ Just (c,input') | is_digit c -> do+ let i' = i*base + conv c+ if i' > 0x10ffff+ then setInput input >> lexError LexNumEscapeRange+ else read i' input'+ _other -> do+ setInput input; return (chr i)+++silly_escape_chars :: [(String, Char)]+silly_escape_chars = [+ ("NUL", '\NUL'),+ ("SOH", '\SOH'),+ ("STX", '\STX'),+ ("ETX", '\ETX'),+ ("EOT", '\EOT'),+ ("ENQ", '\ENQ'),+ ("ACK", '\ACK'),+ ("BEL", '\BEL'),+ ("BS", '\BS'),+ ("HT", '\HT'),+ ("LF", '\LF'),+ ("VT", '\VT'),+ ("FF", '\FF'),+ ("CR", '\CR'),+ ("SO", '\SO'),+ ("SI", '\SI'),+ ("DLE", '\DLE'),+ ("DC1", '\DC1'),+ ("DC2", '\DC2'),+ ("DC3", '\DC3'),+ ("DC4", '\DC4'),+ ("NAK", '\NAK'),+ ("SYN", '\SYN'),+ ("ETB", '\ETB'),+ ("CAN", '\CAN'),+ ("EM", '\EM'),+ ("SUB", '\SUB'),+ ("ESC", '\ESC'),+ ("FS", '\FS'),+ ("GS", '\GS'),+ ("RS", '\RS'),+ ("US", '\US'),+ ("SP", '\SP'),+ ("DEL", '\DEL')+ ]++-- before calling lit_error, ensure that the current input is pointing to+-- the position of the error in the buffer. This is so that we can report+-- a correct location to the user, but also so we can detect UTF-8 decoding+-- errors if they occur.+lit_error :: AlexInput -> P a+lit_error i = do setInput i; lexError LexStringCharLit++getCharOrFail :: AlexInput -> P Char+getCharOrFail i = do+ case alexGetChar' i of+ Nothing -> lexError LexStringCharLitEOF+ Just (c,i) -> do setInput i; return c++-- -----------------------------------------------------------------------------+-- QuasiQuote++lex_qquasiquote_tok :: Action+lex_qquasiquote_tok span buf len = do+ let (qual, quoter) = splitQualName (stepOn buf) (len - 2) False+ quoteStart <- getParsedLoc+ quote <- lex_quasiquote (psRealLoc quoteStart) ""+ end <- getParsedLoc+ return (L (mkPsSpan (psSpanStart span) end)+ (ITqQuasiQuote (qual,+ quoter,+ mkFastString (reverse quote),+ mkPsSpan quoteStart end)))++lex_quasiquote_tok :: Action+lex_quasiquote_tok span buf len = do+ let quoter = tail (lexemeToString buf (len - 1))+ -- 'tail' drops the initial '[',+ -- while the -1 drops the trailing '|'+ quoteStart <- getParsedLoc+ quote <- lex_quasiquote (psRealLoc quoteStart) ""+ end <- getParsedLoc+ return (L (mkPsSpan (psSpanStart span) end)+ (ITquasiQuote (mkFastString quoter,+ mkFastString (reverse quote),+ mkPsSpan quoteStart end)))++lex_quasiquote :: RealSrcLoc -> String -> P String+lex_quasiquote start s = do+ i <- getInput+ case alexGetChar' i of+ Nothing -> quasiquote_error start++ -- NB: The string "|]" terminates the quasiquote,+ -- with absolutely no escaping. See the extensive+ -- discussion on #5348 for why there is no+ -- escape handling.+ Just ('|',i)+ | Just (']',i) <- alexGetChar' i+ -> do { setInput i; return s }++ Just (c, i) -> do+ setInput i; lex_quasiquote start (c : s)++quasiquote_error :: RealSrcLoc -> P a+quasiquote_error start = do+ (AI end buf) <- getInput+ reportLexError start (psRealLoc end) buf+ (\k -> PsError (PsErrLexer LexUnterminatedQQ k) [])++-- -----------------------------------------------------------------------------+-- Warnings++warnTab :: Action+warnTab srcspan _buf _len = do+ addTabWarning (psRealSpan srcspan)+ lexToken++warnThen :: WarningFlag -> (SrcSpan -> PsWarning) -> Action -> Action+warnThen flag warning action srcspan buf len = do+ addWarning flag (warning (RealSrcSpan (psRealSpan srcspan) Nothing))+ action srcspan buf len++-- -----------------------------------------------------------------------------+-- The Parse Monad++-- | Do we want to generate ';' layout tokens? In some cases we just want to+-- generate '}', e.g. in MultiWayIf we don't need ';'s because '|' separates+-- alternatives (unlike a `case` expression where we need ';' to as a separator+-- between alternatives).+type GenSemic = Bool++generateSemic, dontGenerateSemic :: GenSemic+generateSemic = True+dontGenerateSemic = False++data LayoutContext+ = NoLayout+ | Layout !Int !GenSemic+ deriving Show++-- | The result of running a parser.+data ParseResult a+ = POk -- ^ The parser has consumed a (possibly empty) prefix+ -- of the input and produced a result. Use 'getMessages'+ -- to check for accumulated warnings and non-fatal errors.+ PState -- ^ The resulting parsing state. Can be used to resume parsing.+ a -- ^ The resulting value.+ | PFailed -- ^ The parser has consumed a (possibly empty) prefix+ -- of the input and failed.+ PState -- ^ The parsing state right before failure, including the fatal+ -- parse error. 'getMessages' and 'getErrorMessages' must return+ -- a non-empty bag of errors.++-- | Test whether a 'WarningFlag' is set+warnopt :: WarningFlag -> ParserOpts -> Bool+warnopt f options = f `EnumSet.member` pWarningFlags options++-- | Parser options.+--+-- See 'mkParserOpts' to construct this.+data ParserOpts = ParserOpts+ { pWarningFlags :: EnumSet WarningFlag -- ^ enabled warning flags+ , pExtsBitmap :: !ExtsBitmap -- ^ bitmap of permitted extensions+ }++-- | Haddock comment as produced by the lexer. These are accumulated in+-- 'PState' and then processed in "GHC.Parser.PostProcess.Haddock".+data HdkComment+ = HdkCommentNext HsDocString+ | HdkCommentPrev HsDocString+ | HdkCommentNamed String HsDocString+ | HdkCommentSection Int HsDocString+ deriving Show++data PState = PState {+ buffer :: StringBuffer,+ options :: ParserOpts,+ warnings :: Bag PsWarning,+ errors :: Bag PsError,+ tab_first :: Maybe RealSrcSpan, -- pos of first tab warning in the file+ tab_count :: !Word, -- number of tab warnings in the file+ last_tk :: Maybe (PsLocated Token), -- last non-comment token+ prev_loc :: PsSpan, -- pos of previous token, including comments,+ prev_loc2 :: PsSpan, -- pos of two back token, including comments,+ -- see Note [PsSpan in Comments]+ last_loc :: PsSpan, -- pos of current token+ last_len :: !Int, -- len of current token+ loc :: PsLoc, -- current loc (end of prev token + 1)+ context :: [LayoutContext],+ lex_state :: [Int],+ srcfiles :: [FastString],+ -- Used in the alternative layout rule:+ -- These tokens are the next ones to be sent out. They are+ -- just blindly emitted, without the rule looking at them again:+ alr_pending_implicit_tokens :: [PsLocated Token],+ -- This is the next token to be considered or, if it is Nothing,+ -- we need to get the next token from the input stream:+ alr_next_token :: Maybe (PsLocated Token),+ -- This is what we consider to be the location of the last token+ -- emitted:+ alr_last_loc :: PsSpan,+ -- The stack of layout contexts:+ alr_context :: [ALRContext],+ -- Are we expecting a '{'? If it's Just, then the ALRLayout tells+ -- us what sort of layout the '{' will open:+ alr_expecting_ocurly :: Maybe ALRLayout,+ -- Have we just had the '}' for a let block? If so, than an 'in'+ -- token doesn't need to close anything:+ alr_justClosedExplicitLetBlock :: Bool,++ -- The next three are used to implement Annotations giving the+ -- locations of 'noise' tokens in the source, so that users of+ -- the GHC API can do source to source conversions.+ -- See note [exact print annotations] in GHC.Parser.Annotation+ eof_pos :: Maybe (RealSrcSpan, RealSrcSpan), -- pos, gap to prior token+ header_comments :: Maybe [LEpaComment],+ comment_q :: [LEpaComment],++ -- Haddock comments accumulated in ascending order of their location+ -- (BufPos). We use OrdList to get O(1) snoc.+ --+ -- See Note [Adding Haddock comments to the syntax tree] in GHC.Parser.PostProcess.Haddock+ hdk_comments :: OrdList (PsLocated HdkComment)+ }+ -- last_loc and last_len are used when generating error messages,+ -- and in pushCurrentContext only. Sigh, if only Happy passed the+ -- current token to happyError, we could at least get rid of last_len.+ -- Getting rid of last_loc would require finding another way to+ -- implement pushCurrentContext (which is only called from one place).++ -- AZ question: setLastToken which sets last_loc and last_len+ -- is called whan processing AlexToken, immediately prior to+ -- calling the action in the token. So from the perspective+ -- of the action, it is the *current* token. Do I understand+ -- correctly?++data ALRContext = ALRNoLayout Bool{- does it contain commas? -}+ Bool{- is it a 'let' block? -}+ | ALRLayout ALRLayout Int+data ALRLayout = ALRLayoutLet+ | ALRLayoutWhere+ | ALRLayoutOf+ | ALRLayoutDo++-- | The parsing monad, isomorphic to @StateT PState Maybe@.+newtype P a = P { unP :: PState -> ParseResult a }++instance Functor P where+ fmap = liftM++instance Applicative P where+ pure = returnP+ (<*>) = ap++instance Monad P where+ (>>=) = thenP++returnP :: a -> P a+returnP a = a `seq` (P $ \s -> POk s a)++thenP :: P a -> (a -> P b) -> P b+(P m) `thenP` k = P $ \ s ->+ case m s of+ POk s1 a -> (unP (k a)) s1+ PFailed s1 -> PFailed s1++failMsgP :: (SrcSpan -> PsError) -> P a+failMsgP f = do+ pState <- getPState+ addFatalError (f (mkSrcSpanPs (last_loc pState)))++failLocMsgP :: RealSrcLoc -> RealSrcLoc -> (SrcSpan -> PsError) -> P a+failLocMsgP loc1 loc2 f =+ addFatalError (f (RealSrcSpan (mkRealSrcSpan loc1 loc2) Nothing))++getPState :: P PState+getPState = P $ \s -> POk s s++getExts :: P ExtsBitmap+getExts = P $ \s -> POk s (pExtsBitmap . options $ s)++setExts :: (ExtsBitmap -> ExtsBitmap) -> P ()+setExts f = P $ \s -> POk s {+ options =+ let p = options s+ in p { pExtsBitmap = f (pExtsBitmap p) }+ } ()++setSrcLoc :: RealSrcLoc -> P ()+setSrcLoc new_loc =+ P $ \s@(PState{ loc = PsLoc _ buf_loc }) ->+ POk s{ loc = PsLoc new_loc buf_loc } ()++getRealSrcLoc :: P RealSrcLoc+getRealSrcLoc = P $ \s@(PState{ loc=loc }) -> POk s (psRealLoc loc)++getParsedLoc :: P PsLoc+getParsedLoc = P $ \s@(PState{ loc=loc }) -> POk s loc++addSrcFile :: FastString -> P ()+addSrcFile f = P $ \s -> POk s{ srcfiles = f : srcfiles s } ()++setEofPos :: RealSrcSpan -> RealSrcSpan -> P ()+setEofPos span gap = P $ \s -> POk s{ eof_pos = Just (span, gap) } ()++setLastToken :: PsSpan -> Int -> P ()+setLastToken loc len = P $ \s -> POk s {+ last_loc=loc,+ last_len=len+ } ()++setLastTk :: PsLocated Token -> P ()+setLastTk tk@(L l _) = P $ \s -> POk s { last_tk = Just tk+ , prev_loc = l+ , prev_loc2 = prev_loc s} ()++setLastComment :: PsLocated Token -> P ()+setLastComment (L l _) = P $ \s -> POk s { prev_loc = l+ , prev_loc2 = prev_loc s} ()++getLastTk :: P (Maybe (PsLocated Token))+getLastTk = P $ \s@(PState { last_tk = last_tk }) -> POk s last_tk++-- see Note [PsSpan in Comments]+getLastLocComment :: P PsSpan+getLastLocComment = P $ \s@(PState { prev_loc = prev_loc }) -> POk s prev_loc++-- see Note [PsSpan in Comments]+getLastLocEof :: P PsSpan+getLastLocEof = P $ \s@(PState { prev_loc2 = prev_loc2 }) -> POk s prev_loc2++getLastLoc :: P PsSpan+getLastLoc = P $ \s@(PState { last_loc = last_loc }) -> POk s last_loc++data AlexInput = AI !PsLoc !StringBuffer++{-+Note [Unicode in Alex]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+Although newer versions of Alex support unicode, this grammar is processed with+the old style '--latin1' behaviour. This means that when implementing the+functions++ alexGetByte :: AlexInput -> Maybe (Word8,AlexInput)+ alexInputPrevChar :: AlexInput -> Char++which Alex uses to take apart our 'AlexInput', we must++ * return a latin1 character in the 'Word8' that 'alexGetByte' expects+ * return a latin1 character in 'alexInputPrevChar'.++We handle this in 'adjustChar' by squishing entire classes of unicode+characters into single bytes.+-}++{-# INLINE adjustChar #-}+adjustChar :: Char -> Word8+adjustChar c = fromIntegral $ ord adj_c+ where non_graphic = '\x00'+ upper = '\x01'+ lower = '\x02'+ digit = '\x03'+ symbol = '\x04'+ space = '\x05'+ other_graphic = '\x06'+ uniidchar = '\x07'++ adj_c+ | c <= '\x07' = non_graphic+ | c <= '\x7f' = c+ -- Alex doesn't handle Unicode, so when Unicode+ -- character is encountered we output these values+ -- with the actual character value hidden in the state.+ | otherwise =+ -- NB: The logic behind these definitions is also reflected+ -- in "GHC.Utils.Lexeme"+ -- Any changes here should likely be reflected there.++ case generalCategory c of+ UppercaseLetter -> upper+ LowercaseLetter -> lower+ TitlecaseLetter -> upper+ ModifierLetter -> uniidchar -- see #10196+ OtherLetter -> lower -- see #1103+ NonSpacingMark -> uniidchar -- see #7650+ SpacingCombiningMark -> other_graphic+ EnclosingMark -> other_graphic+ DecimalNumber -> digit+ LetterNumber -> other_graphic+ OtherNumber -> digit -- see #4373+ ConnectorPunctuation -> symbol+ DashPunctuation -> symbol+ OpenPunctuation -> other_graphic+ ClosePunctuation -> other_graphic+ InitialQuote -> other_graphic+ FinalQuote -> other_graphic+ OtherPunctuation -> symbol+ MathSymbol -> symbol+ CurrencySymbol -> symbol+ ModifierSymbol -> symbol+ OtherSymbol -> symbol+ Space -> space+ _other -> non_graphic++-- Getting the previous 'Char' isn't enough here - we need to convert it into+-- the same format that 'alexGetByte' would have produced.+--+-- See Note [Unicode in Alex] and #13986.+alexInputPrevChar :: AlexInput -> Char+alexInputPrevChar (AI _ buf) = chr (fromIntegral (adjustChar pc))+ where pc = prevChar buf '\n'++-- backwards compatibility for Alex 2.x+alexGetChar :: AlexInput -> Maybe (Char,AlexInput)+alexGetChar inp = case alexGetByte inp of+ Nothing -> Nothing+ Just (b,i) -> c `seq` Just (c,i)+ where c = chr $ fromIntegral b++-- See Note [Unicode in Alex]+alexGetByte :: AlexInput -> Maybe (Word8,AlexInput)+alexGetByte (AI loc s)+ | atEnd s = Nothing+ | otherwise = byte `seq` loc' `seq` s' `seq`+ --trace (show (ord c)) $+ Just (byte, (AI loc' s'))+ where (c,s') = nextChar s+ loc' = advancePsLoc loc c+ byte = adjustChar c++-- This version does not squash unicode characters, it is used when+-- lexing strings.+alexGetChar' :: AlexInput -> Maybe (Char,AlexInput)+alexGetChar' (AI loc s)+ | atEnd s = Nothing+ | otherwise = c `seq` loc' `seq` s' `seq`+ --trace (show (ord c)) $+ Just (c, (AI loc' s'))+ where (c,s') = nextChar s+ loc' = advancePsLoc loc c++getInput :: P AlexInput+getInput = P $ \s@PState{ loc=l, buffer=b } -> POk s (AI l b)++setInput :: AlexInput -> P ()+setInput (AI l b) = P $ \s -> POk s{ loc=l, buffer=b } ()++nextIsEOF :: P Bool+nextIsEOF = do+ AI _ s <- getInput+ return $ atEnd s++pushLexState :: Int -> P ()+pushLexState ls = P $ \s@PState{ lex_state=l } -> POk s{lex_state=ls:l} ()++popLexState :: P Int+popLexState = P $ \s@PState{ lex_state=ls:l } -> POk s{ lex_state=l } ls++getLexState :: P Int+getLexState = P $ \s@PState{ lex_state=ls:_ } -> POk s ls++popNextToken :: P (Maybe (PsLocated Token))+popNextToken+ = P $ \s@PState{ alr_next_token = m } ->+ POk (s {alr_next_token = Nothing}) m++activeContext :: P Bool+activeContext = do+ ctxt <- getALRContext+ expc <- getAlrExpectingOCurly+ impt <- implicitTokenPending+ case (ctxt,expc) of+ ([],Nothing) -> return impt+ _other -> return True++resetAlrLastLoc :: FastString -> P ()+resetAlrLastLoc file =+ P $ \s@(PState {alr_last_loc = PsSpan _ buf_span}) ->+ POk s{ alr_last_loc = PsSpan (alrInitialLoc file) buf_span } ()++setAlrLastLoc :: PsSpan -> P ()+setAlrLastLoc l = P $ \s -> POk (s {alr_last_loc = l}) ()++getAlrLastLoc :: P PsSpan+getAlrLastLoc = P $ \s@(PState {alr_last_loc = l}) -> POk s l++getALRContext :: P [ALRContext]+getALRContext = P $ \s@(PState {alr_context = cs}) -> POk s cs++setALRContext :: [ALRContext] -> P ()+setALRContext cs = P $ \s -> POk (s {alr_context = cs}) ()++getJustClosedExplicitLetBlock :: P Bool+getJustClosedExplicitLetBlock+ = P $ \s@(PState {alr_justClosedExplicitLetBlock = b}) -> POk s b++setJustClosedExplicitLetBlock :: Bool -> P ()+setJustClosedExplicitLetBlock b+ = P $ \s -> POk (s {alr_justClosedExplicitLetBlock = b}) ()++setNextToken :: PsLocated Token -> P ()+setNextToken t = P $ \s -> POk (s {alr_next_token = Just t}) ()++implicitTokenPending :: P Bool+implicitTokenPending+ = P $ \s@PState{ alr_pending_implicit_tokens = ts } ->+ case ts of+ [] -> POk s False+ _ -> POk s True++popPendingImplicitToken :: P (Maybe (PsLocated Token))+popPendingImplicitToken+ = P $ \s@PState{ alr_pending_implicit_tokens = ts } ->+ case ts of+ [] -> POk s Nothing+ (t : ts') -> POk (s {alr_pending_implicit_tokens = ts'}) (Just t)++setPendingImplicitTokens :: [PsLocated Token] -> P ()+setPendingImplicitTokens ts = P $ \s -> POk (s {alr_pending_implicit_tokens = ts}) ()++getAlrExpectingOCurly :: P (Maybe ALRLayout)+getAlrExpectingOCurly = P $ \s@(PState {alr_expecting_ocurly = b}) -> POk s b++setAlrExpectingOCurly :: Maybe ALRLayout -> P ()+setAlrExpectingOCurly b = P $ \s -> POk (s {alr_expecting_ocurly = b}) ()++-- | For reasons of efficiency, boolean parsing flags (eg, language extensions+-- or whether we are currently in a @RULE@ pragma) are represented by a bitmap+-- stored in a @Word64@.+type ExtsBitmap = Word64++xbit :: ExtBits -> ExtsBitmap+xbit = bit . fromEnum++xtest :: ExtBits -> ExtsBitmap -> Bool+xtest ext xmap = testBit xmap (fromEnum ext)++xset :: ExtBits -> ExtsBitmap -> ExtsBitmap+xset ext xmap = setBit xmap (fromEnum ext)++xunset :: ExtBits -> ExtsBitmap -> ExtsBitmap+xunset ext xmap = clearBit xmap (fromEnum ext)++-- | Various boolean flags, mostly language extensions, that impact lexing and+-- parsing. Note that a handful of these can change during lexing/parsing.+data ExtBits+ -- Flags that are constant once parsing starts+ = FfiBit+ | InterruptibleFfiBit+ | CApiFfiBit+ | ArrowsBit+ | ThBit+ | ThQuotesBit+ | IpBit+ | OverloadedLabelsBit -- #x overloaded labels+ | ExplicitForallBit -- the 'forall' keyword+ | BangPatBit -- Tells the parser to understand bang-patterns+ -- (doesn't affect the lexer)+ | PatternSynonymsBit -- pattern synonyms+ | HaddockBit-- Lex and parse Haddock comments+ | MagicHashBit -- "#" in both functions and operators+ | RecursiveDoBit -- mdo+ | QualifiedDoBit -- .do and .mdo+ | UnicodeSyntaxBit -- the forall symbol, arrow symbols, etc+ | UnboxedTuplesBit -- (# and #)+ | UnboxedSumsBit -- (# and #)+ | DatatypeContextsBit+ | MonadComprehensionsBit+ | TransformComprehensionsBit+ | QqBit -- enable quasiquoting+ | RawTokenStreamBit -- producing a token stream with all comments included+ | AlternativeLayoutRuleBit+ | ALRTransitionalBit+ | RelaxedLayoutBit+ | NondecreasingIndentationBit+ | SafeHaskellBit+ | TraditionalRecordSyntaxBit+ | ExplicitNamespacesBit+ | LambdaCaseBit+ | BinaryLiteralsBit+ | NegativeLiteralsBit+ | HexFloatLiteralsBit+ | StaticPointersBit+ | NumericUnderscoresBit+ | StarIsTypeBit+ | BlockArgumentsBit+ | NPlusKPatternsBit+ | DoAndIfThenElseBit+ | MultiWayIfBit+ | GadtSyntaxBit+ | ImportQualifiedPostBit+ | LinearTypesBit+ | NoLexicalNegationBit -- See Note [Why not LexicalNegationBit]+ | OverloadedRecordDotBit+ | OverloadedRecordUpdateBit++ -- Flags that are updated once parsing starts+ | InRulePragBit+ | InNestedCommentBit -- See Note [Nested comment line pragmas]+ | UsePosPragsBit+ -- ^ If this is enabled, '{-# LINE ... -#}' and '{-# COLUMN ... #-}'+ -- update the internal position. Otherwise, those pragmas are lexed as+ -- tokens of their own.+ deriving Enum++{-# INLINE mkParserOpts #-}+mkParserOpts+ :: EnumSet WarningFlag -- ^ warnings flags enabled+ -> EnumSet LangExt.Extension -- ^ permitted language extensions enabled+ -> Bool -- ^ are safe imports on?+ -> Bool -- ^ keeping Haddock comment tokens+ -> Bool -- ^ keep regular comment tokens++ -> Bool+ -- ^ If this is enabled, '{-# LINE ... -#}' and '{-# COLUMN ... #-}' update+ -- the internal position kept by the parser. Otherwise, those pragmas are+ -- lexed as 'ITline_prag' and 'ITcolumn_prag' tokens.++ -> ParserOpts+-- ^ Given exactly the information needed, set up the 'ParserOpts'+mkParserOpts warningFlags extensionFlags+ safeImports isHaddock rawTokStream usePosPrags =+ ParserOpts {+ pWarningFlags = warningFlags+ , pExtsBitmap = safeHaskellBit .|. langExtBits .|. optBits+ }+ where+ safeHaskellBit = SafeHaskellBit `setBitIf` safeImports+ langExtBits =+ FfiBit `xoptBit` LangExt.ForeignFunctionInterface+ .|. InterruptibleFfiBit `xoptBit` LangExt.InterruptibleFFI+ .|. CApiFfiBit `xoptBit` LangExt.CApiFFI+ .|. ArrowsBit `xoptBit` LangExt.Arrows+ .|. ThBit `xoptBit` LangExt.TemplateHaskell+ .|. ThQuotesBit `xoptBit` LangExt.TemplateHaskellQuotes+ .|. QqBit `xoptBit` LangExt.QuasiQuotes+ .|. IpBit `xoptBit` LangExt.ImplicitParams+ .|. OverloadedLabelsBit `xoptBit` LangExt.OverloadedLabels+ .|. ExplicitForallBit `xoptBit` LangExt.ExplicitForAll+ .|. BangPatBit `xoptBit` LangExt.BangPatterns+ .|. MagicHashBit `xoptBit` LangExt.MagicHash+ .|. RecursiveDoBit `xoptBit` LangExt.RecursiveDo+ .|. QualifiedDoBit `xoptBit` LangExt.QualifiedDo+ .|. UnicodeSyntaxBit `xoptBit` LangExt.UnicodeSyntax+ .|. UnboxedTuplesBit `xoptBit` LangExt.UnboxedTuples+ .|. UnboxedSumsBit `xoptBit` LangExt.UnboxedSums+ .|. DatatypeContextsBit `xoptBit` LangExt.DatatypeContexts+ .|. TransformComprehensionsBit `xoptBit` LangExt.TransformListComp+ .|. MonadComprehensionsBit `xoptBit` LangExt.MonadComprehensions+ .|. AlternativeLayoutRuleBit `xoptBit` LangExt.AlternativeLayoutRule+ .|. ALRTransitionalBit `xoptBit` LangExt.AlternativeLayoutRuleTransitional+ .|. RelaxedLayoutBit `xoptBit` LangExt.RelaxedLayout+ .|. NondecreasingIndentationBit `xoptBit` LangExt.NondecreasingIndentation+ .|. TraditionalRecordSyntaxBit `xoptBit` LangExt.TraditionalRecordSyntax+ .|. ExplicitNamespacesBit `xoptBit` LangExt.ExplicitNamespaces+ .|. LambdaCaseBit `xoptBit` LangExt.LambdaCase+ .|. BinaryLiteralsBit `xoptBit` LangExt.BinaryLiterals+ .|. NegativeLiteralsBit `xoptBit` LangExt.NegativeLiterals+ .|. HexFloatLiteralsBit `xoptBit` LangExt.HexFloatLiterals+ .|. PatternSynonymsBit `xoptBit` LangExt.PatternSynonyms+ .|. StaticPointersBit `xoptBit` LangExt.StaticPointers+ .|. NumericUnderscoresBit `xoptBit` LangExt.NumericUnderscores+ .|. StarIsTypeBit `xoptBit` LangExt.StarIsType+ .|. BlockArgumentsBit `xoptBit` LangExt.BlockArguments+ .|. NPlusKPatternsBit `xoptBit` LangExt.NPlusKPatterns+ .|. DoAndIfThenElseBit `xoptBit` LangExt.DoAndIfThenElse+ .|. MultiWayIfBit `xoptBit` LangExt.MultiWayIf+ .|. GadtSyntaxBit `xoptBit` LangExt.GADTSyntax+ .|. ImportQualifiedPostBit `xoptBit` LangExt.ImportQualifiedPost+ .|. LinearTypesBit `xoptBit` LangExt.LinearTypes+ .|. NoLexicalNegationBit `xoptNotBit` LangExt.LexicalNegation -- See Note [Why not LexicalNegationBit]+ .|. OverloadedRecordDotBit `xoptBit` LangExt.OverloadedRecordDot+ .|. OverloadedRecordUpdateBit `xoptBit` LangExt.OverloadedRecordUpdate -- Enable testing via 'getBit OverloadedRecordUpdateBit' in the parser (RecordDotSyntax parsing uses that information).+ optBits =+ HaddockBit `setBitIf` isHaddock+ .|. RawTokenStreamBit `setBitIf` rawTokStream+ .|. UsePosPragsBit `setBitIf` usePosPrags++ xoptBit bit ext = bit `setBitIf` EnumSet.member ext extensionFlags+ xoptNotBit bit ext = bit `setBitIf` not (EnumSet.member ext extensionFlags)++ setBitIf :: ExtBits -> Bool -> ExtsBitmap+ b `setBitIf` cond | cond = xbit b+ | otherwise = 0++-- | Set parser options for parsing OPTIONS pragmas+initPragState :: ParserOpts -> StringBuffer -> RealSrcLoc -> PState+initPragState options buf loc = (initParserState options buf loc)+ { lex_state = [bol, option_prags, 0]+ }++-- | Creates a parse state from a 'ParserOpts' value+initParserState :: ParserOpts -> StringBuffer -> RealSrcLoc -> PState+initParserState options buf loc =+ PState {+ buffer = buf,+ options = options,+ errors = emptyBag,+ warnings = emptyBag,+ tab_first = Nothing,+ tab_count = 0,+ last_tk = Nothing,+ prev_loc = mkPsSpan init_loc init_loc,+ prev_loc2 = mkPsSpan init_loc init_loc,+ last_loc = mkPsSpan init_loc init_loc,+ last_len = 0,+ loc = init_loc,+ context = [],+ lex_state = [bol, 0],+ srcfiles = [],+ alr_pending_implicit_tokens = [],+ alr_next_token = Nothing,+ alr_last_loc = PsSpan (alrInitialLoc (fsLit "<no file>")) (BufSpan (BufPos 0) (BufPos 0)),+ alr_context = [],+ alr_expecting_ocurly = Nothing,+ alr_justClosedExplicitLetBlock = False,+ eof_pos = Nothing,+ header_comments = Nothing,+ comment_q = [],+ hdk_comments = nilOL+ }+ where init_loc = PsLoc loc (BufPos 0)++-- | An mtl-style class for monads that support parsing-related operations.+-- For example, sometimes we make a second pass over the parsing results to validate,+-- disambiguate, or rearrange them, and we do so in the PV monad which cannot consume+-- input but can report parsing errors, check for extension bits, and accumulate+-- parsing annotations. Both P and PV are instances of MonadP.+--+-- MonadP grants us convenient overloading. The other option is to have separate operations+-- for each monad: addErrorP vs addErrorPV, getBitP vs getBitPV, and so on.+--+class Monad m => MonadP m where+ -- | Add a non-fatal error. Use this when the parser can produce a result+ -- despite the error.+ --+ -- For example, when GHC encounters a @forall@ in a type,+ -- but @-XExplicitForAll@ is disabled, the parser constructs @ForAllTy@+ -- as if @-XExplicitForAll@ was enabled, adding a non-fatal error to+ -- the accumulator.+ --+ -- Control flow wise, non-fatal errors act like warnings: they are added+ -- to the accumulator and parsing continues. This allows GHC to report+ -- more than one parse error per file.+ --+ addError :: PsError -> m ()++ -- | Add a warning to the accumulator.+ -- Use 'getMessages' to get the accumulated warnings.+ addWarning :: WarningFlag -> PsWarning -> m ()++ -- | Add a fatal error. This will be the last error reported by the parser, and+ -- the parser will not produce any result, ending in a 'PFailed' state.+ addFatalError :: PsError -> m a++ -- | Check if a given flag is currently set in the bitmap.+ getBit :: ExtBits -> m Bool+ -- | Go through the @comment_q@ in @PState@ and remove all comments+ -- that belong within the given span+ allocateCommentsP :: RealSrcSpan -> m EpAnnComments+ -- | Go through the @comment_q@ in @PState@ and remove all comments+ -- that come before or within the given span+ allocatePriorCommentsP :: RealSrcSpan -> m EpAnnComments+ -- | Go through the @comment_q@ in @PState@ and remove all comments+ -- that come after the given span+ allocateFinalCommentsP :: RealSrcSpan -> m EpAnnComments++instance MonadP P where+ addError err+ = P $ \s -> POk s { errors = err `consBag` errors s} ()++ addWarning option w+ = P $ \s -> if warnopt option (options s)+ then POk (s { warnings = w `consBag` warnings s }) ()+ else POk s ()++ addFatalError err =+ addError err >> P PFailed++ getBit ext = P $ \s -> let b = ext `xtest` pExtsBitmap (options s)+ in b `seq` POk s b+ allocateCommentsP ss = P $ \s ->+ let (comment_q', newAnns) = allocateComments ss (comment_q s) in+ POk s {+ comment_q = comment_q'+ } (EpaComments newAnns)+ allocatePriorCommentsP ss = P $ \s ->+ let (header_comments', comment_q', newAnns)+ = allocatePriorComments ss (comment_q s) (header_comments s) in+ POk s {+ header_comments = header_comments',+ comment_q = comment_q'+ } (EpaComments newAnns)+ allocateFinalCommentsP ss = P $ \s ->+ let (header_comments', comment_q', newAnns)+ = allocateFinalComments ss (comment_q s) (header_comments s) in+ POk s {+ header_comments = header_comments',+ comment_q = comment_q'+ } (EpaCommentsBalanced (fromMaybe [] header_comments') (reverse newAnns))++getCommentsFor :: (MonadP m) => SrcSpan -> m EpAnnComments+getCommentsFor (RealSrcSpan l _) = allocateCommentsP l+getCommentsFor _ = return emptyComments++getPriorCommentsFor :: (MonadP m) => SrcSpan -> m EpAnnComments+getPriorCommentsFor (RealSrcSpan l _) = allocatePriorCommentsP l+getPriorCommentsFor _ = return emptyComments++getFinalCommentsFor :: (MonadP m) => SrcSpan -> m EpAnnComments+getFinalCommentsFor (RealSrcSpan l _) = allocateFinalCommentsP l+getFinalCommentsFor _ = return emptyComments++getEofPos :: P (Maybe (RealSrcSpan, RealSrcSpan))+getEofPos = P $ \s@(PState { eof_pos = pos }) -> POk s pos++addTabWarning :: RealSrcSpan -> P ()+addTabWarning srcspan+ = P $ \s@PState{tab_first=tf, tab_count=tc, options=o} ->+ let tf' = if isJust tf then tf else Just srcspan+ tc' = tc + 1+ s' = if warnopt Opt_WarnTabs o+ then s{tab_first = tf', tab_count = tc'}+ else s+ in POk s' ()++-- | Get a bag of the errors that have been accumulated so far.+-- Does not take -Werror into account.+getErrorMessages :: PState -> Bag PsError+getErrorMessages p = errors p++-- | Get the warnings and errors accumulated so far.+-- Does not take -Werror into account.+getMessages :: PState -> (Bag PsWarning, Bag PsError)+getMessages p =+ let ws = warnings p+ -- we add the tabulation warning on the fly because+ -- we count the number of occurrences of tab characters+ ws' = case tab_first p of+ Nothing -> ws+ Just tf -> PsWarnTab (RealSrcSpan tf Nothing) (tab_count p)+ `consBag` ws+ in (ws', errors p)++getContext :: P [LayoutContext]+getContext = P $ \s@PState{context=ctx} -> POk s ctx++setContext :: [LayoutContext] -> P ()+setContext ctx = P $ \s -> POk s{context=ctx} ()++popContext :: P ()+popContext = P $ \ s@(PState{ buffer = buf, options = o, context = ctx,+ last_len = len, last_loc = last_loc }) ->+ case ctx of+ (_:tl) ->+ POk s{ context = tl } ()+ [] ->+ unP (addFatalError $ srcParseErr o buf len (mkSrcSpanPs last_loc)) s++-- Push a new layout context at the indentation of the last token read.+pushCurrentContext :: GenSemic -> P ()+pushCurrentContext gen_semic = P $ \ s@PState{ last_loc=loc, context=ctx } ->+ POk s{context = Layout (srcSpanStartCol (psRealSpan loc)) gen_semic : ctx} ()++-- This is only used at the outer level of a module when the 'module' keyword is+-- missing.+pushModuleContext :: P ()+pushModuleContext = pushCurrentContext generateSemic++getOffside :: P (Ordering, Bool)+getOffside = P $ \s@PState{last_loc=loc, context=stk} ->+ let offs = srcSpanStartCol (psRealSpan loc) in+ let ord = case stk of+ Layout n gen_semic : _ ->+ --trace ("layout: " ++ show n ++ ", offs: " ++ show offs) $+ (compare offs n, gen_semic)+ _ ->+ (GT, dontGenerateSemic)+ in POk s ord++-- ---------------------------------------------------------------------------+-- Construct a parse error++srcParseErr+ :: ParserOpts+ -> StringBuffer -- current buffer (placed just after the last token)+ -> Int -- length of the previous token+ -> SrcSpan+ -> PsError+srcParseErr options buf len loc = PsError (PsErrParse token) suggests loc+ where+ token = lexemeToString (offsetBytes (-len) buf) len+ pattern = decodePrevNChars 8 buf+ last100 = decodePrevNChars 100 buf+ doInLast100 = "do" `isInfixOf` last100+ mdoInLast100 = "mdo" `isInfixOf` last100+ th_enabled = ThQuotesBit `xtest` pExtsBitmap options+ ps_enabled = PatternSynonymsBit `xtest` pExtsBitmap options++ sug c s = if c then Just s else Nothing+ sug_th = sug (not th_enabled && token == "$") SuggestTH -- #7396+ sug_rdo = sug (token == "<-" && mdoInLast100) SuggestRecursiveDo+ sug_do = sug (token == "<-" && not mdoInLast100) SuggestDo+ sug_let = sug (token == "=" && doInLast100) SuggestLetInDo -- #15849+ sug_pat = sug (not ps_enabled && pattern == "pattern ") SuggestPatternSynonyms -- #12429+ suggests+ | null token = []+ | otherwise = catMaybes [sug_th, sug_rdo, sug_do, sug_let, sug_pat]++-- Report a parse failure, giving the span of the previous token as+-- the location of the error. This is the entry point for errors+-- detected during parsing.+srcParseFail :: P a+srcParseFail = P $ \s@PState{ buffer = buf, options = o, last_len = len,+ last_loc = last_loc } ->+ unP (addFatalError $ srcParseErr o buf len (mkSrcSpanPs last_loc)) s++-- A lexical error is reported at a particular position in the source file,+-- not over a token range.+lexError :: LexErr -> P a+lexError e = do+ loc <- getRealSrcLoc+ (AI end buf) <- getInput+ reportLexError loc (psRealLoc end) buf+ (\k -> PsError (PsErrLexer e k) [])++-- -----------------------------------------------------------------------------+-- This is the top-level function: called from the parser each time a+-- new token is to be read from the input.++lexer, lexerDbg :: Bool -> (Located Token -> P a) -> P a++lexer queueComments cont = do+ alr <- getBit AlternativeLayoutRuleBit+ let lexTokenFun = if alr then lexTokenAlr else lexToken+ (L span tok) <- lexTokenFun+ --trace ("token: " ++ show tok) $ do++ if (queueComments && isComment tok)+ then queueComment (L (psRealSpan span) tok) >> lexer queueComments cont+ else cont (L (mkSrcSpanPs span) tok)++-- Use this instead of 'lexer' in GHC.Parser to dump the tokens for debugging.+lexerDbg queueComments cont = lexer queueComments contDbg+ where+ contDbg tok = trace ("token: " ++ show (unLoc tok)) (cont tok)++lexTokenAlr :: P (PsLocated Token)+lexTokenAlr = do mPending <- popPendingImplicitToken+ t <- case mPending of+ Nothing ->+ do mNext <- popNextToken+ t <- case mNext of+ Nothing -> lexToken+ Just next -> return next+ alternativeLayoutRuleToken t+ Just t ->+ return t+ setAlrLastLoc (getLoc t)+ case unLoc t of+ ITwhere -> setAlrExpectingOCurly (Just ALRLayoutWhere)+ ITlet -> setAlrExpectingOCurly (Just ALRLayoutLet)+ ITof -> setAlrExpectingOCurly (Just ALRLayoutOf)+ ITlcase -> setAlrExpectingOCurly (Just ALRLayoutOf)+ ITdo _ -> setAlrExpectingOCurly (Just ALRLayoutDo)+ ITmdo _ -> setAlrExpectingOCurly (Just ALRLayoutDo)+ ITrec -> setAlrExpectingOCurly (Just ALRLayoutDo)+ _ -> return ()+ return t++alternativeLayoutRuleToken :: PsLocated Token -> P (PsLocated Token)+alternativeLayoutRuleToken t+ = do context <- getALRContext+ lastLoc <- getAlrLastLoc+ mExpectingOCurly <- getAlrExpectingOCurly+ transitional <- getBit ALRTransitionalBit+ justClosedExplicitLetBlock <- getJustClosedExplicitLetBlock+ setJustClosedExplicitLetBlock False+ let thisLoc = getLoc t+ thisCol = srcSpanStartCol (psRealSpan thisLoc)+ newLine = srcSpanStartLine (psRealSpan thisLoc) > srcSpanEndLine (psRealSpan lastLoc)+ case (unLoc t, context, mExpectingOCurly) of+ -- This case handles a GHC extension to the original H98+ -- layout rule...+ (ITocurly, _, Just alrLayout) ->+ do setAlrExpectingOCurly Nothing+ let isLet = case alrLayout of+ ALRLayoutLet -> True+ _ -> False+ setALRContext (ALRNoLayout (containsCommas ITocurly) isLet : context)+ return t+ -- ...and makes this case unnecessary+ {-+ -- I think our implicit open-curly handling is slightly+ -- different to John's, in how it interacts with newlines+ -- and "in"+ (ITocurly, _, Just _) ->+ do setAlrExpectingOCurly Nothing+ setNextToken t+ lexTokenAlr+ -}+ (_, ALRLayout _ col : _ls, Just expectingOCurly)+ | (thisCol > col) ||+ (thisCol == col &&+ isNonDecreasingIndentation expectingOCurly) ->+ do setAlrExpectingOCurly Nothing+ setALRContext (ALRLayout expectingOCurly thisCol : context)+ setNextToken t+ return (L thisLoc ITvocurly)+ | otherwise ->+ do setAlrExpectingOCurly Nothing+ setPendingImplicitTokens [L lastLoc ITvccurly]+ setNextToken t+ return (L lastLoc ITvocurly)+ (_, _, Just expectingOCurly) ->+ do setAlrExpectingOCurly Nothing+ setALRContext (ALRLayout expectingOCurly thisCol : context)+ setNextToken t+ return (L thisLoc ITvocurly)+ -- We do the [] cases earlier than in the spec, as we+ -- have an actual EOF token+ (ITeof, ALRLayout _ _ : ls, _) ->+ do setALRContext ls+ setNextToken t+ return (L thisLoc ITvccurly)+ (ITeof, _, _) ->+ return t+ -- the other ITeof case omitted; general case below covers it+ (ITin, _, _)+ | justClosedExplicitLetBlock ->+ return t+ (ITin, ALRLayout ALRLayoutLet _ : ls, _)+ | newLine ->+ do setPendingImplicitTokens [t]+ setALRContext ls+ return (L thisLoc ITvccurly)+ -- This next case is to handle a transitional issue:+ (ITwhere, ALRLayout _ col : ls, _)+ | newLine && thisCol == col && transitional ->+ do addWarning Opt_WarnAlternativeLayoutRuleTransitional+ $ PsWarnTransitionalLayout (mkSrcSpanPs thisLoc) TransLayout_Where+ setALRContext ls+ setNextToken t+ -- Note that we use lastLoc, as we may need to close+ -- more layouts, or give a semicolon+ return (L lastLoc ITvccurly)+ -- This next case is to handle a transitional issue:+ (ITvbar, ALRLayout _ col : ls, _)+ | newLine && thisCol == col && transitional ->+ do addWarning Opt_WarnAlternativeLayoutRuleTransitional+ $ PsWarnTransitionalLayout (mkSrcSpanPs thisLoc) TransLayout_Pipe+ setALRContext ls+ setNextToken t+ -- Note that we use lastLoc, as we may need to close+ -- more layouts, or give a semicolon+ return (L lastLoc ITvccurly)+ (_, ALRLayout _ col : ls, _)+ | newLine && thisCol == col ->+ do setNextToken t+ let loc = psSpanStart thisLoc+ zeroWidthLoc = mkPsSpan loc loc+ return (L zeroWidthLoc ITsemi)+ | newLine && thisCol < col ->+ do setALRContext ls+ setNextToken t+ -- Note that we use lastLoc, as we may need to close+ -- more layouts, or give a semicolon+ return (L lastLoc ITvccurly)+ -- We need to handle close before open, as 'then' is both+ -- an open and a close+ (u, _, _)+ | isALRclose u ->+ case context of+ ALRLayout _ _ : ls ->+ do setALRContext ls+ setNextToken t+ return (L thisLoc ITvccurly)+ ALRNoLayout _ isLet : ls ->+ do let ls' = if isALRopen u+ then ALRNoLayout (containsCommas u) False : ls+ else ls+ setALRContext ls'+ when isLet $ setJustClosedExplicitLetBlock True+ return t+ [] ->+ do let ls = if isALRopen u+ then [ALRNoLayout (containsCommas u) False]+ else []+ setALRContext ls+ -- XXX This is an error in John's code, but+ -- it looks reachable to me at first glance+ return t+ (u, _, _)+ | isALRopen u ->+ do setALRContext (ALRNoLayout (containsCommas u) False : context)+ return t+ (ITin, ALRLayout ALRLayoutLet _ : ls, _) ->+ do setALRContext ls+ setPendingImplicitTokens [t]+ return (L thisLoc ITvccurly)+ (ITin, ALRLayout _ _ : ls, _) ->+ do setALRContext ls+ setNextToken t+ return (L thisLoc ITvccurly)+ -- the other ITin case omitted; general case below covers it+ (ITcomma, ALRLayout _ _ : ls, _)+ | topNoLayoutContainsCommas ls ->+ do setALRContext ls+ setNextToken t+ return (L thisLoc ITvccurly)+ (ITwhere, ALRLayout ALRLayoutDo _ : ls, _) ->+ do setALRContext ls+ setPendingImplicitTokens [t]+ return (L thisLoc ITvccurly)+ -- the other ITwhere case omitted; general case below covers it+ (_, _, _) -> return t++isALRopen :: Token -> Bool+isALRopen ITcase = True+isALRopen ITif = True+isALRopen ITthen = True+isALRopen IToparen = True+isALRopen ITobrack = True+isALRopen ITocurly = True+-- GHC Extensions:+isALRopen IToubxparen = True+isALRopen _ = False++isALRclose :: Token -> Bool+isALRclose ITof = True+isALRclose ITthen = True+isALRclose ITelse = True+isALRclose ITcparen = True+isALRclose ITcbrack = True+isALRclose ITccurly = True+-- GHC Extensions:+isALRclose ITcubxparen = True+isALRclose _ = False++isNonDecreasingIndentation :: ALRLayout -> Bool+isNonDecreasingIndentation ALRLayoutDo = True+isNonDecreasingIndentation _ = False++containsCommas :: Token -> Bool+containsCommas IToparen = True+containsCommas ITobrack = True+-- John doesn't have {} as containing commas, but records contain them,+-- which caused a problem parsing Cabal's Distribution.Simple.InstallDirs+-- (defaultInstallDirs).+containsCommas ITocurly = True+-- GHC Extensions:+containsCommas IToubxparen = True+containsCommas _ = False++topNoLayoutContainsCommas :: [ALRContext] -> Bool+topNoLayoutContainsCommas [] = False+topNoLayoutContainsCommas (ALRLayout _ _ : ls) = topNoLayoutContainsCommas ls+topNoLayoutContainsCommas (ALRNoLayout b _ : _) = b++lexToken :: P (PsLocated Token)+lexToken = do+ inp@(AI loc1 buf) <- getInput+ sc <- getLexState+ exts <- getExts+ case alexScanUser exts inp sc of+ AlexEOF -> do+ let span = mkPsSpan loc1 loc1+ lt <- getLastLocEof+ setEofPos (psRealSpan span) (psRealSpan lt)+ setLastToken span 0+ return (L span ITeof)+ AlexError (AI loc2 buf) ->+ reportLexError (psRealLoc loc1) (psRealLoc loc2) buf+ (\k -> PsError (PsErrLexer LexError k) [])+ AlexSkip inp2 _ -> do+ setInput inp2+ lexToken+ AlexToken inp2@(AI end buf2) _ t -> do+ setInput inp2+ let span = mkPsSpan loc1 end+ let bytes = byteDiff buf buf2+ span `seq` setLastToken span bytes+ lt <- t span buf bytes+ let lt' = unLoc lt+ if (isComment lt') then setLastComment lt else setLastTk lt+ return lt++reportLexError :: RealSrcLoc -> RealSrcLoc -> StringBuffer -> (LexErrKind -> SrcSpan -> PsError) -> P a+reportLexError loc1 loc2 buf f+ | atEnd buf = failLocMsgP loc1 loc2 (f LexErrKind_EOF)+ | otherwise =+ let c = fst (nextChar buf)+ in if c == '\0' -- decoding errors are mapped to '\0', see utf8DecodeChar#+ then failLocMsgP loc2 loc2 (f LexErrKind_UTF8)+ else failLocMsgP loc1 loc2 (f (LexErrKind_Char c))++lexTokenStream :: ParserOpts -> StringBuffer -> RealSrcLoc -> ParseResult [Located Token]+lexTokenStream opts buf loc = unP go initState{ options = opts' }+ where+ new_exts = xunset HaddockBit -- disable Haddock+ $ xunset UsePosPragsBit -- parse LINE/COLUMN pragmas as tokens+ $ xset RawTokenStreamBit -- include comments+ $ pExtsBitmap opts+ opts' = opts { pExtsBitmap = new_exts }+ initState = initParserState opts' buf loc+ go = do+ ltok <- lexer False return+ case ltok of+ L _ ITeof -> return []+ _ -> liftM (ltok:) go++linePrags = Map.singleton "line" linePrag++fileHeaderPrags = Map.fromList([("options", lex_string_prag IToptions_prag),+ ("options_ghc", lex_string_prag IToptions_prag),+ ("options_haddock", lex_string_prag_comment ITdocOptions),+ ("language", token ITlanguage_prag),+ ("include", lex_string_prag ITinclude_prag)])++ignoredPrags = Map.fromList (map ignored pragmas)+ where ignored opt = (opt, nested_comment lexToken)+ impls = ["hugs", "nhc98", "jhc", "yhc", "catch", "derive"]+ options_pragmas = map ("options_" ++) impls+ -- CFILES is a hugs-only thing.+ pragmas = options_pragmas ++ ["cfiles", "contract"]++oneWordPrags = Map.fromList [+ ("rules", rulePrag),+ ("inline",+ strtoken (\s -> (ITinline_prag (SourceText s) Inline FunLike))),+ ("inlinable",+ strtoken (\s -> (ITinline_prag (SourceText s) Inlinable FunLike))),+ ("inlineable",+ strtoken (\s -> (ITinline_prag (SourceText s) Inlinable FunLike))),+ -- Spelling variant+ ("notinline",+ strtoken (\s -> (ITinline_prag (SourceText s) NoInline FunLike))),+ ("specialize", strtoken (\s -> ITspec_prag (SourceText s))),+ ("source", strtoken (\s -> ITsource_prag (SourceText s))),+ ("warning", strtoken (\s -> ITwarning_prag (SourceText s))),+ ("deprecated", strtoken (\s -> ITdeprecated_prag (SourceText s))),+ ("scc", strtoken (\s -> ITscc_prag (SourceText s))),+ ("unpack", strtoken (\s -> ITunpack_prag (SourceText s))),+ ("nounpack", strtoken (\s -> ITnounpack_prag (SourceText s))),+ ("ann", strtoken (\s -> ITann_prag (SourceText s))),+ ("minimal", strtoken (\s -> ITminimal_prag (SourceText s))),+ ("overlaps", strtoken (\s -> IToverlaps_prag (SourceText s))),+ ("overlappable", strtoken (\s -> IToverlappable_prag (SourceText s))),+ ("overlapping", strtoken (\s -> IToverlapping_prag (SourceText s))),+ ("incoherent", strtoken (\s -> ITincoherent_prag (SourceText s))),+ ("ctype", strtoken (\s -> ITctype (SourceText s))),+ ("complete", strtoken (\s -> ITcomplete_prag (SourceText s))),+ ("column", columnPrag)+ ]++twoWordPrags = Map.fromList [+ ("inline conlike",+ strtoken (\s -> (ITinline_prag (SourceText s) Inline ConLike))),+ ("notinline conlike",+ strtoken (\s -> (ITinline_prag (SourceText s) NoInline ConLike))),+ ("specialize inline",+ strtoken (\s -> (ITspec_inline_prag (SourceText s) True))),+ ("specialize notinline",+ strtoken (\s -> (ITspec_inline_prag (SourceText s) False)))+ ]++dispatch_pragmas :: Map String Action -> Action+dispatch_pragmas prags span buf len = case Map.lookup (clean_pragma (lexemeToString buf len)) prags of+ Just found -> found span buf len+ Nothing -> lexError LexUnknownPragma++known_pragma :: Map String Action -> AlexAccPred ExtsBitmap+known_pragma prags _ (AI _ startbuf) _ (AI _ curbuf)+ = isKnown && nextCharIsNot curbuf pragmaNameChar+ where l = lexemeToString startbuf (byteDiff startbuf curbuf)+ isKnown = isJust $ Map.lookup (clean_pragma l) prags+ pragmaNameChar c = isAlphaNum c || c == '_'++clean_pragma :: String -> String+clean_pragma prag = canon_ws (map toLower (unprefix prag))+ where unprefix prag' = case stripPrefix "{-#" prag' of+ Just rest -> rest+ Nothing -> prag'+ canonical prag' = case prag' of+ "noinline" -> "notinline"+ "specialise" -> "specialize"+ "constructorlike" -> "conlike"+ _ -> prag'+ canon_ws s = unwords (map canonical (words s))++++{-+%************************************************************************+%* *+ Helper functions for generating annotations in the parser+%* *+%************************************************************************+-}+++-- |Given a 'RealSrcSpan' that surrounds a 'HsPar' or 'HsParTy', generate+-- 'AddEpAnn' values for the opening and closing bordering on the start+-- and end of the span+mkParensEpAnn :: RealSrcSpan -> (AddEpAnn, AddEpAnn)+mkParensEpAnn ss = (AddEpAnn AnnOpenP (EpaSpan lo),AddEpAnn AnnCloseP (EpaSpan lc))+ where+ f = srcSpanFile ss+ sl = srcSpanStartLine ss+ sc = srcSpanStartCol ss+ el = srcSpanEndLine ss+ ec = srcSpanEndCol ss+ lo = mkRealSrcSpan (realSrcSpanStart ss) (mkRealSrcLoc f sl (sc+1))+ lc = mkRealSrcSpan (mkRealSrcLoc f el (ec - 1)) (realSrcSpanEnd ss)++queueComment :: RealLocated Token -> P()+queueComment c = P $ \s -> POk s {+ comment_q = commentToAnnotation c : comment_q s+ } ()++allocateComments+ :: RealSrcSpan+ -> [LEpaComment]+ -> ([LEpaComment], [LEpaComment])+allocateComments ss comment_q =+ let+ (before,rest) = break (\(L l _) -> isRealSubspanOf (anchor l) ss) comment_q+ (middle,after) = break (\(L l _) -> not (isRealSubspanOf (anchor l) ss)) rest+ comment_q' = before ++ after+ newAnns = middle+ in+ (comment_q', newAnns)++allocatePriorComments+ :: RealSrcSpan+ -> [LEpaComment]+ -> Maybe [LEpaComment]+ -> (Maybe [LEpaComment], [LEpaComment], [LEpaComment])+allocatePriorComments ss comment_q mheader_comments =+ let+ cmp (L l _) = anchor l <= ss+ (before,after) = partition cmp comment_q+ newAnns = before+ comment_q'= after+ in+ case mheader_comments of+ Nothing -> (Just newAnns, comment_q', [])+ Just _ -> (mheader_comments, comment_q', newAnns)++allocateFinalComments+ :: RealSrcSpan+ -> [LEpaComment]+ -> Maybe [LEpaComment]+ -> (Maybe [LEpaComment], [LEpaComment], [LEpaComment])+allocateFinalComments ss comment_q mheader_comments =+ let+ cmp (L l _) = anchor l <= ss+ (before,after) = partition cmp comment_q+ newAnns = after+ comment_q'= before+ in+ case mheader_comments of+ Nothing -> (Just newAnns, [], comment_q')+ Just _ -> (mheader_comments, [], comment_q' ++ newAnns)++commentToAnnotation :: RealLocated Token -> LEpaComment+commentToAnnotation (L l (ITdocCommentNext s ll)) = mkLEpaComment l ll (EpaDocCommentNext s)+commentToAnnotation (L l (ITdocCommentPrev s ll)) = mkLEpaComment l ll (EpaDocCommentPrev s)+commentToAnnotation (L l (ITdocCommentNamed s ll)) = mkLEpaComment l ll (EpaDocCommentNamed s)+commentToAnnotation (L l (ITdocSection n s ll)) = mkLEpaComment l ll (EpaDocSection n s)+commentToAnnotation (L l (ITdocOptions s ll)) = mkLEpaComment l ll (EpaDocOptions s)+commentToAnnotation (L l (ITlineComment s ll)) = mkLEpaComment l ll (EpaLineComment s)+commentToAnnotation (L l (ITblockComment s ll)) = mkLEpaComment l ll (EpaBlockComment s)+commentToAnnotation _ = panic "commentToAnnotation"++-- see Note [PsSpan in Comments]+mkLEpaComment :: RealSrcSpan -> PsSpan -> EpaCommentTok -> LEpaComment+mkLEpaComment l ll tok = L (realSpanAsAnchor l) (EpaComment tok (psRealSpan ll))++-- ---------------------------------------------------------------------++isComment :: Token -> Bool+isComment (ITlineComment _ _) = True+isComment (ITblockComment _ _) = True+isComment (ITdocCommentNext _ _) = True+isComment (ITdocCommentPrev _ _) = True+isComment (ITdocCommentNamed _ _) = True+isComment (ITdocSection _ _ _) = True+isComment (ITdocOptions _ _) = True+isComment _ = False+}
ghc-lib-parser.cabal view
@@ -1,7 +1,7 @@ cabal-version: 2.0 build-type: Simple name: ghc-lib-parser-version: 9.2.3.20220527+version: 9.2.3.20220709 license: BSD3 license-file: LICENSE category: Development@@ -38,9 +38,10 @@ ghc-lib/stage0/compiler/build/primop-docs.hs-incl ghc-lib/stage0/compiler/build/GHC/Platform/Constants.hs ghc-lib/stage0/libraries/ghc-boot/build/GHC/Version.hs+ ghc-lib/stage0/libraries/ghc-boot/build/GHC/Platform/Host.hs ghc-lib/stage0/compiler/build/GHC/Settings/Config.hs- ghc-lib/stage0/compiler/build/GHC/Parser.hs- ghc-lib/stage0/compiler/build/GHC/Parser/Lexer.hs+ compiler/GHC/Parser.y+ compiler/GHC/Parser/Lexer.x includes/MachDeps.h includes/stg/MachRegs.h includes/CodeGen.Platform.hs
− ghc-lib/stage0/compiler/build/GHC/Parser.hs
@@ -1,13042 +0,0 @@-{-# OPTIONS_GHC -w #-}-{-# OPTIONS -XMagicHash -XBangPatterns -XTypeSynonymInstances -XFlexibleInstances -cpp #-}-#if __GLASGOW_HASKELL__ >= 710-{-# OPTIONS_GHC -XPartialTypeSignatures #-}-#endif-{-# LANGUAGE ViewPatterns #-}-{-# LANGUAGE TypeFamilies #-}-{-# LANGUAGE LambdaCase #-}-{-# LANGUAGE RankNTypes #-}-{-# LANGUAGE GADTs #-}-{-# LANGUAGE ScopedTypeVariables #-}---- | This module provides the generated Happy parser for Haskell. It exports--- a number of parsers which may be used in any library that uses the GHC API.--- A common usage pattern is to initialize the parser state with a given string--- and then parse that string:------ @--- runParser :: ParserOpts -> String -> P a -> ParseResult a--- runParser opts str parser = unP parser parseState--- where--- filename = "\<interactive\>"--- location = mkRealSrcLoc (mkFastString filename) 1 1--- buffer = stringToStringBuffer str--- parseState = initParserState opts buffer location--- @-module GHC.Parser- ( parseModule, parseSignature, parseImport, parseStatement, parseBackpack- , parseDeclaration, parseExpression, parsePattern- , parseTypeSignature- , parseStmt, parseIdentifier- , parseType, parseHeader- , parseModuleNoHaddock- )-where---- base-import Control.Monad ( unless, liftM, when, (<=<) )-import GHC.Exts-import Data.Maybe ( maybeToList )-import Data.List.NonEmpty ( NonEmpty((:|)) )-import qualified Data.List.NonEmpty as NE-import qualified Prelude -- for happy-generated code--import GHC.Prelude--import GHC.Hs--import GHC.Driver.Backpack.Syntax--import GHC.Unit.Info-import GHC.Unit.Module-import GHC.Unit.Module.Warnings--import GHC.Data.OrdList-import GHC.Data.BooleanFormula ( BooleanFormula(..), LBooleanFormula, mkTrue )-import GHC.Data.FastString-import GHC.Data.Maybe ( orElse )--import GHC.Utils.Outputable-import GHC.Utils.Misc ( looksLikePackageName, fstOf3, sndOf3, thdOf3 )-import GHC.Utils.Panic-import GHC.Prelude--import GHC.Types.Name.Reader-import GHC.Types.Name.Occurrence ( varName, dataName, tcClsName, tvName, occNameFS, mkVarOcc, occNameString)-import GHC.Types.SrcLoc-import GHC.Types.Basic-import GHC.Types.Fixity-import GHC.Types.ForeignCall-import GHC.Types.SourceFile-import GHC.Types.SourceText--import GHC.Core.Type ( unrestrictedFunTyCon, Specificity(..) )-import GHC.Core.Class ( FunDep )-import GHC.Core.DataCon ( DataCon, dataConName )--import GHC.Parser.PostProcess-import GHC.Parser.PostProcess.Haddock-import GHC.Parser.Lexer-import GHC.Parser.Annotation-import GHC.Parser.Errors--import GHC.Builtin.Types ( unitTyCon, unitDataCon, tupleTyCon, tupleDataCon, nilDataCon,- unboxedUnitTyCon, unboxedUnitDataCon,- listTyCon_RDR, consDataCon_RDR, eqTyCon_RDR)--import qualified Data.Semigroup as Semi-import qualified Data.Array as Happy_Data_Array-import qualified Data.Bits as Bits-import qualified GHC.Exts as Happy_GHC_Exts-import Control.Applicative(Applicative(..))-import Control.Monad (ap)---- parser produced by Happy Version 1.20.0--newtype HappyAbsSyn = HappyAbsSyn HappyAny-#if __GLASGOW_HASKELL__ >= 607-type HappyAny = Happy_GHC_Exts.Any-#else-type HappyAny = forall a . a-#endif-newtype HappyWrap16 = HappyWrap16 (LocatedN RdrName)-happyIn16 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn16 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap16 x)-{-# INLINE happyIn16 #-}-happyOut16 :: (HappyAbsSyn ) -> HappyWrap16-happyOut16 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut16 #-}-newtype HappyWrap17 = HappyWrap17 ([LHsUnit PackageName])-happyIn17 :: ([LHsUnit PackageName]) -> (HappyAbsSyn )-happyIn17 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap17 x)-{-# INLINE happyIn17 #-}-happyOut17 :: (HappyAbsSyn ) -> HappyWrap17-happyOut17 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut17 #-}-newtype HappyWrap18 = HappyWrap18 (OrdList (LHsUnit PackageName))-happyIn18 :: (OrdList (LHsUnit PackageName)) -> (HappyAbsSyn )-happyIn18 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap18 x)-{-# INLINE happyIn18 #-}-happyOut18 :: (HappyAbsSyn ) -> HappyWrap18-happyOut18 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut18 #-}-newtype HappyWrap19 = HappyWrap19 (LHsUnit PackageName)-happyIn19 :: (LHsUnit PackageName) -> (HappyAbsSyn )-happyIn19 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap19 x)-{-# INLINE happyIn19 #-}-happyOut19 :: (HappyAbsSyn ) -> HappyWrap19-happyOut19 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut19 #-}-newtype HappyWrap20 = HappyWrap20 (LHsUnitId PackageName)-happyIn20 :: (LHsUnitId PackageName) -> (HappyAbsSyn )-happyIn20 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap20 x)-{-# INLINE happyIn20 #-}-happyOut20 :: (HappyAbsSyn ) -> HappyWrap20-happyOut20 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut20 #-}-newtype HappyWrap21 = HappyWrap21 (OrdList (LHsModuleSubst PackageName))-happyIn21 :: (OrdList (LHsModuleSubst PackageName)) -> (HappyAbsSyn )-happyIn21 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap21 x)-{-# INLINE happyIn21 #-}-happyOut21 :: (HappyAbsSyn ) -> HappyWrap21-happyOut21 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut21 #-}-newtype HappyWrap22 = HappyWrap22 (LHsModuleSubst PackageName)-happyIn22 :: (LHsModuleSubst PackageName) -> (HappyAbsSyn )-happyIn22 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap22 x)-{-# INLINE happyIn22 #-}-happyOut22 :: (HappyAbsSyn ) -> HappyWrap22-happyOut22 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut22 #-}-newtype HappyWrap23 = HappyWrap23 (LHsModuleId PackageName)-happyIn23 :: (LHsModuleId PackageName) -> (HappyAbsSyn )-happyIn23 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap23 x)-{-# INLINE happyIn23 #-}-happyOut23 :: (HappyAbsSyn ) -> HappyWrap23-happyOut23 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut23 #-}-newtype HappyWrap24 = HappyWrap24 (Located PackageName)-happyIn24 :: (Located PackageName) -> (HappyAbsSyn )-happyIn24 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap24 x)-{-# INLINE happyIn24 #-}-happyOut24 :: (HappyAbsSyn ) -> HappyWrap24-happyOut24 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut24 #-}-newtype HappyWrap25 = HappyWrap25 (Located FastString)-happyIn25 :: (Located FastString) -> (HappyAbsSyn )-happyIn25 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap25 x)-{-# INLINE happyIn25 #-}-happyOut25 :: (HappyAbsSyn ) -> HappyWrap25-happyOut25 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut25 #-}-newtype HappyWrap26 = HappyWrap26 ([AddEpAnn])-happyIn26 :: ([AddEpAnn]) -> (HappyAbsSyn )-happyIn26 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap26 x)-{-# INLINE happyIn26 #-}-happyOut26 :: (HappyAbsSyn ) -> HappyWrap26-happyOut26 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut26 #-}-newtype HappyWrap27 = HappyWrap27 (Located FastString)-happyIn27 :: (Located FastString) -> (HappyAbsSyn )-happyIn27 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap27 x)-{-# INLINE happyIn27 #-}-happyOut27 :: (HappyAbsSyn ) -> HappyWrap27-happyOut27 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut27 #-}-newtype HappyWrap28 = HappyWrap28 (Maybe [LRenaming])-happyIn28 :: (Maybe [LRenaming]) -> (HappyAbsSyn )-happyIn28 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap28 x)-{-# INLINE happyIn28 #-}-happyOut28 :: (HappyAbsSyn ) -> HappyWrap28-happyOut28 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut28 #-}-newtype HappyWrap29 = HappyWrap29 (OrdList LRenaming)-happyIn29 :: (OrdList LRenaming) -> (HappyAbsSyn )-happyIn29 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap29 x)-{-# INLINE happyIn29 #-}-happyOut29 :: (HappyAbsSyn ) -> HappyWrap29-happyOut29 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut29 #-}-newtype HappyWrap30 = HappyWrap30 (LRenaming)-happyIn30 :: (LRenaming) -> (HappyAbsSyn )-happyIn30 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap30 x)-{-# INLINE happyIn30 #-}-happyOut30 :: (HappyAbsSyn ) -> HappyWrap30-happyOut30 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut30 #-}-newtype HappyWrap31 = HappyWrap31 (OrdList (LHsUnitDecl PackageName))-happyIn31 :: (OrdList (LHsUnitDecl PackageName)) -> (HappyAbsSyn )-happyIn31 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap31 x)-{-# INLINE happyIn31 #-}-happyOut31 :: (HappyAbsSyn ) -> HappyWrap31-happyOut31 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut31 #-}-newtype HappyWrap32 = HappyWrap32 (OrdList (LHsUnitDecl PackageName))-happyIn32 :: (OrdList (LHsUnitDecl PackageName)) -> (HappyAbsSyn )-happyIn32 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap32 x)-{-# INLINE happyIn32 #-}-happyOut32 :: (HappyAbsSyn ) -> HappyWrap32-happyOut32 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut32 #-}-newtype HappyWrap33 = HappyWrap33 (LHsUnitDecl PackageName)-happyIn33 :: (LHsUnitDecl PackageName) -> (HappyAbsSyn )-happyIn33 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap33 x)-{-# INLINE happyIn33 #-}-happyOut33 :: (HappyAbsSyn ) -> HappyWrap33-happyOut33 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut33 #-}-newtype HappyWrap34 = HappyWrap34 (Located HsModule)-happyIn34 :: (Located HsModule) -> (HappyAbsSyn )-happyIn34 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap34 x)-{-# INLINE happyIn34 #-}-happyOut34 :: (HappyAbsSyn ) -> HappyWrap34-happyOut34 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut34 #-}-newtype HappyWrap35 = HappyWrap35 (Located HsModule)-happyIn35 :: (Located HsModule) -> (HappyAbsSyn )-happyIn35 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap35 x)-{-# INLINE happyIn35 #-}-happyOut35 :: (HappyAbsSyn ) -> HappyWrap35-happyOut35 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut35 #-}-newtype HappyWrap36 = HappyWrap36 (())-happyIn36 :: (()) -> (HappyAbsSyn )-happyIn36 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap36 x)-{-# INLINE happyIn36 #-}-happyOut36 :: (HappyAbsSyn ) -> HappyWrap36-happyOut36 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut36 #-}-newtype HappyWrap37 = HappyWrap37 (())-happyIn37 :: (()) -> (HappyAbsSyn )-happyIn37 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap37 x)-{-# INLINE happyIn37 #-}-happyOut37 :: (HappyAbsSyn ) -> HappyWrap37-happyOut37 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut37 #-}-newtype HappyWrap38 = HappyWrap38 (Maybe (LocatedP WarningTxt))-happyIn38 :: (Maybe (LocatedP WarningTxt)) -> (HappyAbsSyn )-happyIn38 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap38 x)-{-# INLINE happyIn38 #-}-happyOut38 :: (HappyAbsSyn ) -> HappyWrap38-happyOut38 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut38 #-}-newtype HappyWrap39 = HappyWrap39 ((AnnList- ,([LImportDecl GhcPs], [LHsDecl GhcPs])- ,LayoutInfo))-happyIn39 :: ((AnnList- ,([LImportDecl GhcPs], [LHsDecl GhcPs])- ,LayoutInfo)) -> (HappyAbsSyn )-happyIn39 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap39 x)-{-# INLINE happyIn39 #-}-happyOut39 :: (HappyAbsSyn ) -> HappyWrap39-happyOut39 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut39 #-}-newtype HappyWrap40 = HappyWrap40 ((AnnList- ,([LImportDecl GhcPs], [LHsDecl GhcPs])- ,LayoutInfo))-happyIn40 :: ((AnnList- ,([LImportDecl GhcPs], [LHsDecl GhcPs])- ,LayoutInfo)) -> (HappyAbsSyn )-happyIn40 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap40 x)-{-# INLINE happyIn40 #-}-happyOut40 :: (HappyAbsSyn ) -> HappyWrap40-happyOut40 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut40 #-}-newtype HappyWrap41 = HappyWrap41 (([TrailingAnn]- ,([LImportDecl GhcPs], [LHsDecl GhcPs])))-happyIn41 :: (([TrailingAnn]- ,([LImportDecl GhcPs], [LHsDecl GhcPs]))) -> (HappyAbsSyn )-happyIn41 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap41 x)-{-# INLINE happyIn41 #-}-happyOut41 :: (HappyAbsSyn ) -> HappyWrap41-happyOut41 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut41 #-}-newtype HappyWrap42 = HappyWrap42 (([LImportDecl GhcPs], [LHsDecl GhcPs]))-happyIn42 :: (([LImportDecl GhcPs], [LHsDecl GhcPs])) -> (HappyAbsSyn )-happyIn42 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap42 x)-{-# INLINE happyIn42 #-}-happyOut42 :: (HappyAbsSyn ) -> HappyWrap42-happyOut42 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut42 #-}-newtype HappyWrap43 = HappyWrap43 (Located HsModule)-happyIn43 :: (Located HsModule) -> (HappyAbsSyn )-happyIn43 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap43 x)-{-# INLINE happyIn43 #-}-happyOut43 :: (HappyAbsSyn ) -> HappyWrap43-happyOut43 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut43 #-}-newtype HappyWrap44 = HappyWrap44 ([LImportDecl GhcPs])-happyIn44 :: ([LImportDecl GhcPs]) -> (HappyAbsSyn )-happyIn44 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap44 x)-{-# INLINE happyIn44 #-}-happyOut44 :: (HappyAbsSyn ) -> HappyWrap44-happyOut44 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut44 #-}-newtype HappyWrap45 = HappyWrap45 ([LImportDecl GhcPs])-happyIn45 :: ([LImportDecl GhcPs]) -> (HappyAbsSyn )-happyIn45 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap45 x)-{-# INLINE happyIn45 #-}-happyOut45 :: (HappyAbsSyn ) -> HappyWrap45-happyOut45 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut45 #-}-newtype HappyWrap46 = HappyWrap46 ([LImportDecl GhcPs])-happyIn46 :: ([LImportDecl GhcPs]) -> (HappyAbsSyn )-happyIn46 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap46 x)-{-# INLINE happyIn46 #-}-happyOut46 :: (HappyAbsSyn ) -> HappyWrap46-happyOut46 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut46 #-}-newtype HappyWrap47 = HappyWrap47 ([LImportDecl GhcPs])-happyIn47 :: ([LImportDecl GhcPs]) -> (HappyAbsSyn )-happyIn47 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap47 x)-{-# INLINE happyIn47 #-}-happyOut47 :: (HappyAbsSyn ) -> HappyWrap47-happyOut47 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut47 #-}-newtype HappyWrap48 = HappyWrap48 ((Maybe (LocatedL [LIE GhcPs])))-happyIn48 :: ((Maybe (LocatedL [LIE GhcPs]))) -> (HappyAbsSyn )-happyIn48 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap48 x)-{-# INLINE happyIn48 #-}-happyOut48 :: (HappyAbsSyn ) -> HappyWrap48-happyOut48 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut48 #-}-newtype HappyWrap49 = HappyWrap49 (([AddEpAnn], OrdList (LIE GhcPs)))-happyIn49 :: (([AddEpAnn], OrdList (LIE GhcPs))) -> (HappyAbsSyn )-happyIn49 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap49 x)-{-# INLINE happyIn49 #-}-happyOut49 :: (HappyAbsSyn ) -> HappyWrap49-happyOut49 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut49 #-}-newtype HappyWrap50 = HappyWrap50 (OrdList (LIE GhcPs))-happyIn50 :: (OrdList (LIE GhcPs)) -> (HappyAbsSyn )-happyIn50 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap50 x)-{-# INLINE happyIn50 #-}-happyOut50 :: (HappyAbsSyn ) -> HappyWrap50-happyOut50 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut50 #-}-newtype HappyWrap51 = HappyWrap51 (OrdList (LIE GhcPs))-happyIn51 :: (OrdList (LIE GhcPs)) -> (HappyAbsSyn )-happyIn51 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap51 x)-{-# INLINE happyIn51 #-}-happyOut51 :: (HappyAbsSyn ) -> HappyWrap51-happyOut51 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut51 #-}-newtype HappyWrap52 = HappyWrap52 (Located ([AddEpAnn],ImpExpSubSpec))-happyIn52 :: (Located ([AddEpAnn],ImpExpSubSpec)) -> (HappyAbsSyn )-happyIn52 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap52 x)-{-# INLINE happyIn52 #-}-happyOut52 :: (HappyAbsSyn ) -> HappyWrap52-happyOut52 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut52 #-}-newtype HappyWrap53 = HappyWrap53 (([AddEpAnn], [LocatedA ImpExpQcSpec]))-happyIn53 :: (([AddEpAnn], [LocatedA ImpExpQcSpec])) -> (HappyAbsSyn )-happyIn53 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap53 x)-{-# INLINE happyIn53 #-}-happyOut53 :: (HappyAbsSyn ) -> HappyWrap53-happyOut53 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut53 #-}-newtype HappyWrap54 = HappyWrap54 (([AddEpAnn], [LocatedA ImpExpQcSpec]))-happyIn54 :: (([AddEpAnn], [LocatedA ImpExpQcSpec])) -> (HappyAbsSyn )-happyIn54 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap54 x)-{-# INLINE happyIn54 #-}-happyOut54 :: (HappyAbsSyn ) -> HappyWrap54-happyOut54 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut54 #-}-newtype HappyWrap55 = HappyWrap55 (Located ([AddEpAnn], LocatedA ImpExpQcSpec))-happyIn55 :: (Located ([AddEpAnn], LocatedA ImpExpQcSpec)) -> (HappyAbsSyn )-happyIn55 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap55 x)-{-# INLINE happyIn55 #-}-happyOut55 :: (HappyAbsSyn ) -> HappyWrap55-happyOut55 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut55 #-}-newtype HappyWrap56 = HappyWrap56 (LocatedA ImpExpQcSpec)-happyIn56 :: (LocatedA ImpExpQcSpec) -> (HappyAbsSyn )-happyIn56 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap56 x)-{-# INLINE happyIn56 #-}-happyOut56 :: (HappyAbsSyn ) -> HappyWrap56-happyOut56 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut56 #-}-newtype HappyWrap57 = HappyWrap57 (LocatedN RdrName)-happyIn57 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn57 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap57 x)-{-# INLINE happyIn57 #-}-happyOut57 :: (HappyAbsSyn ) -> HappyWrap57-happyOut57 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut57 #-}-newtype HappyWrap58 = HappyWrap58 (Located [TrailingAnn])-happyIn58 :: (Located [TrailingAnn]) -> (HappyAbsSyn )-happyIn58 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap58 x)-{-# INLINE happyIn58 #-}-happyOut58 :: (HappyAbsSyn ) -> HappyWrap58-happyOut58 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut58 #-}-newtype HappyWrap59 = HappyWrap59 ([TrailingAnn])-happyIn59 :: ([TrailingAnn]) -> (HappyAbsSyn )-happyIn59 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap59 x)-{-# INLINE happyIn59 #-}-happyOut59 :: (HappyAbsSyn ) -> HappyWrap59-happyOut59 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut59 #-}-newtype HappyWrap60 = HappyWrap60 ([LImportDecl GhcPs])-happyIn60 :: ([LImportDecl GhcPs]) -> (HappyAbsSyn )-happyIn60 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap60 x)-{-# INLINE happyIn60 #-}-happyOut60 :: (HappyAbsSyn ) -> HappyWrap60-happyOut60 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut60 #-}-newtype HappyWrap61 = HappyWrap61 ([LImportDecl GhcPs])-happyIn61 :: ([LImportDecl GhcPs]) -> (HappyAbsSyn )-happyIn61 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap61 x)-{-# INLINE happyIn61 #-}-happyOut61 :: (HappyAbsSyn ) -> HappyWrap61-happyOut61 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut61 #-}-newtype HappyWrap62 = HappyWrap62 (LImportDecl GhcPs)-happyIn62 :: (LImportDecl GhcPs) -> (HappyAbsSyn )-happyIn62 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap62 x)-{-# INLINE happyIn62 #-}-happyOut62 :: (HappyAbsSyn ) -> HappyWrap62-happyOut62 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut62 #-}-newtype HappyWrap63 = HappyWrap63 (((Maybe (EpaLocation,EpaLocation),SourceText),IsBootInterface))-happyIn63 :: (((Maybe (EpaLocation,EpaLocation),SourceText),IsBootInterface)) -> (HappyAbsSyn )-happyIn63 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap63 x)-{-# INLINE happyIn63 #-}-happyOut63 :: (HappyAbsSyn ) -> HappyWrap63-happyOut63 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut63 #-}-newtype HappyWrap64 = HappyWrap64 ((Maybe EpaLocation,Bool))-happyIn64 :: ((Maybe EpaLocation,Bool)) -> (HappyAbsSyn )-happyIn64 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap64 x)-{-# INLINE happyIn64 #-}-happyOut64 :: (HappyAbsSyn ) -> HappyWrap64-happyOut64 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut64 #-}-newtype HappyWrap65 = HappyWrap65 ((Maybe EpaLocation,Maybe StringLiteral))-happyIn65 :: ((Maybe EpaLocation,Maybe StringLiteral)) -> (HappyAbsSyn )-happyIn65 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap65 x)-{-# INLINE happyIn65 #-}-happyOut65 :: (HappyAbsSyn ) -> HappyWrap65-happyOut65 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut65 #-}-newtype HappyWrap66 = HappyWrap66 (Located (Maybe EpaLocation))-happyIn66 :: (Located (Maybe EpaLocation)) -> (HappyAbsSyn )-happyIn66 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap66 x)-{-# INLINE happyIn66 #-}-happyOut66 :: (HappyAbsSyn ) -> HappyWrap66-happyOut66 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut66 #-}-newtype HappyWrap67 = HappyWrap67 ((Maybe EpaLocation,Located (Maybe (LocatedA ModuleName))))-happyIn67 :: ((Maybe EpaLocation,Located (Maybe (LocatedA ModuleName)))) -> (HappyAbsSyn )-happyIn67 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap67 x)-{-# INLINE happyIn67 #-}-happyOut67 :: (HappyAbsSyn ) -> HappyWrap67-happyOut67 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut67 #-}-newtype HappyWrap68 = HappyWrap68 (Located (Maybe (Bool, LocatedL [LIE GhcPs])))-happyIn68 :: (Located (Maybe (Bool, LocatedL [LIE GhcPs]))) -> (HappyAbsSyn )-happyIn68 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap68 x)-{-# INLINE happyIn68 #-}-happyOut68 :: (HappyAbsSyn ) -> HappyWrap68-happyOut68 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut68 #-}-newtype HappyWrap69 = HappyWrap69 (Located (Bool, LocatedL [LIE GhcPs]))-happyIn69 :: (Located (Bool, LocatedL [LIE GhcPs])) -> (HappyAbsSyn )-happyIn69 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap69 x)-{-# INLINE happyIn69 #-}-happyOut69 :: (HappyAbsSyn ) -> HappyWrap69-happyOut69 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut69 #-}-newtype HappyWrap70 = HappyWrap70 (Maybe (Located (SourceText,Int)))-happyIn70 :: (Maybe (Located (SourceText,Int))) -> (HappyAbsSyn )-happyIn70 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap70 x)-{-# INLINE happyIn70 #-}-happyOut70 :: (HappyAbsSyn ) -> HappyWrap70-happyOut70 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut70 #-}-newtype HappyWrap71 = HappyWrap71 (Located FixityDirection)-happyIn71 :: (Located FixityDirection) -> (HappyAbsSyn )-happyIn71 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap71 x)-{-# INLINE happyIn71 #-}-happyOut71 :: (HappyAbsSyn ) -> HappyWrap71-happyOut71 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut71 #-}-newtype HappyWrap72 = HappyWrap72 (Located (OrdList (LocatedN RdrName)))-happyIn72 :: (Located (OrdList (LocatedN RdrName))) -> (HappyAbsSyn )-happyIn72 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap72 x)-{-# INLINE happyIn72 #-}-happyOut72 :: (HappyAbsSyn ) -> HappyWrap72-happyOut72 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut72 #-}-newtype HappyWrap73 = HappyWrap73 (OrdList (LHsDecl GhcPs))-happyIn73 :: (OrdList (LHsDecl GhcPs)) -> (HappyAbsSyn )-happyIn73 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap73 x)-{-# INLINE happyIn73 #-}-happyOut73 :: (HappyAbsSyn ) -> HappyWrap73-happyOut73 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut73 #-}-newtype HappyWrap74 = HappyWrap74 (OrdList (LHsDecl GhcPs))-happyIn74 :: (OrdList (LHsDecl GhcPs)) -> (HappyAbsSyn )-happyIn74 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap74 x)-{-# INLINE happyIn74 #-}-happyOut74 :: (HappyAbsSyn ) -> HappyWrap74-happyOut74 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut74 #-}-newtype HappyWrap75 = HappyWrap75 (OrdList (LHsDecl GhcPs))-happyIn75 :: (OrdList (LHsDecl GhcPs)) -> (HappyAbsSyn )-happyIn75 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap75 x)-{-# INLINE happyIn75 #-}-happyOut75 :: (HappyAbsSyn ) -> HappyWrap75-happyOut75 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut75 #-}-newtype HappyWrap76 = HappyWrap76 (OrdList (LHsDecl GhcPs))-happyIn76 :: (OrdList (LHsDecl GhcPs)) -> (HappyAbsSyn )-happyIn76 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap76 x)-{-# INLINE happyIn76 #-}-happyOut76 :: (HappyAbsSyn ) -> HappyWrap76-happyOut76 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut76 #-}-newtype HappyWrap77 = HappyWrap77 (LHsDecl GhcPs)-happyIn77 :: (LHsDecl GhcPs) -> (HappyAbsSyn )-happyIn77 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap77 x)-{-# INLINE happyIn77 #-}-happyOut77 :: (HappyAbsSyn ) -> HappyWrap77-happyOut77 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut77 #-}-newtype HappyWrap78 = HappyWrap78 (LHsDecl GhcPs)-happyIn78 :: (LHsDecl GhcPs) -> (HappyAbsSyn )-happyIn78 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap78 x)-{-# INLINE happyIn78 #-}-happyOut78 :: (HappyAbsSyn ) -> HappyWrap78-happyOut78 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut78 #-}-newtype HappyWrap79 = HappyWrap79 (LTyClDecl GhcPs)-happyIn79 :: (LTyClDecl GhcPs) -> (HappyAbsSyn )-happyIn79 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap79 x)-{-# INLINE happyIn79 #-}-happyOut79 :: (HappyAbsSyn ) -> HappyWrap79-happyOut79 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut79 #-}-newtype HappyWrap80 = HappyWrap80 (LTyClDecl GhcPs)-happyIn80 :: (LTyClDecl GhcPs) -> (HappyAbsSyn )-happyIn80 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap80 x)-{-# INLINE happyIn80 #-}-happyOut80 :: (HappyAbsSyn ) -> HappyWrap80-happyOut80 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut80 #-}-newtype HappyWrap81 = HappyWrap81 (LStandaloneKindSig GhcPs)-happyIn81 :: (LStandaloneKindSig GhcPs) -> (HappyAbsSyn )-happyIn81 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap81 x)-{-# INLINE happyIn81 #-}-happyOut81 :: (HappyAbsSyn ) -> HappyWrap81-happyOut81 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut81 #-}-newtype HappyWrap82 = HappyWrap82 (Located [LocatedN RdrName])-happyIn82 :: (Located [LocatedN RdrName]) -> (HappyAbsSyn )-happyIn82 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap82 x)-{-# INLINE happyIn82 #-}-happyOut82 :: (HappyAbsSyn ) -> HappyWrap82-happyOut82 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut82 #-}-newtype HappyWrap83 = HappyWrap83 (LInstDecl GhcPs)-happyIn83 :: (LInstDecl GhcPs) -> (HappyAbsSyn )-happyIn83 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap83 x)-{-# INLINE happyIn83 #-}-happyOut83 :: (HappyAbsSyn ) -> HappyWrap83-happyOut83 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut83 #-}-newtype HappyWrap84 = HappyWrap84 (Maybe (LocatedP OverlapMode))-happyIn84 :: (Maybe (LocatedP OverlapMode)) -> (HappyAbsSyn )-happyIn84 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap84 x)-{-# INLINE happyIn84 #-}-happyOut84 :: (HappyAbsSyn ) -> HappyWrap84-happyOut84 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut84 #-}-newtype HappyWrap85 = HappyWrap85 (LDerivStrategy GhcPs)-happyIn85 :: (LDerivStrategy GhcPs) -> (HappyAbsSyn )-happyIn85 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap85 x)-{-# INLINE happyIn85 #-}-happyOut85 :: (HappyAbsSyn ) -> HappyWrap85-happyOut85 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut85 #-}-newtype HappyWrap86 = HappyWrap86 (LDerivStrategy GhcPs)-happyIn86 :: (LDerivStrategy GhcPs) -> (HappyAbsSyn )-happyIn86 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap86 x)-{-# INLINE happyIn86 #-}-happyOut86 :: (HappyAbsSyn ) -> HappyWrap86-happyOut86 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut86 #-}-newtype HappyWrap87 = HappyWrap87 (Maybe (LDerivStrategy GhcPs))-happyIn87 :: (Maybe (LDerivStrategy GhcPs)) -> (HappyAbsSyn )-happyIn87 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap87 x)-{-# INLINE happyIn87 #-}-happyOut87 :: (HappyAbsSyn ) -> HappyWrap87-happyOut87 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut87 #-}-newtype HappyWrap88 = HappyWrap88 (Located ([AddEpAnn], Maybe (LInjectivityAnn GhcPs)))-happyIn88 :: (Located ([AddEpAnn], Maybe (LInjectivityAnn GhcPs))) -> (HappyAbsSyn )-happyIn88 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap88 x)-{-# INLINE happyIn88 #-}-happyOut88 :: (HappyAbsSyn ) -> HappyWrap88-happyOut88 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut88 #-}-newtype HappyWrap89 = HappyWrap89 (LInjectivityAnn GhcPs)-happyIn89 :: (LInjectivityAnn GhcPs) -> (HappyAbsSyn )-happyIn89 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap89 x)-{-# INLINE happyIn89 #-}-happyOut89 :: (HappyAbsSyn ) -> HappyWrap89-happyOut89 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut89 #-}-newtype HappyWrap90 = HappyWrap90 (Located [LocatedN RdrName])-happyIn90 :: (Located [LocatedN RdrName]) -> (HappyAbsSyn )-happyIn90 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap90 x)-{-# INLINE happyIn90 #-}-happyOut90 :: (HappyAbsSyn ) -> HappyWrap90-happyOut90 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut90 #-}-newtype HappyWrap91 = HappyWrap91 (Located ([AddEpAnn],FamilyInfo GhcPs))-happyIn91 :: (Located ([AddEpAnn],FamilyInfo GhcPs)) -> (HappyAbsSyn )-happyIn91 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap91 x)-{-# INLINE happyIn91 #-}-happyOut91 :: (HappyAbsSyn ) -> HappyWrap91-happyOut91 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut91 #-}-newtype HappyWrap92 = HappyWrap92 (Located ([AddEpAnn],Maybe [LTyFamInstEqn GhcPs]))-happyIn92 :: (Located ([AddEpAnn],Maybe [LTyFamInstEqn GhcPs])) -> (HappyAbsSyn )-happyIn92 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap92 x)-{-# INLINE happyIn92 #-}-happyOut92 :: (HappyAbsSyn ) -> HappyWrap92-happyOut92 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut92 #-}-newtype HappyWrap93 = HappyWrap93 (Located [LTyFamInstEqn GhcPs])-happyIn93 :: (Located [LTyFamInstEqn GhcPs]) -> (HappyAbsSyn )-happyIn93 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap93 x)-{-# INLINE happyIn93 #-}-happyOut93 :: (HappyAbsSyn ) -> HappyWrap93-happyOut93 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut93 #-}-newtype HappyWrap94 = HappyWrap94 (LTyFamInstEqn GhcPs)-happyIn94 :: (LTyFamInstEqn GhcPs) -> (HappyAbsSyn )-happyIn94 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap94 x)-{-# INLINE happyIn94 #-}-happyOut94 :: (HappyAbsSyn ) -> HappyWrap94-happyOut94 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut94 #-}-newtype HappyWrap95 = HappyWrap95 (LHsDecl GhcPs)-happyIn95 :: (LHsDecl GhcPs) -> (HappyAbsSyn )-happyIn95 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap95 x)-{-# INLINE happyIn95 #-}-happyOut95 :: (HappyAbsSyn ) -> HappyWrap95-happyOut95 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut95 #-}-newtype HappyWrap96 = HappyWrap96 ([AddEpAnn])-happyIn96 :: ([AddEpAnn]) -> (HappyAbsSyn )-happyIn96 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap96 x)-{-# INLINE happyIn96 #-}-happyOut96 :: (HappyAbsSyn ) -> HappyWrap96-happyOut96 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut96 #-}-newtype HappyWrap97 = HappyWrap97 ([AddEpAnn])-happyIn97 :: ([AddEpAnn]) -> (HappyAbsSyn )-happyIn97 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap97 x)-{-# INLINE happyIn97 #-}-happyOut97 :: (HappyAbsSyn ) -> HappyWrap97-happyOut97 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut97 #-}-newtype HappyWrap98 = HappyWrap98 (LInstDecl GhcPs)-happyIn98 :: (LInstDecl GhcPs) -> (HappyAbsSyn )-happyIn98 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap98 x)-{-# INLINE happyIn98 #-}-happyOut98 :: (HappyAbsSyn ) -> HappyWrap98-happyOut98 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut98 #-}-newtype HappyWrap99 = HappyWrap99 (Located (AddEpAnn, NewOrData))-happyIn99 :: (Located (AddEpAnn, NewOrData)) -> (HappyAbsSyn )-happyIn99 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap99 x)-{-# INLINE happyIn99 #-}-happyOut99 :: (HappyAbsSyn ) -> HappyWrap99-happyOut99 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut99 #-}-newtype HappyWrap100 = HappyWrap100 (Located ([AddEpAnn], Maybe (LHsKind GhcPs)))-happyIn100 :: (Located ([AddEpAnn], Maybe (LHsKind GhcPs))) -> (HappyAbsSyn )-happyIn100 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap100 x)-{-# INLINE happyIn100 #-}-happyOut100 :: (HappyAbsSyn ) -> HappyWrap100-happyOut100 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut100 #-}-newtype HappyWrap101 = HappyWrap101 (Located ([AddEpAnn], LFamilyResultSig GhcPs))-happyIn101 :: (Located ([AddEpAnn], LFamilyResultSig GhcPs)) -> (HappyAbsSyn )-happyIn101 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap101 x)-{-# INLINE happyIn101 #-}-happyOut101 :: (HappyAbsSyn ) -> HappyWrap101-happyOut101 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut101 #-}-newtype HappyWrap102 = HappyWrap102 (Located ([AddEpAnn], LFamilyResultSig GhcPs))-happyIn102 :: (Located ([AddEpAnn], LFamilyResultSig GhcPs)) -> (HappyAbsSyn )-happyIn102 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap102 x)-{-# INLINE happyIn102 #-}-happyOut102 :: (HappyAbsSyn ) -> HappyWrap102-happyOut102 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut102 #-}-newtype HappyWrap103 = HappyWrap103 (Located ([AddEpAnn], ( LFamilyResultSig GhcPs- , Maybe (LInjectivityAnn GhcPs))))-happyIn103 :: (Located ([AddEpAnn], ( LFamilyResultSig GhcPs- , Maybe (LInjectivityAnn GhcPs)))) -> (HappyAbsSyn )-happyIn103 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap103 x)-{-# INLINE happyIn103 #-}-happyOut103 :: (HappyAbsSyn ) -> HappyWrap103-happyOut103 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut103 #-}-newtype HappyWrap104 = HappyWrap104 (Located (Maybe (LHsContext GhcPs), LHsType GhcPs))-happyIn104 :: (Located (Maybe (LHsContext GhcPs), LHsType GhcPs)) -> (HappyAbsSyn )-happyIn104 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap104 x)-{-# INLINE happyIn104 #-}-happyOut104 :: (HappyAbsSyn ) -> HappyWrap104-happyOut104 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut104 #-}-newtype HappyWrap105 = HappyWrap105 (Located (Maybe (LHsContext GhcPs), HsOuterFamEqnTyVarBndrs GhcPs, LHsType GhcPs))-happyIn105 :: (Located (Maybe (LHsContext GhcPs), HsOuterFamEqnTyVarBndrs GhcPs, LHsType GhcPs)) -> (HappyAbsSyn )-happyIn105 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap105 x)-{-# INLINE happyIn105 #-}-happyOut105 :: (HappyAbsSyn ) -> HappyWrap105-happyOut105 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut105 #-}-newtype HappyWrap106 = HappyWrap106 (Maybe (LocatedP CType))-happyIn106 :: (Maybe (LocatedP CType)) -> (HappyAbsSyn )-happyIn106 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap106 x)-{-# INLINE happyIn106 #-}-happyOut106 :: (HappyAbsSyn ) -> HappyWrap106-happyOut106 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut106 #-}-newtype HappyWrap107 = HappyWrap107 (LDerivDecl GhcPs)-happyIn107 :: (LDerivDecl GhcPs) -> (HappyAbsSyn )-happyIn107 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap107 x)-{-# INLINE happyIn107 #-}-happyOut107 :: (HappyAbsSyn ) -> HappyWrap107-happyOut107 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut107 #-}-newtype HappyWrap108 = HappyWrap108 (LRoleAnnotDecl GhcPs)-happyIn108 :: (LRoleAnnotDecl GhcPs) -> (HappyAbsSyn )-happyIn108 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap108 x)-{-# INLINE happyIn108 #-}-happyOut108 :: (HappyAbsSyn ) -> HappyWrap108-happyOut108 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut108 #-}-newtype HappyWrap109 = HappyWrap109 (Located [Located (Maybe FastString)])-happyIn109 :: (Located [Located (Maybe FastString)]) -> (HappyAbsSyn )-happyIn109 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap109 x)-{-# INLINE happyIn109 #-}-happyOut109 :: (HappyAbsSyn ) -> HappyWrap109-happyOut109 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut109 #-}-newtype HappyWrap110 = HappyWrap110 (Located [Located (Maybe FastString)])-happyIn110 :: (Located [Located (Maybe FastString)]) -> (HappyAbsSyn )-happyIn110 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap110 x)-{-# INLINE happyIn110 #-}-happyOut110 :: (HappyAbsSyn ) -> HappyWrap110-happyOut110 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut110 #-}-newtype HappyWrap111 = HappyWrap111 (Located (Maybe FastString))-happyIn111 :: (Located (Maybe FastString)) -> (HappyAbsSyn )-happyIn111 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap111 x)-{-# INLINE happyIn111 #-}-happyOut111 :: (HappyAbsSyn ) -> HappyWrap111-happyOut111 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut111 #-}-newtype HappyWrap112 = HappyWrap112 (LHsDecl GhcPs)-happyIn112 :: (LHsDecl GhcPs) -> (HappyAbsSyn )-happyIn112 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap112 x)-{-# INLINE happyIn112 #-}-happyOut112 :: (HappyAbsSyn ) -> HappyWrap112-happyOut112 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut112 #-}-newtype HappyWrap113 = HappyWrap113 ((LocatedN RdrName, HsPatSynDetails GhcPs, [AddEpAnn]))-happyIn113 :: ((LocatedN RdrName, HsPatSynDetails GhcPs, [AddEpAnn])) -> (HappyAbsSyn )-happyIn113 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap113 x)-{-# INLINE happyIn113 #-}-happyOut113 :: (HappyAbsSyn ) -> HappyWrap113-happyOut113 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut113 #-}-newtype HappyWrap114 = HappyWrap114 ([LocatedN RdrName])-happyIn114 :: ([LocatedN RdrName]) -> (HappyAbsSyn )-happyIn114 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap114 x)-{-# INLINE happyIn114 #-}-happyOut114 :: (HappyAbsSyn ) -> HappyWrap114-happyOut114 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut114 #-}-newtype HappyWrap115 = HappyWrap115 ([RecordPatSynField GhcPs])-happyIn115 :: ([RecordPatSynField GhcPs]) -> (HappyAbsSyn )-happyIn115 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap115 x)-{-# INLINE happyIn115 #-}-happyOut115 :: (HappyAbsSyn ) -> HappyWrap115-happyOut115 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut115 #-}-newtype HappyWrap116 = HappyWrap116 (LocatedL (OrdList (LHsDecl GhcPs)))-happyIn116 :: (LocatedL (OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )-happyIn116 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap116 x)-{-# INLINE happyIn116 #-}-happyOut116 :: (HappyAbsSyn ) -> HappyWrap116-happyOut116 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut116 #-}-newtype HappyWrap117 = HappyWrap117 (LSig GhcPs)-happyIn117 :: (LSig GhcPs) -> (HappyAbsSyn )-happyIn117 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap117 x)-{-# INLINE happyIn117 #-}-happyOut117 :: (HappyAbsSyn ) -> HappyWrap117-happyOut117 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut117 #-}-newtype HappyWrap118 = HappyWrap118 (LocatedN RdrName)-happyIn118 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn118 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap118 x)-{-# INLINE happyIn118 #-}-happyOut118 :: (HappyAbsSyn ) -> HappyWrap118-happyOut118 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut118 #-}-newtype HappyWrap119 = HappyWrap119 (LHsDecl GhcPs)-happyIn119 :: (LHsDecl GhcPs) -> (HappyAbsSyn )-happyIn119 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap119 x)-{-# INLINE happyIn119 #-}-happyOut119 :: (HappyAbsSyn ) -> HappyWrap119-happyOut119 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut119 #-}-newtype HappyWrap120 = HappyWrap120 (Located ([AddEpAnn],OrdList (LHsDecl GhcPs)))-happyIn120 :: (Located ([AddEpAnn],OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )-happyIn120 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap120 x)-{-# INLINE happyIn120 #-}-happyOut120 :: (HappyAbsSyn ) -> HappyWrap120-happyOut120 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut120 #-}-newtype HappyWrap121 = HappyWrap121 (Located ([AddEpAnn]- , OrdList (LHsDecl GhcPs)- , LayoutInfo))-happyIn121 :: (Located ([AddEpAnn]- , OrdList (LHsDecl GhcPs)- , LayoutInfo)) -> (HappyAbsSyn )-happyIn121 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap121 x)-{-# INLINE happyIn121 #-}-happyOut121 :: (HappyAbsSyn ) -> HappyWrap121-happyOut121 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut121 #-}-newtype HappyWrap122 = HappyWrap122 (Located ([AddEpAnn]- ,(OrdList (LHsDecl GhcPs)) -- Reversed- ,LayoutInfo))-happyIn122 :: (Located ([AddEpAnn]- ,(OrdList (LHsDecl GhcPs)) -- Reversed- ,LayoutInfo)) -> (HappyAbsSyn )-happyIn122 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap122 x)-{-# INLINE happyIn122 #-}-happyOut122 :: (HappyAbsSyn ) -> HappyWrap122-happyOut122 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut122 #-}-newtype HappyWrap123 = HappyWrap123 (Located (OrdList (LHsDecl GhcPs)))-happyIn123 :: (Located (OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )-happyIn123 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap123 x)-{-# INLINE happyIn123 #-}-happyOut123 :: (HappyAbsSyn ) -> HappyWrap123-happyOut123 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut123 #-}-newtype HappyWrap124 = HappyWrap124 (Located ([AddEpAnn],OrdList (LHsDecl GhcPs)))-happyIn124 :: (Located ([AddEpAnn],OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )-happyIn124 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap124 x)-{-# INLINE happyIn124 #-}-happyOut124 :: (HappyAbsSyn ) -> HappyWrap124-happyOut124 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut124 #-}-newtype HappyWrap125 = HappyWrap125 (Located ([AddEpAnn]- , OrdList (LHsDecl GhcPs)))-happyIn125 :: (Located ([AddEpAnn]- , OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )-happyIn125 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap125 x)-{-# INLINE happyIn125 #-}-happyOut125 :: (HappyAbsSyn ) -> HappyWrap125-happyOut125 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut125 #-}-newtype HappyWrap126 = HappyWrap126 (Located ([AddEpAnn]- , OrdList (LHsDecl GhcPs)))-happyIn126 :: (Located ([AddEpAnn]- , OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )-happyIn126 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap126 x)-{-# INLINE happyIn126 #-}-happyOut126 :: (HappyAbsSyn ) -> HappyWrap126-happyOut126 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut126 #-}-newtype HappyWrap127 = HappyWrap127 (Located ([TrailingAnn], OrdList (LHsDecl GhcPs)))-happyIn127 :: (Located ([TrailingAnn], OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )-happyIn127 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap127 x)-{-# INLINE happyIn127 #-}-happyOut127 :: (HappyAbsSyn ) -> HappyWrap127-happyOut127 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut127 #-}-newtype HappyWrap128 = HappyWrap128 (Located (AnnList,Located (OrdList (LHsDecl GhcPs))))-happyIn128 :: (Located (AnnList,Located (OrdList (LHsDecl GhcPs)))) -> (HappyAbsSyn )-happyIn128 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap128 x)-{-# INLINE happyIn128 #-}-happyOut128 :: (HappyAbsSyn ) -> HappyWrap128-happyOut128 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut128 #-}-newtype HappyWrap129 = HappyWrap129 (Located (HsLocalBinds GhcPs))-happyIn129 :: (Located (HsLocalBinds GhcPs)) -> (HappyAbsSyn )-happyIn129 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap129 x)-{-# INLINE happyIn129 #-}-happyOut129 :: (HappyAbsSyn ) -> HappyWrap129-happyOut129 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut129 #-}-newtype HappyWrap130 = HappyWrap130 (Maybe (Located (HsLocalBinds GhcPs, Maybe EpAnnComments )))-happyIn130 :: (Maybe (Located (HsLocalBinds GhcPs, Maybe EpAnnComments ))) -> (HappyAbsSyn )-happyIn130 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap130 x)-{-# INLINE happyIn130 #-}-happyOut130 :: (HappyAbsSyn ) -> HappyWrap130-happyOut130 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut130 #-}-newtype HappyWrap131 = HappyWrap131 ([LRuleDecl GhcPs])-happyIn131 :: ([LRuleDecl GhcPs]) -> (HappyAbsSyn )-happyIn131 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap131 x)-{-# INLINE happyIn131 #-}-happyOut131 :: (HappyAbsSyn ) -> HappyWrap131-happyOut131 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut131 #-}-newtype HappyWrap132 = HappyWrap132 (LRuleDecl GhcPs)-happyIn132 :: (LRuleDecl GhcPs) -> (HappyAbsSyn )-happyIn132 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap132 x)-{-# INLINE happyIn132 #-}-happyOut132 :: (HappyAbsSyn ) -> HappyWrap132-happyOut132 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut132 #-}-newtype HappyWrap133 = HappyWrap133 (([AddEpAnn],Maybe Activation))-happyIn133 :: (([AddEpAnn],Maybe Activation)) -> (HappyAbsSyn )-happyIn133 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap133 x)-{-# INLINE happyIn133 #-}-happyOut133 :: (HappyAbsSyn ) -> HappyWrap133-happyOut133 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut133 #-}-newtype HappyWrap134 = HappyWrap134 ([AddEpAnn])-happyIn134 :: ([AddEpAnn]) -> (HappyAbsSyn )-happyIn134 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap134 x)-{-# INLINE happyIn134 #-}-happyOut134 :: (HappyAbsSyn ) -> HappyWrap134-happyOut134 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut134 #-}-newtype HappyWrap135 = HappyWrap135 (([AddEpAnn]- ,Activation))-happyIn135 :: (([AddEpAnn]- ,Activation)) -> (HappyAbsSyn )-happyIn135 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap135 x)-{-# INLINE happyIn135 #-}-happyOut135 :: (HappyAbsSyn ) -> HappyWrap135-happyOut135 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut135 #-}-newtype HappyWrap136 = HappyWrap136 (([AddEpAnn] -> HsRuleAnn, Maybe [LHsTyVarBndr () GhcPs], [LRuleBndr GhcPs]))-happyIn136 :: (([AddEpAnn] -> HsRuleAnn, Maybe [LHsTyVarBndr () GhcPs], [LRuleBndr GhcPs])) -> (HappyAbsSyn )-happyIn136 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap136 x)-{-# INLINE happyIn136 #-}-happyOut136 :: (HappyAbsSyn ) -> HappyWrap136-happyOut136 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut136 #-}-newtype HappyWrap137 = HappyWrap137 ([LRuleTyTmVar])-happyIn137 :: ([LRuleTyTmVar]) -> (HappyAbsSyn )-happyIn137 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap137 x)-{-# INLINE happyIn137 #-}-happyOut137 :: (HappyAbsSyn ) -> HappyWrap137-happyOut137 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut137 #-}-newtype HappyWrap138 = HappyWrap138 (LRuleTyTmVar)-happyIn138 :: (LRuleTyTmVar) -> (HappyAbsSyn )-happyIn138 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap138 x)-{-# INLINE happyIn138 #-}-happyOut138 :: (HappyAbsSyn ) -> HappyWrap138-happyOut138 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut138 #-}-newtype HappyWrap139 = HappyWrap139 (OrdList (LWarnDecl GhcPs))-happyIn139 :: (OrdList (LWarnDecl GhcPs)) -> (HappyAbsSyn )-happyIn139 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap139 x)-{-# INLINE happyIn139 #-}-happyOut139 :: (HappyAbsSyn ) -> HappyWrap139-happyOut139 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut139 #-}-newtype HappyWrap140 = HappyWrap140 (OrdList (LWarnDecl GhcPs))-happyIn140 :: (OrdList (LWarnDecl GhcPs)) -> (HappyAbsSyn )-happyIn140 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap140 x)-{-# INLINE happyIn140 #-}-happyOut140 :: (HappyAbsSyn ) -> HappyWrap140-happyOut140 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut140 #-}-newtype HappyWrap141 = HappyWrap141 (OrdList (LWarnDecl GhcPs))-happyIn141 :: (OrdList (LWarnDecl GhcPs)) -> (HappyAbsSyn )-happyIn141 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap141 x)-{-# INLINE happyIn141 #-}-happyOut141 :: (HappyAbsSyn ) -> HappyWrap141-happyOut141 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut141 #-}-newtype HappyWrap142 = HappyWrap142 (OrdList (LWarnDecl GhcPs))-happyIn142 :: (OrdList (LWarnDecl GhcPs)) -> (HappyAbsSyn )-happyIn142 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap142 x)-{-# INLINE happyIn142 #-}-happyOut142 :: (HappyAbsSyn ) -> HappyWrap142-happyOut142 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut142 #-}-newtype HappyWrap143 = HappyWrap143 (Located ([AddEpAnn],[Located StringLiteral]))-happyIn143 :: (Located ([AddEpAnn],[Located StringLiteral])) -> (HappyAbsSyn )-happyIn143 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap143 x)-{-# INLINE happyIn143 #-}-happyOut143 :: (HappyAbsSyn ) -> HappyWrap143-happyOut143 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut143 #-}-newtype HappyWrap144 = HappyWrap144 (Located (OrdList (Located StringLiteral)))-happyIn144 :: (Located (OrdList (Located StringLiteral))) -> (HappyAbsSyn )-happyIn144 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap144 x)-{-# INLINE happyIn144 #-}-happyOut144 :: (HappyAbsSyn ) -> HappyWrap144-happyOut144 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut144 #-}-newtype HappyWrap145 = HappyWrap145 (LHsDecl GhcPs)-happyIn145 :: (LHsDecl GhcPs) -> (HappyAbsSyn )-happyIn145 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap145 x)-{-# INLINE happyIn145 #-}-happyOut145 :: (HappyAbsSyn ) -> HappyWrap145-happyOut145 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut145 #-}-newtype HappyWrap146 = HappyWrap146 (Located ([AddEpAnn],EpAnn [AddEpAnn] -> HsDecl GhcPs))-happyIn146 :: (Located ([AddEpAnn],EpAnn [AddEpAnn] -> HsDecl GhcPs)) -> (HappyAbsSyn )-happyIn146 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap146 x)-{-# INLINE happyIn146 #-}-happyOut146 :: (HappyAbsSyn ) -> HappyWrap146-happyOut146 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut146 #-}-newtype HappyWrap147 = HappyWrap147 (Located CCallConv)-happyIn147 :: (Located CCallConv) -> (HappyAbsSyn )-happyIn147 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap147 x)-{-# INLINE happyIn147 #-}-happyOut147 :: (HappyAbsSyn ) -> HappyWrap147-happyOut147 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut147 #-}-newtype HappyWrap148 = HappyWrap148 (Located Safety)-happyIn148 :: (Located Safety) -> (HappyAbsSyn )-happyIn148 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap148 x)-{-# INLINE happyIn148 #-}-happyOut148 :: (HappyAbsSyn ) -> HappyWrap148-happyOut148 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut148 #-}-newtype HappyWrap149 = HappyWrap149 (Located ([AddEpAnn]- ,(Located StringLiteral, LocatedN RdrName, LHsSigType GhcPs)))-happyIn149 :: (Located ([AddEpAnn]- ,(Located StringLiteral, LocatedN RdrName, LHsSigType GhcPs))) -> (HappyAbsSyn )-happyIn149 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap149 x)-{-# INLINE happyIn149 #-}-happyOut149 :: (HappyAbsSyn ) -> HappyWrap149-happyOut149 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut149 #-}-newtype HappyWrap150 = HappyWrap150 (Maybe (AddEpAnn, LHsType GhcPs))-happyIn150 :: (Maybe (AddEpAnn, LHsType GhcPs)) -> (HappyAbsSyn )-happyIn150 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap150 x)-{-# INLINE happyIn150 #-}-happyOut150 :: (HappyAbsSyn ) -> HappyWrap150-happyOut150 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut150 #-}-newtype HappyWrap151 = HappyWrap151 (([AddEpAnn], Maybe (LocatedN RdrName)))-happyIn151 :: (([AddEpAnn], Maybe (LocatedN RdrName))) -> (HappyAbsSyn )-happyIn151 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap151 x)-{-# INLINE happyIn151 #-}-happyOut151 :: (HappyAbsSyn ) -> HappyWrap151-happyOut151 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut151 #-}-newtype HappyWrap152 = HappyWrap152 (LHsSigType GhcPs)-happyIn152 :: (LHsSigType GhcPs) -> (HappyAbsSyn )-happyIn152 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap152 x)-{-# INLINE happyIn152 #-}-happyOut152 :: (HappyAbsSyn ) -> HappyWrap152-happyOut152 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut152 #-}-newtype HappyWrap153 = HappyWrap153 (LHsSigType GhcPs)-happyIn153 :: (LHsSigType GhcPs) -> (HappyAbsSyn )-happyIn153 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap153 x)-{-# INLINE happyIn153 #-}-happyOut153 :: (HappyAbsSyn ) -> HappyWrap153-happyOut153 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut153 #-}-newtype HappyWrap154 = HappyWrap154 (Located [LocatedN RdrName])-happyIn154 :: (Located [LocatedN RdrName]) -> (HappyAbsSyn )-happyIn154 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap154 x)-{-# INLINE happyIn154 #-}-happyOut154 :: (HappyAbsSyn ) -> HappyWrap154-happyOut154 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut154 #-}-newtype HappyWrap155 = HappyWrap155 (OrdList (LHsSigType GhcPs))-happyIn155 :: (OrdList (LHsSigType GhcPs)) -> (HappyAbsSyn )-happyIn155 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap155 x)-{-# INLINE happyIn155 #-}-happyOut155 :: (HappyAbsSyn ) -> HappyWrap155-happyOut155 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut155 #-}-newtype HappyWrap156 = HappyWrap156 (Located UnpackednessPragma)-happyIn156 :: (Located UnpackednessPragma) -> (HappyAbsSyn )-happyIn156 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap156 x)-{-# INLINE happyIn156 #-}-happyOut156 :: (HappyAbsSyn ) -> HappyWrap156-happyOut156 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut156 #-}-newtype HappyWrap157 = HappyWrap157 (Located (HsForAllTelescope GhcPs))-happyIn157 :: (Located (HsForAllTelescope GhcPs)) -> (HappyAbsSyn )-happyIn157 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap157 x)-{-# INLINE happyIn157 #-}-happyOut157 :: (HappyAbsSyn ) -> HappyWrap157-happyOut157 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut157 #-}-newtype HappyWrap158 = HappyWrap158 (LHsType GhcPs)-happyIn158 :: (LHsType GhcPs) -> (HappyAbsSyn )-happyIn158 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap158 x)-{-# INLINE happyIn158 #-}-happyOut158 :: (HappyAbsSyn ) -> HappyWrap158-happyOut158 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut158 #-}-newtype HappyWrap159 = HappyWrap159 (LHsType GhcPs)-happyIn159 :: (LHsType GhcPs) -> (HappyAbsSyn )-happyIn159 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap159 x)-{-# INLINE happyIn159 #-}-happyOut159 :: (HappyAbsSyn ) -> HappyWrap159-happyOut159 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut159 #-}-newtype HappyWrap160 = HappyWrap160 (LHsContext GhcPs)-happyIn160 :: (LHsContext GhcPs) -> (HappyAbsSyn )-happyIn160 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap160 x)-{-# INLINE happyIn160 #-}-happyOut160 :: (HappyAbsSyn ) -> HappyWrap160-happyOut160 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut160 #-}-newtype HappyWrap161 = HappyWrap161 (LHsType GhcPs)-happyIn161 :: (LHsType GhcPs) -> (HappyAbsSyn )-happyIn161 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap161 x)-{-# INLINE happyIn161 #-}-happyOut161 :: (HappyAbsSyn ) -> HappyWrap161-happyOut161 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut161 #-}-newtype HappyWrap162 = HappyWrap162 (Located (IsUnicodeSyntax -> HsArrow GhcPs))-happyIn162 :: (Located (IsUnicodeSyntax -> HsArrow GhcPs)) -> (HappyAbsSyn )-happyIn162 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap162 x)-{-# INLINE happyIn162 #-}-happyOut162 :: (HappyAbsSyn ) -> HappyWrap162-happyOut162 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut162 #-}-newtype HappyWrap163 = HappyWrap163 (LHsType GhcPs)-happyIn163 :: (LHsType GhcPs) -> (HappyAbsSyn )-happyIn163 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap163 x)-{-# INLINE happyIn163 #-}-happyOut163 :: (HappyAbsSyn ) -> HappyWrap163-happyOut163 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut163 #-}-newtype HappyWrap164 = HappyWrap164 (forall b. DisambTD b => PV (LocatedA b))-happyIn164 :: (forall b. DisambTD b => PV (LocatedA b)) -> (HappyAbsSyn )-happyIn164 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap164 x)-{-# INLINE happyIn164 #-}-happyOut164 :: (HappyAbsSyn ) -> HappyWrap164-happyOut164 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut164 #-}-newtype HappyWrap165 = HappyWrap165 (forall b. DisambTD b => PV (LocatedA b))-happyIn165 :: (forall b. DisambTD b => PV (LocatedA b)) -> (HappyAbsSyn )-happyIn165 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap165 x)-{-# INLINE happyIn165 #-}-happyOut165 :: (HappyAbsSyn ) -> HappyWrap165-happyOut165 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut165 #-}-newtype HappyWrap166 = HappyWrap166 (LHsType GhcPs)-happyIn166 :: (LHsType GhcPs) -> (HappyAbsSyn )-happyIn166 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap166 x)-{-# INLINE happyIn166 #-}-happyOut166 :: (HappyAbsSyn ) -> HappyWrap166-happyOut166 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut166 #-}-newtype HappyWrap167 = HappyWrap167 (LocatedN RdrName)-happyIn167 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn167 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap167 x)-{-# INLINE happyIn167 #-}-happyOut167 :: (HappyAbsSyn ) -> HappyWrap167-happyOut167 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut167 #-}-newtype HappyWrap168 = HappyWrap168 (LHsType GhcPs)-happyIn168 :: (LHsType GhcPs) -> (HappyAbsSyn )-happyIn168 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap168 x)-{-# INLINE happyIn168 #-}-happyOut168 :: (HappyAbsSyn ) -> HappyWrap168-happyOut168 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut168 #-}-newtype HappyWrap169 = HappyWrap169 (LHsSigType GhcPs)-happyIn169 :: (LHsSigType GhcPs) -> (HappyAbsSyn )-happyIn169 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap169 x)-{-# INLINE happyIn169 #-}-happyOut169 :: (HappyAbsSyn ) -> HappyWrap169-happyOut169 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut169 #-}-newtype HappyWrap170 = HappyWrap170 ([LHsSigType GhcPs])-happyIn170 :: ([LHsSigType GhcPs]) -> (HappyAbsSyn )-happyIn170 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap170 x)-{-# INLINE happyIn170 #-}-happyOut170 :: (HappyAbsSyn ) -> HappyWrap170-happyOut170 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut170 #-}-newtype HappyWrap171 = HappyWrap171 ([LHsType GhcPs])-happyIn171 :: ([LHsType GhcPs]) -> (HappyAbsSyn )-happyIn171 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap171 x)-{-# INLINE happyIn171 #-}-happyOut171 :: (HappyAbsSyn ) -> HappyWrap171-happyOut171 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut171 #-}-newtype HappyWrap172 = HappyWrap172 ([LHsType GhcPs])-happyIn172 :: ([LHsType GhcPs]) -> (HappyAbsSyn )-happyIn172 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap172 x)-{-# INLINE happyIn172 #-}-happyOut172 :: (HappyAbsSyn ) -> HappyWrap172-happyOut172 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut172 #-}-newtype HappyWrap173 = HappyWrap173 ([LHsType GhcPs])-happyIn173 :: ([LHsType GhcPs]) -> (HappyAbsSyn )-happyIn173 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap173 x)-{-# INLINE happyIn173 #-}-happyOut173 :: (HappyAbsSyn ) -> HappyWrap173-happyOut173 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut173 #-}-newtype HappyWrap174 = HappyWrap174 ([LHsTyVarBndr Specificity GhcPs])-happyIn174 :: ([LHsTyVarBndr Specificity GhcPs]) -> (HappyAbsSyn )-happyIn174 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap174 x)-{-# INLINE happyIn174 #-}-happyOut174 :: (HappyAbsSyn ) -> HappyWrap174-happyOut174 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut174 #-}-newtype HappyWrap175 = HappyWrap175 (LHsTyVarBndr Specificity GhcPs)-happyIn175 :: (LHsTyVarBndr Specificity GhcPs) -> (HappyAbsSyn )-happyIn175 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap175 x)-{-# INLINE happyIn175 #-}-happyOut175 :: (HappyAbsSyn ) -> HappyWrap175-happyOut175 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut175 #-}-newtype HappyWrap176 = HappyWrap176 (LHsTyVarBndr Specificity GhcPs)-happyIn176 :: (LHsTyVarBndr Specificity GhcPs) -> (HappyAbsSyn )-happyIn176 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap176 x)-{-# INLINE happyIn176 #-}-happyOut176 :: (HappyAbsSyn ) -> HappyWrap176-happyOut176 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut176 #-}-newtype HappyWrap177 = HappyWrap177 (Located ([AddEpAnn],[LHsFunDep GhcPs]))-happyIn177 :: (Located ([AddEpAnn],[LHsFunDep GhcPs])) -> (HappyAbsSyn )-happyIn177 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap177 x)-{-# INLINE happyIn177 #-}-happyOut177 :: (HappyAbsSyn ) -> HappyWrap177-happyOut177 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut177 #-}-newtype HappyWrap178 = HappyWrap178 (Located [LHsFunDep GhcPs])-happyIn178 :: (Located [LHsFunDep GhcPs]) -> (HappyAbsSyn )-happyIn178 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap178 x)-{-# INLINE happyIn178 #-}-happyOut178 :: (HappyAbsSyn ) -> HappyWrap178-happyOut178 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut178 #-}-newtype HappyWrap179 = HappyWrap179 (LHsFunDep GhcPs)-happyIn179 :: (LHsFunDep GhcPs) -> (HappyAbsSyn )-happyIn179 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap179 x)-{-# INLINE happyIn179 #-}-happyOut179 :: (HappyAbsSyn ) -> HappyWrap179-happyOut179 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut179 #-}-newtype HappyWrap180 = HappyWrap180 (Located [LocatedN RdrName])-happyIn180 :: (Located [LocatedN RdrName]) -> (HappyAbsSyn )-happyIn180 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap180 x)-{-# INLINE happyIn180 #-}-happyOut180 :: (HappyAbsSyn ) -> HappyWrap180-happyOut180 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut180 #-}-newtype HappyWrap181 = HappyWrap181 (LHsKind GhcPs)-happyIn181 :: (LHsKind GhcPs) -> (HappyAbsSyn )-happyIn181 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap181 x)-{-# INLINE happyIn181 #-}-happyOut181 :: (HappyAbsSyn ) -> HappyWrap181-happyOut181 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut181 #-}-newtype HappyWrap182 = HappyWrap182 (Located ([AddEpAnn]- ,[LConDecl GhcPs]))-happyIn182 :: (Located ([AddEpAnn]- ,[LConDecl GhcPs])) -> (HappyAbsSyn )-happyIn182 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap182 x)-{-# INLINE happyIn182 #-}-happyOut182 :: (HappyAbsSyn ) -> HappyWrap182-happyOut182 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut182 #-}-newtype HappyWrap183 = HappyWrap183 (Located [LConDecl GhcPs])-happyIn183 :: (Located [LConDecl GhcPs]) -> (HappyAbsSyn )-happyIn183 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap183 x)-{-# INLINE happyIn183 #-}-happyOut183 :: (HappyAbsSyn ) -> HappyWrap183-happyOut183 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut183 #-}-newtype HappyWrap184 = HappyWrap184 (LConDecl GhcPs)-happyIn184 :: (LConDecl GhcPs) -> (HappyAbsSyn )-happyIn184 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap184 x)-{-# INLINE happyIn184 #-}-happyOut184 :: (HappyAbsSyn ) -> HappyWrap184-happyOut184 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut184 #-}-newtype HappyWrap185 = HappyWrap185 (Located ([AddEpAnn],[LConDecl GhcPs]))-happyIn185 :: (Located ([AddEpAnn],[LConDecl GhcPs])) -> (HappyAbsSyn )-happyIn185 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap185 x)-{-# INLINE happyIn185 #-}-happyOut185 :: (HappyAbsSyn ) -> HappyWrap185-happyOut185 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut185 #-}-newtype HappyWrap186 = HappyWrap186 (Located [LConDecl GhcPs])-happyIn186 :: (Located [LConDecl GhcPs]) -> (HappyAbsSyn )-happyIn186 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap186 x)-{-# INLINE happyIn186 #-}-happyOut186 :: (HappyAbsSyn ) -> HappyWrap186-happyOut186 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut186 #-}-newtype HappyWrap187 = HappyWrap187 (LConDecl GhcPs)-happyIn187 :: (LConDecl GhcPs) -> (HappyAbsSyn )-happyIn187 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap187 x)-{-# INLINE happyIn187 #-}-happyOut187 :: (HappyAbsSyn ) -> HappyWrap187-happyOut187 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut187 #-}-newtype HappyWrap188 = HappyWrap188 (Located ([AddEpAnn], Maybe [LHsTyVarBndr Specificity GhcPs]))-happyIn188 :: (Located ([AddEpAnn], Maybe [LHsTyVarBndr Specificity GhcPs])) -> (HappyAbsSyn )-happyIn188 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap188 x)-{-# INLINE happyIn188 #-}-happyOut188 :: (HappyAbsSyn ) -> HappyWrap188-happyOut188 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut188 #-}-newtype HappyWrap189 = HappyWrap189 (Located (LocatedN RdrName, HsConDeclH98Details GhcPs))-happyIn189 :: (Located (LocatedN RdrName, HsConDeclH98Details GhcPs)) -> (HappyAbsSyn )-happyIn189 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap189 x)-{-# INLINE happyIn189 #-}-happyOut189 :: (HappyAbsSyn ) -> HappyWrap189-happyOut189 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut189 #-}-newtype HappyWrap190 = HappyWrap190 ([LConDeclField GhcPs])-happyIn190 :: ([LConDeclField GhcPs]) -> (HappyAbsSyn )-happyIn190 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap190 x)-{-# INLINE happyIn190 #-}-happyOut190 :: (HappyAbsSyn ) -> HappyWrap190-happyOut190 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut190 #-}-newtype HappyWrap191 = HappyWrap191 ([LConDeclField GhcPs])-happyIn191 :: ([LConDeclField GhcPs]) -> (HappyAbsSyn )-happyIn191 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap191 x)-{-# INLINE happyIn191 #-}-happyOut191 :: (HappyAbsSyn ) -> HappyWrap191-happyOut191 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut191 #-}-newtype HappyWrap192 = HappyWrap192 (LConDeclField GhcPs)-happyIn192 :: (LConDeclField GhcPs) -> (HappyAbsSyn )-happyIn192 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap192 x)-{-# INLINE happyIn192 #-}-happyOut192 :: (HappyAbsSyn ) -> HappyWrap192-happyOut192 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut192 #-}-newtype HappyWrap193 = HappyWrap193 (Located (HsDeriving GhcPs))-happyIn193 :: (Located (HsDeriving GhcPs)) -> (HappyAbsSyn )-happyIn193 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap193 x)-{-# INLINE happyIn193 #-}-happyOut193 :: (HappyAbsSyn ) -> HappyWrap193-happyOut193 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut193 #-}-newtype HappyWrap194 = HappyWrap194 (Located (HsDeriving GhcPs))-happyIn194 :: (Located (HsDeriving GhcPs)) -> (HappyAbsSyn )-happyIn194 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap194 x)-{-# INLINE happyIn194 #-}-happyOut194 :: (HappyAbsSyn ) -> HappyWrap194-happyOut194 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut194 #-}-newtype HappyWrap195 = HappyWrap195 (LHsDerivingClause GhcPs)-happyIn195 :: (LHsDerivingClause GhcPs) -> (HappyAbsSyn )-happyIn195 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap195 x)-{-# INLINE happyIn195 #-}-happyOut195 :: (HappyAbsSyn ) -> HappyWrap195-happyOut195 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut195 #-}-newtype HappyWrap196 = HappyWrap196 (LDerivClauseTys GhcPs)-happyIn196 :: (LDerivClauseTys GhcPs) -> (HappyAbsSyn )-happyIn196 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap196 x)-{-# INLINE happyIn196 #-}-happyOut196 :: (HappyAbsSyn ) -> HappyWrap196-happyOut196 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut196 #-}-newtype HappyWrap197 = HappyWrap197 (LHsDecl GhcPs)-happyIn197 :: (LHsDecl GhcPs) -> (HappyAbsSyn )-happyIn197 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap197 x)-{-# INLINE happyIn197 #-}-happyOut197 :: (HappyAbsSyn ) -> HappyWrap197-happyOut197 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut197 #-}-newtype HappyWrap198 = HappyWrap198 (LHsDecl GhcPs)-happyIn198 :: (LHsDecl GhcPs) -> (HappyAbsSyn )-happyIn198 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap198 x)-{-# INLINE happyIn198 #-}-happyOut198 :: (HappyAbsSyn ) -> HappyWrap198-happyOut198 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut198 #-}-newtype HappyWrap199 = HappyWrap199 (Located (GRHSs GhcPs (LHsExpr GhcPs)))-happyIn199 :: (Located (GRHSs GhcPs (LHsExpr GhcPs))) -> (HappyAbsSyn )-happyIn199 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap199 x)-{-# INLINE happyIn199 #-}-happyOut199 :: (HappyAbsSyn ) -> HappyWrap199-happyOut199 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut199 #-}-newtype HappyWrap200 = HappyWrap200 (Located [LGRHS GhcPs (LHsExpr GhcPs)])-happyIn200 :: (Located [LGRHS GhcPs (LHsExpr GhcPs)]) -> (HappyAbsSyn )-happyIn200 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap200 x)-{-# INLINE happyIn200 #-}-happyOut200 :: (HappyAbsSyn ) -> HappyWrap200-happyOut200 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut200 #-}-newtype HappyWrap201 = HappyWrap201 (LGRHS GhcPs (LHsExpr GhcPs))-happyIn201 :: (LGRHS GhcPs (LHsExpr GhcPs)) -> (HappyAbsSyn )-happyIn201 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap201 x)-{-# INLINE happyIn201 #-}-happyOut201 :: (HappyAbsSyn ) -> HappyWrap201-happyOut201 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut201 #-}-newtype HappyWrap202 = HappyWrap202 (LHsDecl GhcPs)-happyIn202 :: (LHsDecl GhcPs) -> (HappyAbsSyn )-happyIn202 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap202 x)-{-# INLINE happyIn202 #-}-happyOut202 :: (HappyAbsSyn ) -> HappyWrap202-happyOut202 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut202 #-}-newtype HappyWrap203 = HappyWrap203 (([AddEpAnn],Maybe Activation))-happyIn203 :: (([AddEpAnn],Maybe Activation)) -> (HappyAbsSyn )-happyIn203 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap203 x)-{-# INLINE happyIn203 #-}-happyOut203 :: (HappyAbsSyn ) -> HappyWrap203-happyOut203 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut203 #-}-newtype HappyWrap204 = HappyWrap204 (([AddEpAnn],Activation))-happyIn204 :: (([AddEpAnn],Activation)) -> (HappyAbsSyn )-happyIn204 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap204 x)-{-# INLINE happyIn204 #-}-happyOut204 :: (HappyAbsSyn ) -> HappyWrap204-happyOut204 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut204 #-}-newtype HappyWrap205 = HappyWrap205 (Located (HsSplice GhcPs))-happyIn205 :: (Located (HsSplice GhcPs)) -> (HappyAbsSyn )-happyIn205 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap205 x)-{-# INLINE happyIn205 #-}-happyOut205 :: (HappyAbsSyn ) -> HappyWrap205-happyOut205 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut205 #-}-newtype HappyWrap206 = HappyWrap206 (ECP)-happyIn206 :: (ECP) -> (HappyAbsSyn )-happyIn206 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap206 x)-{-# INLINE happyIn206 #-}-happyOut206 :: (HappyAbsSyn ) -> HappyWrap206-happyOut206 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut206 #-}-newtype HappyWrap207 = HappyWrap207 (ECP)-happyIn207 :: (ECP) -> (HappyAbsSyn )-happyIn207 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap207 x)-{-# INLINE happyIn207 #-}-happyOut207 :: (HappyAbsSyn ) -> HappyWrap207-happyOut207 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut207 #-}-newtype HappyWrap208 = HappyWrap208 (ECP)-happyIn208 :: (ECP) -> (HappyAbsSyn )-happyIn208 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap208 x)-{-# INLINE happyIn208 #-}-happyOut208 :: (HappyAbsSyn ) -> HappyWrap208-happyOut208 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut208 #-}-newtype HappyWrap209 = HappyWrap209 (ECP)-happyIn209 :: (ECP) -> (HappyAbsSyn )-happyIn209 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap209 x)-{-# INLINE happyIn209 #-}-happyOut209 :: (HappyAbsSyn ) -> HappyWrap209-happyOut209 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut209 #-}-newtype HappyWrap210 = HappyWrap210 ((Maybe EpaLocation,Bool))-happyIn210 :: ((Maybe EpaLocation,Bool)) -> (HappyAbsSyn )-happyIn210 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap210 x)-{-# INLINE happyIn210 #-}-happyOut210 :: (HappyAbsSyn ) -> HappyWrap210-happyOut210 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut210 #-}-newtype HappyWrap211 = HappyWrap211 (Located (HsPragE GhcPs))-happyIn211 :: (Located (HsPragE GhcPs)) -> (HappyAbsSyn )-happyIn211 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap211 x)-{-# INLINE happyIn211 #-}-happyOut211 :: (HappyAbsSyn ) -> HappyWrap211-happyOut211 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut211 #-}-newtype HappyWrap212 = HappyWrap212 (ECP)-happyIn212 :: (ECP) -> (HappyAbsSyn )-happyIn212 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap212 x)-{-# INLINE happyIn212 #-}-happyOut212 :: (HappyAbsSyn ) -> HappyWrap212-happyOut212 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut212 #-}-newtype HappyWrap213 = HappyWrap213 (ECP)-happyIn213 :: (ECP) -> (HappyAbsSyn )-happyIn213 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap213 x)-{-# INLINE happyIn213 #-}-happyOut213 :: (HappyAbsSyn ) -> HappyWrap213-happyOut213 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut213 #-}-newtype HappyWrap214 = HappyWrap214 (ECP)-happyIn214 :: (ECP) -> (HappyAbsSyn )-happyIn214 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap214 x)-{-# INLINE happyIn214 #-}-happyOut214 :: (HappyAbsSyn ) -> HappyWrap214-happyOut214 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut214 #-}-newtype HappyWrap215 = HappyWrap215 (ECP)-happyIn215 :: (ECP) -> (HappyAbsSyn )-happyIn215 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap215 x)-{-# INLINE happyIn215 #-}-happyOut215 :: (HappyAbsSyn ) -> HappyWrap215-happyOut215 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut215 #-}-newtype HappyWrap216 = HappyWrap216 (Located (NonEmpty (Located (HsFieldLabel GhcPs))))-happyIn216 :: (Located (NonEmpty (Located (HsFieldLabel GhcPs)))) -> (HappyAbsSyn )-happyIn216 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap216 x)-{-# INLINE happyIn216 #-}-happyOut216 :: (HappyAbsSyn ) -> HappyWrap216-happyOut216 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut216 #-}-newtype HappyWrap217 = HappyWrap217 (LHsExpr GhcPs)-happyIn217 :: (LHsExpr GhcPs) -> (HappyAbsSyn )-happyIn217 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap217 x)-{-# INLINE happyIn217 #-}-happyOut217 :: (HappyAbsSyn ) -> HappyWrap217-happyOut217 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut217 #-}-newtype HappyWrap218 = HappyWrap218 (Located (HsSplice GhcPs))-happyIn218 :: (Located (HsSplice GhcPs)) -> (HappyAbsSyn )-happyIn218 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap218 x)-{-# INLINE happyIn218 #-}-happyOut218 :: (HappyAbsSyn ) -> HappyWrap218-happyOut218 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut218 #-}-newtype HappyWrap219 = HappyWrap219 (Located (HsSplice GhcPs))-happyIn219 :: (Located (HsSplice GhcPs)) -> (HappyAbsSyn )-happyIn219 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap219 x)-{-# INLINE happyIn219 #-}-happyOut219 :: (HappyAbsSyn ) -> HappyWrap219-happyOut219 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut219 #-}-newtype HappyWrap220 = HappyWrap220 ([LHsCmdTop GhcPs])-happyIn220 :: ([LHsCmdTop GhcPs]) -> (HappyAbsSyn )-happyIn220 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap220 x)-{-# INLINE happyIn220 #-}-happyOut220 :: (HappyAbsSyn ) -> HappyWrap220-happyOut220 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut220 #-}-newtype HappyWrap221 = HappyWrap221 (LHsCmdTop GhcPs)-happyIn221 :: (LHsCmdTop GhcPs) -> (HappyAbsSyn )-happyIn221 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap221 x)-{-# INLINE happyIn221 #-}-happyOut221 :: (HappyAbsSyn ) -> HappyWrap221-happyOut221 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut221 #-}-newtype HappyWrap222 = HappyWrap222 (([AddEpAnn],[LHsDecl GhcPs]))-happyIn222 :: (([AddEpAnn],[LHsDecl GhcPs])) -> (HappyAbsSyn )-happyIn222 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap222 x)-{-# INLINE happyIn222 #-}-happyOut222 :: (HappyAbsSyn ) -> HappyWrap222-happyOut222 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut222 #-}-newtype HappyWrap223 = HappyWrap223 ([LHsDecl GhcPs])-happyIn223 :: ([LHsDecl GhcPs]) -> (HappyAbsSyn )-happyIn223 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap223 x)-{-# INLINE happyIn223 #-}-happyOut223 :: (HappyAbsSyn ) -> HappyWrap223-happyOut223 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut223 #-}-newtype HappyWrap224 = HappyWrap224 (ECP)-happyIn224 :: (ECP) -> (HappyAbsSyn )-happyIn224 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap224 x)-{-# INLINE happyIn224 #-}-happyOut224 :: (HappyAbsSyn ) -> HappyWrap224-happyOut224 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut224 #-}-newtype HappyWrap225 = HappyWrap225 (forall b. DisambECP b => PV (SumOrTuple b))-happyIn225 :: (forall b. DisambECP b => PV (SumOrTuple b)) -> (HappyAbsSyn )-happyIn225 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap225 x)-{-# INLINE happyIn225 #-}-happyOut225 :: (HappyAbsSyn ) -> HappyWrap225-happyOut225 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut225 #-}-newtype HappyWrap226 = HappyWrap226 (forall b. DisambECP b => PV (SrcSpan,[Either (EpAnn EpaLocation) (LocatedA b)]))-happyIn226 :: (forall b. DisambECP b => PV (SrcSpan,[Either (EpAnn EpaLocation) (LocatedA b)])) -> (HappyAbsSyn )-happyIn226 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap226 x)-{-# INLINE happyIn226 #-}-happyOut226 :: (HappyAbsSyn ) -> HappyWrap226-happyOut226 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut226 #-}-newtype HappyWrap227 = HappyWrap227 (forall b. DisambECP b => PV [Either (EpAnn EpaLocation) (LocatedA b)])-happyIn227 :: (forall b. DisambECP b => PV [Either (EpAnn EpaLocation) (LocatedA b)]) -> (HappyAbsSyn )-happyIn227 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap227 x)-{-# INLINE happyIn227 #-}-happyOut227 :: (HappyAbsSyn ) -> HappyWrap227-happyOut227 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut227 #-}-newtype HappyWrap228 = HappyWrap228 (forall b. DisambECP b => SrcSpan -> (AddEpAnn, AddEpAnn) -> PV (LocatedA b))-happyIn228 :: (forall b. DisambECP b => SrcSpan -> (AddEpAnn, AddEpAnn) -> PV (LocatedA b)) -> (HappyAbsSyn )-happyIn228 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap228 x)-{-# INLINE happyIn228 #-}-happyOut228 :: (HappyAbsSyn ) -> HappyWrap228-happyOut228 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut228 #-}-newtype HappyWrap229 = HappyWrap229 (forall b. DisambECP b => PV [LocatedA b])-happyIn229 :: (forall b. DisambECP b => PV [LocatedA b]) -> (HappyAbsSyn )-happyIn229 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap229 x)-{-# INLINE happyIn229 #-}-happyOut229 :: (HappyAbsSyn ) -> HappyWrap229-happyOut229 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut229 #-}-newtype HappyWrap230 = HappyWrap230 (Located [LStmt GhcPs (LHsExpr GhcPs)])-happyIn230 :: (Located [LStmt GhcPs (LHsExpr GhcPs)]) -> (HappyAbsSyn )-happyIn230 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap230 x)-{-# INLINE happyIn230 #-}-happyOut230 :: (HappyAbsSyn ) -> HappyWrap230-happyOut230 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut230 #-}-newtype HappyWrap231 = HappyWrap231 (Located [[LStmt GhcPs (LHsExpr GhcPs)]])-happyIn231 :: (Located [[LStmt GhcPs (LHsExpr GhcPs)]]) -> (HappyAbsSyn )-happyIn231 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap231 x)-{-# INLINE happyIn231 #-}-happyOut231 :: (HappyAbsSyn ) -> HappyWrap231-happyOut231 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut231 #-}-newtype HappyWrap232 = HappyWrap232 (Located [LStmt GhcPs (LHsExpr GhcPs)])-happyIn232 :: (Located [LStmt GhcPs (LHsExpr GhcPs)]) -> (HappyAbsSyn )-happyIn232 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap232 x)-{-# INLINE happyIn232 #-}-happyOut232 :: (HappyAbsSyn ) -> HappyWrap232-happyOut232 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut232 #-}-newtype HappyWrap233 = HappyWrap233 (Located (RealSrcSpan -> [LStmt GhcPs (LHsExpr GhcPs)] -> Stmt GhcPs (LHsExpr GhcPs)))-happyIn233 :: (Located (RealSrcSpan -> [LStmt GhcPs (LHsExpr GhcPs)] -> Stmt GhcPs (LHsExpr GhcPs))) -> (HappyAbsSyn )-happyIn233 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap233 x)-{-# INLINE happyIn233 #-}-happyOut233 :: (HappyAbsSyn ) -> HappyWrap233-happyOut233 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut233 #-}-newtype HappyWrap234 = HappyWrap234 (Located [LStmt GhcPs (LHsExpr GhcPs)])-happyIn234 :: (Located [LStmt GhcPs (LHsExpr GhcPs)]) -> (HappyAbsSyn )-happyIn234 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap234 x)-{-# INLINE happyIn234 #-}-happyOut234 :: (HappyAbsSyn ) -> HappyWrap234-happyOut234 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut234 #-}-newtype HappyWrap235 = HappyWrap235 (Located [LStmt GhcPs (LHsExpr GhcPs)])-happyIn235 :: (Located [LStmt GhcPs (LHsExpr GhcPs)]) -> (HappyAbsSyn )-happyIn235 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap235 x)-{-# INLINE happyIn235 #-}-happyOut235 :: (HappyAbsSyn ) -> HappyWrap235-happyOut235 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut235 #-}-newtype HappyWrap236 = HappyWrap236 (forall b. DisambECP b => PV (LocatedL [LMatch GhcPs (LocatedA b)]))-happyIn236 :: (forall b. DisambECP b => PV (LocatedL [LMatch GhcPs (LocatedA b)])) -> (HappyAbsSyn )-happyIn236 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap236 x)-{-# INLINE happyIn236 #-}-happyOut236 :: (HappyAbsSyn ) -> HappyWrap236-happyOut236 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut236 #-}-newtype HappyWrap237 = HappyWrap237 (forall b. DisambECP b => PV (Located ([AddEpAnn],[LMatch GhcPs (LocatedA b)])))-happyIn237 :: (forall b. DisambECP b => PV (Located ([AddEpAnn],[LMatch GhcPs (LocatedA b)]))) -> (HappyAbsSyn )-happyIn237 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap237 x)-{-# INLINE happyIn237 #-}-happyOut237 :: (HappyAbsSyn ) -> HappyWrap237-happyOut237 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut237 #-}-newtype HappyWrap238 = HappyWrap238 (forall b. DisambECP b => PV (Located ([AddEpAnn],[LMatch GhcPs (LocatedA b)])))-happyIn238 :: (forall b. DisambECP b => PV (Located ([AddEpAnn],[LMatch GhcPs (LocatedA b)]))) -> (HappyAbsSyn )-happyIn238 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap238 x)-{-# INLINE happyIn238 #-}-happyOut238 :: (HappyAbsSyn ) -> HappyWrap238-happyOut238 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut238 #-}-newtype HappyWrap239 = HappyWrap239 (forall b. DisambECP b => PV (LMatch GhcPs (LocatedA b)))-happyIn239 :: (forall b. DisambECP b => PV (LMatch GhcPs (LocatedA b))) -> (HappyAbsSyn )-happyIn239 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap239 x)-{-# INLINE happyIn239 #-}-happyOut239 :: (HappyAbsSyn ) -> HappyWrap239-happyOut239 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut239 #-}-newtype HappyWrap240 = HappyWrap240 (forall b. DisambECP b => PV (Located (GRHSs GhcPs (LocatedA b))))-happyIn240 :: (forall b. DisambECP b => PV (Located (GRHSs GhcPs (LocatedA b)))) -> (HappyAbsSyn )-happyIn240 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap240 x)-{-# INLINE happyIn240 #-}-happyOut240 :: (HappyAbsSyn ) -> HappyWrap240-happyOut240 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut240 #-}-newtype HappyWrap241 = HappyWrap241 (forall b. DisambECP b => PV (Located [LGRHS GhcPs (LocatedA b)]))-happyIn241 :: (forall b. DisambECP b => PV (Located [LGRHS GhcPs (LocatedA b)])) -> (HappyAbsSyn )-happyIn241 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap241 x)-{-# INLINE happyIn241 #-}-happyOut241 :: (HappyAbsSyn ) -> HappyWrap241-happyOut241 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut241 #-}-newtype HappyWrap242 = HappyWrap242 (forall b. DisambECP b => PV (Located [LGRHS GhcPs (LocatedA b)]))-happyIn242 :: (forall b. DisambECP b => PV (Located [LGRHS GhcPs (LocatedA b)])) -> (HappyAbsSyn )-happyIn242 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap242 x)-{-# INLINE happyIn242 #-}-happyOut242 :: (HappyAbsSyn ) -> HappyWrap242-happyOut242 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut242 #-}-newtype HappyWrap243 = HappyWrap243 (Located ([AddEpAnn],[LGRHS GhcPs (LHsExpr GhcPs)]))-happyIn243 :: (Located ([AddEpAnn],[LGRHS GhcPs (LHsExpr GhcPs)])) -> (HappyAbsSyn )-happyIn243 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap243 x)-{-# INLINE happyIn243 #-}-happyOut243 :: (HappyAbsSyn ) -> HappyWrap243-happyOut243 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut243 #-}-newtype HappyWrap244 = HappyWrap244 (forall b. DisambECP b => PV (LGRHS GhcPs (LocatedA b)))-happyIn244 :: (forall b. DisambECP b => PV (LGRHS GhcPs (LocatedA b))) -> (HappyAbsSyn )-happyIn244 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap244 x)-{-# INLINE happyIn244 #-}-happyOut244 :: (HappyAbsSyn ) -> HappyWrap244-happyOut244 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut244 #-}-newtype HappyWrap245 = HappyWrap245 (LPat GhcPs)-happyIn245 :: (LPat GhcPs) -> (HappyAbsSyn )-happyIn245 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap245 x)-{-# INLINE happyIn245 #-}-happyOut245 :: (HappyAbsSyn ) -> HappyWrap245-happyOut245 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut245 #-}-newtype HappyWrap246 = HappyWrap246 (LPat GhcPs)-happyIn246 :: (LPat GhcPs) -> (HappyAbsSyn )-happyIn246 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap246 x)-{-# INLINE happyIn246 #-}-happyOut246 :: (HappyAbsSyn ) -> HappyWrap246-happyOut246 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut246 #-}-newtype HappyWrap247 = HappyWrap247 (LPat GhcPs)-happyIn247 :: (LPat GhcPs) -> (HappyAbsSyn )-happyIn247 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap247 x)-{-# INLINE happyIn247 #-}-happyOut247 :: (HappyAbsSyn ) -> HappyWrap247-happyOut247 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut247 #-}-newtype HappyWrap248 = HappyWrap248 ([LPat GhcPs])-happyIn248 :: ([LPat GhcPs]) -> (HappyAbsSyn )-happyIn248 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap248 x)-{-# INLINE happyIn248 #-}-happyOut248 :: (HappyAbsSyn ) -> HappyWrap248-happyOut248 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut248 #-}-newtype HappyWrap249 = HappyWrap249 (forall b. DisambECP b => PV (LocatedL [LocatedA (Stmt GhcPs (LocatedA b))]))-happyIn249 :: (forall b. DisambECP b => PV (LocatedL [LocatedA (Stmt GhcPs (LocatedA b))])) -> (HappyAbsSyn )-happyIn249 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap249 x)-{-# INLINE happyIn249 #-}-happyOut249 :: (HappyAbsSyn ) -> HappyWrap249-happyOut249 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut249 #-}-newtype HappyWrap250 = HappyWrap250 (forall b. DisambECP b => PV (Located (OrdList AddEpAnn,[LStmt GhcPs (LocatedA b)])))-happyIn250 :: (forall b. DisambECP b => PV (Located (OrdList AddEpAnn,[LStmt GhcPs (LocatedA b)]))) -> (HappyAbsSyn )-happyIn250 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap250 x)-{-# INLINE happyIn250 #-}-happyOut250 :: (HappyAbsSyn ) -> HappyWrap250-happyOut250 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut250 #-}-newtype HappyWrap251 = HappyWrap251 (Maybe (LStmt GhcPs (LHsExpr GhcPs)))-happyIn251 :: (Maybe (LStmt GhcPs (LHsExpr GhcPs))) -> (HappyAbsSyn )-happyIn251 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap251 x)-{-# INLINE happyIn251 #-}-happyOut251 :: (HappyAbsSyn ) -> HappyWrap251-happyOut251 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut251 #-}-newtype HappyWrap252 = HappyWrap252 (LStmt GhcPs (LHsExpr GhcPs))-happyIn252 :: (LStmt GhcPs (LHsExpr GhcPs)) -> (HappyAbsSyn )-happyIn252 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap252 x)-{-# INLINE happyIn252 #-}-happyOut252 :: (HappyAbsSyn ) -> HappyWrap252-happyOut252 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut252 #-}-newtype HappyWrap253 = HappyWrap253 (forall b. DisambECP b => PV (LStmt GhcPs (LocatedA b)))-happyIn253 :: (forall b. DisambECP b => PV (LStmt GhcPs (LocatedA b))) -> (HappyAbsSyn )-happyIn253 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap253 x)-{-# INLINE happyIn253 #-}-happyOut253 :: (HappyAbsSyn ) -> HappyWrap253-happyOut253 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut253 #-}-newtype HappyWrap254 = HappyWrap254 (forall b. DisambECP b => PV (LStmt GhcPs (LocatedA b)))-happyIn254 :: (forall b. DisambECP b => PV (LStmt GhcPs (LocatedA b))) -> (HappyAbsSyn )-happyIn254 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap254 x)-{-# INLINE happyIn254 #-}-happyOut254 :: (HappyAbsSyn ) -> HappyWrap254-happyOut254 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut254 #-}-newtype HappyWrap255 = HappyWrap255 (forall b. DisambECP b => PV ([Fbind b], Maybe SrcSpan))-happyIn255 :: (forall b. DisambECP b => PV ([Fbind b], Maybe SrcSpan)) -> (HappyAbsSyn )-happyIn255 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap255 x)-{-# INLINE happyIn255 #-}-happyOut255 :: (HappyAbsSyn ) -> HappyWrap255-happyOut255 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut255 #-}-newtype HappyWrap256 = HappyWrap256 (forall b. DisambECP b => PV ([Fbind b], Maybe SrcSpan))-happyIn256 :: (forall b. DisambECP b => PV ([Fbind b], Maybe SrcSpan)) -> (HappyAbsSyn )-happyIn256 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap256 x)-{-# INLINE happyIn256 #-}-happyOut256 :: (HappyAbsSyn ) -> HappyWrap256-happyOut256 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut256 #-}-newtype HappyWrap257 = HappyWrap257 (forall b. DisambECP b => PV (Fbind b))-happyIn257 :: (forall b. DisambECP b => PV (Fbind b)) -> (HappyAbsSyn )-happyIn257 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap257 x)-{-# INLINE happyIn257 #-}-happyOut257 :: (HappyAbsSyn ) -> HappyWrap257-happyOut257 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut257 #-}-newtype HappyWrap258 = HappyWrap258 (Located [Located (HsFieldLabel GhcPs)])-happyIn258 :: (Located [Located (HsFieldLabel GhcPs)]) -> (HappyAbsSyn )-happyIn258 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap258 x)-{-# INLINE happyIn258 #-}-happyOut258 :: (HappyAbsSyn ) -> HappyWrap258-happyOut258 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut258 #-}-newtype HappyWrap259 = HappyWrap259 (Located [LIPBind GhcPs])-happyIn259 :: (Located [LIPBind GhcPs]) -> (HappyAbsSyn )-happyIn259 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap259 x)-{-# INLINE happyIn259 #-}-happyOut259 :: (HappyAbsSyn ) -> HappyWrap259-happyOut259 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut259 #-}-newtype HappyWrap260 = HappyWrap260 (LIPBind GhcPs)-happyIn260 :: (LIPBind GhcPs) -> (HappyAbsSyn )-happyIn260 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap260 x)-{-# INLINE happyIn260 #-}-happyOut260 :: (HappyAbsSyn ) -> HappyWrap260-happyOut260 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut260 #-}-newtype HappyWrap261 = HappyWrap261 (Located HsIPName)-happyIn261 :: (Located HsIPName) -> (HappyAbsSyn )-happyIn261 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap261 x)-{-# INLINE happyIn261 #-}-happyOut261 :: (HappyAbsSyn ) -> HappyWrap261-happyOut261 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut261 #-}-newtype HappyWrap262 = HappyWrap262 (Located FastString)-happyIn262 :: (Located FastString) -> (HappyAbsSyn )-happyIn262 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap262 x)-{-# INLINE happyIn262 #-}-happyOut262 :: (HappyAbsSyn ) -> HappyWrap262-happyOut262 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut262 #-}-newtype HappyWrap263 = HappyWrap263 (LBooleanFormula (LocatedN RdrName))-happyIn263 :: (LBooleanFormula (LocatedN RdrName)) -> (HappyAbsSyn )-happyIn263 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap263 x)-{-# INLINE happyIn263 #-}-happyOut263 :: (HappyAbsSyn ) -> HappyWrap263-happyOut263 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut263 #-}-newtype HappyWrap264 = HappyWrap264 (LBooleanFormula (LocatedN RdrName))-happyIn264 :: (LBooleanFormula (LocatedN RdrName)) -> (HappyAbsSyn )-happyIn264 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap264 x)-{-# INLINE happyIn264 #-}-happyOut264 :: (HappyAbsSyn ) -> HappyWrap264-happyOut264 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut264 #-}-newtype HappyWrap265 = HappyWrap265 (LBooleanFormula (LocatedN RdrName))-happyIn265 :: (LBooleanFormula (LocatedN RdrName)) -> (HappyAbsSyn )-happyIn265 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap265 x)-{-# INLINE happyIn265 #-}-happyOut265 :: (HappyAbsSyn ) -> HappyWrap265-happyOut265 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut265 #-}-newtype HappyWrap266 = HappyWrap266 ([LBooleanFormula (LocatedN RdrName)])-happyIn266 :: ([LBooleanFormula (LocatedN RdrName)]) -> (HappyAbsSyn )-happyIn266 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap266 x)-{-# INLINE happyIn266 #-}-happyOut266 :: (HappyAbsSyn ) -> HappyWrap266-happyOut266 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut266 #-}-newtype HappyWrap267 = HappyWrap267 (LBooleanFormula (LocatedN RdrName))-happyIn267 :: (LBooleanFormula (LocatedN RdrName)) -> (HappyAbsSyn )-happyIn267 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap267 x)-{-# INLINE happyIn267 #-}-happyOut267 :: (HappyAbsSyn ) -> HappyWrap267-happyOut267 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut267 #-}-newtype HappyWrap268 = HappyWrap268 (Located [LocatedN RdrName])-happyIn268 :: (Located [LocatedN RdrName]) -> (HappyAbsSyn )-happyIn268 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap268 x)-{-# INLINE happyIn268 #-}-happyOut268 :: (HappyAbsSyn ) -> HappyWrap268-happyOut268 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut268 #-}-newtype HappyWrap269 = HappyWrap269 (LocatedN RdrName)-happyIn269 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn269 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap269 x)-{-# INLINE happyIn269 #-}-happyOut269 :: (HappyAbsSyn ) -> HappyWrap269-happyOut269 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut269 #-}-newtype HappyWrap270 = HappyWrap270 (LocatedN RdrName)-happyIn270 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn270 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap270 x)-{-# INLINE happyIn270 #-}-happyOut270 :: (HappyAbsSyn ) -> HappyWrap270-happyOut270 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut270 #-}-newtype HappyWrap271 = HappyWrap271 (LocatedN RdrName)-happyIn271 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn271 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap271 x)-{-# INLINE happyIn271 #-}-happyOut271 :: (HappyAbsSyn ) -> HappyWrap271-happyOut271 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut271 #-}-newtype HappyWrap272 = HappyWrap272 (LocatedN RdrName)-happyIn272 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn272 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap272 x)-{-# INLINE happyIn272 #-}-happyOut272 :: (HappyAbsSyn ) -> HappyWrap272-happyOut272 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut272 #-}-newtype HappyWrap273 = HappyWrap273 (LocatedN RdrName)-happyIn273 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn273 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap273 x)-{-# INLINE happyIn273 #-}-happyOut273 :: (HappyAbsSyn ) -> HappyWrap273-happyOut273 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut273 #-}-newtype HappyWrap274 = HappyWrap274 (Located [LocatedN RdrName])-happyIn274 :: (Located [LocatedN RdrName]) -> (HappyAbsSyn )-happyIn274 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap274 x)-{-# INLINE happyIn274 #-}-happyOut274 :: (HappyAbsSyn ) -> HappyWrap274-happyOut274 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut274 #-}-newtype HappyWrap275 = HappyWrap275 (LocatedN DataCon)-happyIn275 :: (LocatedN DataCon) -> (HappyAbsSyn )-happyIn275 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap275 x)-{-# INLINE happyIn275 #-}-happyOut275 :: (HappyAbsSyn ) -> HappyWrap275-happyOut275 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut275 #-}-newtype HappyWrap276 = HappyWrap276 (LocatedN DataCon)-happyIn276 :: (LocatedN DataCon) -> (HappyAbsSyn )-happyIn276 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap276 x)-{-# INLINE happyIn276 #-}-happyOut276 :: (HappyAbsSyn ) -> HappyWrap276-happyOut276 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut276 #-}-newtype HappyWrap277 = HappyWrap277 (LocatedN RdrName)-happyIn277 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn277 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap277 x)-{-# INLINE happyIn277 #-}-happyOut277 :: (HappyAbsSyn ) -> HappyWrap277-happyOut277 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut277 #-}-newtype HappyWrap278 = HappyWrap278 (LocatedN RdrName)-happyIn278 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn278 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap278 x)-{-# INLINE happyIn278 #-}-happyOut278 :: (HappyAbsSyn ) -> HappyWrap278-happyOut278 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut278 #-}-newtype HappyWrap279 = HappyWrap279 (LocatedN RdrName)-happyIn279 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn279 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap279 x)-{-# INLINE happyIn279 #-}-happyOut279 :: (HappyAbsSyn ) -> HappyWrap279-happyOut279 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut279 #-}-newtype HappyWrap280 = HappyWrap280 (LocatedN RdrName)-happyIn280 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn280 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap280 x)-{-# INLINE happyIn280 #-}-happyOut280 :: (HappyAbsSyn ) -> HappyWrap280-happyOut280 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut280 #-}-newtype HappyWrap281 = HappyWrap281 (LocatedN RdrName)-happyIn281 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn281 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap281 x)-{-# INLINE happyIn281 #-}-happyOut281 :: (HappyAbsSyn ) -> HappyWrap281-happyOut281 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut281 #-}-newtype HappyWrap282 = HappyWrap282 (LocatedN RdrName)-happyIn282 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn282 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap282 x)-{-# INLINE happyIn282 #-}-happyOut282 :: (HappyAbsSyn ) -> HappyWrap282-happyOut282 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut282 #-}-newtype HappyWrap283 = HappyWrap283 (LocatedN RdrName)-happyIn283 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn283 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap283 x)-{-# INLINE happyIn283 #-}-happyOut283 :: (HappyAbsSyn ) -> HappyWrap283-happyOut283 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut283 #-}-newtype HappyWrap284 = HappyWrap284 (LocatedN RdrName)-happyIn284 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn284 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap284 x)-{-# INLINE happyIn284 #-}-happyOut284 :: (HappyAbsSyn ) -> HappyWrap284-happyOut284 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut284 #-}-newtype HappyWrap285 = HappyWrap285 (LocatedN RdrName)-happyIn285 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn285 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap285 x)-{-# INLINE happyIn285 #-}-happyOut285 :: (HappyAbsSyn ) -> HappyWrap285-happyOut285 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut285 #-}-newtype HappyWrap286 = HappyWrap286 (LocatedN RdrName)-happyIn286 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn286 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap286 x)-{-# INLINE happyIn286 #-}-happyOut286 :: (HappyAbsSyn ) -> HappyWrap286-happyOut286 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut286 #-}-newtype HappyWrap287 = HappyWrap287 (LocatedN RdrName)-happyIn287 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn287 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap287 x)-{-# INLINE happyIn287 #-}-happyOut287 :: (HappyAbsSyn ) -> HappyWrap287-happyOut287 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut287 #-}-newtype HappyWrap288 = HappyWrap288 (LocatedN RdrName)-happyIn288 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn288 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap288 x)-{-# INLINE happyIn288 #-}-happyOut288 :: (HappyAbsSyn ) -> HappyWrap288-happyOut288 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut288 #-}-newtype HappyWrap289 = HappyWrap289 (LocatedN RdrName)-happyIn289 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn289 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap289 x)-{-# INLINE happyIn289 #-}-happyOut289 :: (HappyAbsSyn ) -> HappyWrap289-happyOut289 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut289 #-}-newtype HappyWrap290 = HappyWrap290 (LocatedN RdrName)-happyIn290 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn290 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap290 x)-{-# INLINE happyIn290 #-}-happyOut290 :: (HappyAbsSyn ) -> HappyWrap290-happyOut290 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut290 #-}-newtype HappyWrap291 = HappyWrap291 (forall b. DisambInfixOp b => PV (LocatedN b))-happyIn291 :: (forall b. DisambInfixOp b => PV (LocatedN b)) -> (HappyAbsSyn )-happyIn291 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap291 x)-{-# INLINE happyIn291 #-}-happyOut291 :: (HappyAbsSyn ) -> HappyWrap291-happyOut291 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut291 #-}-newtype HappyWrap292 = HappyWrap292 (forall b. DisambInfixOp b => PV (LocatedN b))-happyIn292 :: (forall b. DisambInfixOp b => PV (LocatedN b)) -> (HappyAbsSyn )-happyIn292 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap292 x)-{-# INLINE happyIn292 #-}-happyOut292 :: (HappyAbsSyn ) -> HappyWrap292-happyOut292 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut292 #-}-newtype HappyWrap293 = HappyWrap293 (forall b. DisambInfixOp b => PV (Located b))-happyIn293 :: (forall b. DisambInfixOp b => PV (Located b)) -> (HappyAbsSyn )-happyIn293 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap293 x)-{-# INLINE happyIn293 #-}-happyOut293 :: (HappyAbsSyn ) -> HappyWrap293-happyOut293 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut293 #-}-newtype HappyWrap294 = HappyWrap294 (LocatedN RdrName)-happyIn294 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn294 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap294 x)-{-# INLINE happyIn294 #-}-happyOut294 :: (HappyAbsSyn ) -> HappyWrap294-happyOut294 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut294 #-}-newtype HappyWrap295 = HappyWrap295 (LocatedN RdrName)-happyIn295 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn295 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap295 x)-{-# INLINE happyIn295 #-}-happyOut295 :: (HappyAbsSyn ) -> HappyWrap295-happyOut295 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut295 #-}-newtype HappyWrap296 = HappyWrap296 (LocatedN RdrName)-happyIn296 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn296 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap296 x)-{-# INLINE happyIn296 #-}-happyOut296 :: (HappyAbsSyn ) -> HappyWrap296-happyOut296 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut296 #-}-newtype HappyWrap297 = HappyWrap297 (LocatedN RdrName)-happyIn297 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn297 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap297 x)-{-# INLINE happyIn297 #-}-happyOut297 :: (HappyAbsSyn ) -> HappyWrap297-happyOut297 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut297 #-}-newtype HappyWrap298 = HappyWrap298 (LocatedN RdrName)-happyIn298 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn298 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap298 x)-{-# INLINE happyIn298 #-}-happyOut298 :: (HappyAbsSyn ) -> HappyWrap298-happyOut298 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut298 #-}-newtype HappyWrap299 = HappyWrap299 (LocatedN RdrName)-happyIn299 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn299 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap299 x)-{-# INLINE happyIn299 #-}-happyOut299 :: (HappyAbsSyn ) -> HappyWrap299-happyOut299 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut299 #-}-newtype HappyWrap300 = HappyWrap300 (LocatedN RdrName)-happyIn300 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn300 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap300 x)-{-# INLINE happyIn300 #-}-happyOut300 :: (HappyAbsSyn ) -> HappyWrap300-happyOut300 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut300 #-}-newtype HappyWrap301 = HappyWrap301 (Located FastString)-happyIn301 :: (Located FastString) -> (HappyAbsSyn )-happyIn301 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap301 x)-{-# INLINE happyIn301 #-}-happyOut301 :: (HappyAbsSyn ) -> HappyWrap301-happyOut301 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut301 #-}-newtype HappyWrap302 = HappyWrap302 (LocatedN RdrName)-happyIn302 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn302 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap302 x)-{-# INLINE happyIn302 #-}-happyOut302 :: (HappyAbsSyn ) -> HappyWrap302-happyOut302 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut302 #-}-newtype HappyWrap303 = HappyWrap303 (LocatedN RdrName)-happyIn303 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn303 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap303 x)-{-# INLINE happyIn303 #-}-happyOut303 :: (HappyAbsSyn ) -> HappyWrap303-happyOut303 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut303 #-}-newtype HappyWrap304 = HappyWrap304 (LocatedN RdrName)-happyIn304 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn304 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap304 x)-{-# INLINE happyIn304 #-}-happyOut304 :: (HappyAbsSyn ) -> HappyWrap304-happyOut304 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut304 #-}-newtype HappyWrap305 = HappyWrap305 (LocatedN RdrName)-happyIn305 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn305 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap305 x)-{-# INLINE happyIn305 #-}-happyOut305 :: (HappyAbsSyn ) -> HappyWrap305-happyOut305 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut305 #-}-newtype HappyWrap306 = HappyWrap306 (LocatedN RdrName)-happyIn306 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn306 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap306 x)-{-# INLINE happyIn306 #-}-happyOut306 :: (HappyAbsSyn ) -> HappyWrap306-happyOut306 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut306 #-}-newtype HappyWrap307 = HappyWrap307 (LocatedN RdrName)-happyIn307 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn307 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap307 x)-{-# INLINE happyIn307 #-}-happyOut307 :: (HappyAbsSyn ) -> HappyWrap307-happyOut307 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut307 #-}-newtype HappyWrap308 = HappyWrap308 (LocatedN RdrName)-happyIn308 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn308 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap308 x)-{-# INLINE happyIn308 #-}-happyOut308 :: (HappyAbsSyn ) -> HappyWrap308-happyOut308 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut308 #-}-newtype HappyWrap309 = HappyWrap309 (Located FastString)-happyIn309 :: (Located FastString) -> (HappyAbsSyn )-happyIn309 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap309 x)-{-# INLINE happyIn309 #-}-happyOut309 :: (HappyAbsSyn ) -> HappyWrap309-happyOut309 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut309 #-}-newtype HappyWrap310 = HappyWrap310 (Located FastString)-happyIn310 :: (Located FastString) -> (HappyAbsSyn )-happyIn310 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap310 x)-{-# INLINE happyIn310 #-}-happyOut310 :: (HappyAbsSyn ) -> HappyWrap310-happyOut310 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut310 #-}-newtype HappyWrap311 = HappyWrap311 (LocatedN RdrName)-happyIn311 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn311 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap311 x)-{-# INLINE happyIn311 #-}-happyOut311 :: (HappyAbsSyn ) -> HappyWrap311-happyOut311 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut311 #-}-newtype HappyWrap312 = HappyWrap312 (LocatedN RdrName)-happyIn312 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn312 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap312 x)-{-# INLINE happyIn312 #-}-happyOut312 :: (HappyAbsSyn ) -> HappyWrap312-happyOut312 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut312 #-}-newtype HappyWrap313 = HappyWrap313 (LocatedN RdrName)-happyIn313 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn313 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap313 x)-{-# INLINE happyIn313 #-}-happyOut313 :: (HappyAbsSyn ) -> HappyWrap313-happyOut313 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut313 #-}-newtype HappyWrap314 = HappyWrap314 (LocatedN RdrName)-happyIn314 :: (LocatedN RdrName) -> (HappyAbsSyn )-happyIn314 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap314 x)-{-# INLINE happyIn314 #-}-happyOut314 :: (HappyAbsSyn ) -> HappyWrap314-happyOut314 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut314 #-}-newtype HappyWrap315 = HappyWrap315 (Located (HsLit GhcPs))-happyIn315 :: (Located (HsLit GhcPs)) -> (HappyAbsSyn )-happyIn315 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap315 x)-{-# INLINE happyIn315 #-}-happyOut315 :: (HappyAbsSyn ) -> HappyWrap315-happyOut315 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut315 #-}-newtype HappyWrap316 = HappyWrap316 (())-happyIn316 :: (()) -> (HappyAbsSyn )-happyIn316 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap316 x)-{-# INLINE happyIn316 #-}-happyOut316 :: (HappyAbsSyn ) -> HappyWrap316-happyOut316 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut316 #-}-newtype HappyWrap317 = HappyWrap317 (LocatedA ModuleName)-happyIn317 :: (LocatedA ModuleName) -> (HappyAbsSyn )-happyIn317 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap317 x)-{-# INLINE happyIn317 #-}-happyOut317 :: (HappyAbsSyn ) -> HappyWrap317-happyOut317 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut317 #-}-newtype HappyWrap318 = HappyWrap318 (([SrcSpan],Int))-happyIn318 :: (([SrcSpan],Int)) -> (HappyAbsSyn )-happyIn318 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap318 x)-{-# INLINE happyIn318 #-}-happyOut318 :: (HappyAbsSyn ) -> HappyWrap318-happyOut318 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut318 #-}-newtype HappyWrap319 = HappyWrap319 (([EpaLocation],Int))-happyIn319 :: (([EpaLocation],Int)) -> (HappyAbsSyn )-happyIn319 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap319 x)-{-# INLINE happyIn319 #-}-happyOut319 :: (HappyAbsSyn ) -> HappyWrap319-happyOut319 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut319 #-}-newtype HappyWrap320 = HappyWrap320 (([EpaLocation],Int))-happyIn320 :: (([EpaLocation],Int)) -> (HappyAbsSyn )-happyIn320 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap320 x)-{-# INLINE happyIn320 #-}-happyOut320 :: (HappyAbsSyn ) -> HappyWrap320-happyOut320 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut320 #-}-newtype HappyWrap321 = HappyWrap321 (ECP)-happyIn321 :: (ECP) -> (HappyAbsSyn )-happyIn321 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap321 x)-{-# INLINE happyIn321 #-}-happyOut321 :: (HappyAbsSyn ) -> HappyWrap321-happyOut321 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut321 #-}-newtype HappyWrap322 = HappyWrap322 (ECP)-happyIn322 :: (ECP) -> (HappyAbsSyn )-happyIn322 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap322 x)-{-# INLINE happyIn322 #-}-happyOut322 :: (HappyAbsSyn ) -> HappyWrap322-happyOut322 x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOut322 #-}-happyInTok :: ((Located Token)) -> (HappyAbsSyn )-happyInTok x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyInTok #-}-happyOutTok :: (HappyAbsSyn ) -> ((Located Token))-happyOutTok x = Happy_GHC_Exts.unsafeCoerce# x-{-# INLINE happyOutTok #-}---happyExpList :: HappyAddr-happyExpList = HappyA# "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x30\x10\xd1\xff\x3f\xfe\x20\x00\x80\x80\x07\x00\xaa\x70\xe6\xff\x7f\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfc\xcd\x57\xfd\xff\xcb\xff\x3d\x83\x20\xe0\x01\x80\x2a\x9c\xf9\xff\x5f\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07\x03\x11\xfd\xff\xe2\x0f\x02\x00\x08\x78\x00\xa0\x0a\x67\xfe\xff\xd7\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xc1\x40\x44\xff\xbf\xf8\x83\x00\x00\x02\x1e\x00\xa8\xc2\x99\xff\xff\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x30\x17\xd1\xff\x2f\xff\x27\x08\x82\x80\x07\x00\xaa\x70\xe6\xff\x7f\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x0c\x44\xf4\xff\x8f\x3f\x08\x00\x20\xe0\x01\x80\x2a\x9c\xf9\xff\x5f\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x01\x10\xfd\x7f\xc2\x0f\x00\x00\x81\x88\x10\xa0\x82\xfe\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x40\x00\x44\x3f\x9f\xf0\x03\x0c\x40\x00\x2e\x84\xa8\xe0\x77\x3a\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x10\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x01\x10\xfd\x7f\xc2\x0f\x00\x00\x00\x00\x00\x80\x00\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x22\x04\x00\x00\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x40\x00\x04\x3f\x9f\xf0\x03\x0c\x40\x00\x2e\x84\xa8\xe0\x77\x38\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x10\x00\xd1\xcf\x27\xfc\x00\x03\x10\x80\x0b\x21\x2a\xf8\x9d\x0e\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x40\x00\x04\x3f\x9f\xf0\x03\x0c\x40\x00\x2e\xa4\xa8\xe0\x77\x38\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x04\x40\xf0\xf3\x09\x3f\x00\x00\x00\x00\x00\x08\x02\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x04\x40\xf0\xf3\x09\x3f\x00\x00\x00\xc0\x02\x88\x0a\x1c\x81\x03\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x01\x10\xfc\x7c\xc2\x0f\x00\x00\x00\xb0\x00\xa2\x02\x47\xe0\x00\x40\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x04\x40\xf4\xff\x09\x3f\x00\x00\x00\x00\x00\x00\x02\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x01\x10\xfd\x7c\xc2\x0f\x30\x00\x01\xb8\x10\xe2\x82\xdf\xe9\x00\x40\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x40\x00\x44\x3f\x9f\xf0\x03\x0c\x40\x20\x2e\x84\xe8\xf0\x77\x3a\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x10\x00\xd1\xcf\x27\xfc\x00\x03\x10\x80\x0b\x21\x6a\xfc\x9d\x0e\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x04\x40\xf0\xf3\x09\x3f\x00\x00\x00\x00\x00\x00\x00\x18\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x01\x10\xfd\x7f\xc2\x0f\x00\x00\x01\x88\x10\xa0\x82\x5e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x01\x10\xfd\x7f\xc2\x0f\x00\x00\x00\x00\x00\xa0\x0a\x67\xf8\xff\xd7\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x20\x22\x04\x40\x10\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x04\x40\xf4\xff\x09\x3f\x00\x00\x00\x00\x00\x00\x00\x98\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x88\x1f\x00\x80\x98\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x30\x10\xd1\xff\x2f\xfe\x20\x00\x80\x80\x07\x00\xaa\x70\xe6\xff\x7f\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x0c\x44\xf4\xff\x0b\x3f\x00\x00\x20\xc0\x01\x82\x2a\x9c\xf9\xff\x5f\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x90\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07\x03\x11\xfd\xff\xe2\x0f\x02\x00\x08\x78\x00\xa0\x0a\x67\xfe\xff\xd7\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xc1\x40\x44\xff\xbf\xf8\x83\x00\x00\x0a\x1e\x80\xa8\xc2\x99\xff\xff\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x0c\x44\xf4\xff\x0b\x3f\x00\x00\x20\xc0\x01\x80\x2a\x9c\xf9\xff\x5f\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xc1\x40\x44\xff\xbf\xf0\x03\x00\x00\x02\x1c\x00\xa8\xc2\x99\xff\xff\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x0c\x44\xf4\xff\x0b\x3f\x00\x00\x60\xc0\x01\x80\x2a\x9c\xf9\xff\x5f\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07\x03\x11\xfd\xff\xe2\x0f\x00\x00\x08\x70\x00\xa0\x0a\x67\xfe\xff\xd7\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xc1\x40\x44\xff\xbf\xf0\x03\x00\x00\x02\x1c\x00\xa8\xc2\x99\xff\xff\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x30\x10\xd1\xff\x2f\xfc\x00\x00\x80\x00\x07\x00\xaa\x70\xe6\xff\x7f\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x0c\x44\xf4\xff\x0b\x3f\x00\x00\x20\xc0\x01\x80\x2a\x9c\xf9\xff\x5f\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07\x03\x11\xfd\xff\xe2\x0f\x02\x00\x09\xf8\x10\xe0\x8a\xff\xff\xff\xd7\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xc1\x40\x44\xff\xbf\xf8\x83\x00\x40\x0a\x3e\x0c\xe8\xf2\xff\xff\xff\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x30\x10\xd1\xff\x2f\xfe\x20\x00\x90\x82\x0f\x01\xea\xfc\xff\xff\x7f\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x0c\x44\xf4\xff\x0b\x3f\x00\x00\x20\xc0\x01\x80\x2a\x9c\xf9\xff\x5f\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x01\x10\xfd\x7f\xc2\x0f\x00\x00\x00\x00\x00\xa0\x02\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x30\x10\xd1\xff\x2f\xfe\x20\x00\x80\x80\x07\x00\xaa\x70\xe6\xff\x7f\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x0c\x44\xf4\xff\x8b\x3f\x00\x00\x20\xe0\x01\x80\x2a\x9c\xf9\xff\x5f\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x01\x10\xfd\x7c\xc2\x0f\x30\x00\x01\xb8\x10\xa2\x82\xdf\xe9\x00\x40\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x30\x10\xd1\xff\x2f\xfe\x20\x00\x80\x80\x07\x00\xaa\x70\xe6\xff\x7f\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x04\x40\xf4\xff\x09\x3f\x00\x00\x00\x00\x00\x80\x2a\x9c\xe1\xff\x5f\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x01\x10\xfc\x7c\xc2\x0f\x00\x00\x00\x00\x00\xa0\x02\x46\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x88\x10\x00\x80\x98\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x0a\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x04\x40\xf4\xff\x09\x3f\x00\x00\x00\x00\x00\x00\x02\x88\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x01\x10\xfd\x7f\xc2\x0f\x00\x00\x00\x00\x00\xa0\x02\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa8\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x30\x10\xd1\xff\x2f\xfe\x20\x00\x90\x82\x0f\x03\xba\xfc\xff\xff\x7f\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x80\x08\x01\x00\x88\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x04\x40\xf0\xf3\x09\x3f\xc0\x00\x04\xe0\x42\x88\x0a\x7e\x87\x03\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x40\x20\x04\xff\x9f\xf0\x03\x0c\x40\x00\x2e\x84\xa8\xe0\x77\x38\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x04\x40\xf4\xff\x09\x3f\x00\x00\x00\x00\x00\x80\x0a\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x40\x00\x44\xff\x9f\xf0\x03\x00\x00\x00\x00\x00\xa8\x80\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x10\x00\xd1\xff\x27\xfc\x00\x00\x00\x00\x00\x00\x2a\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x04\x48\xf5\xff\x09\x3f\x00\x00\x00\x00\x00\x80\x0a\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07\x03\x11\xfd\xff\xc2\x0f\x00\x00\x08\x70\x00\xa0\x0a\x67\xfe\xff\xd7\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x30\x10\xd1\xff\x2f\xfc\x00\x00\x80\x00\x07\x00\xaa\x70\xe6\xff\x7f\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x88\x10\x00\x41\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x01\x10\xfd\x7f\xc2\x0f\x00\x00\x00\x00\x00\x02\x40\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x08\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x04\x40\xf4\xf3\x09\x3f\xc0\x00\x04\xe0\x42\x88\x0a\x7e\x87\x03\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x01\x10\xfc\x7c\xc2\x0f\x30\x00\x01\xb8\x10\xa2\x82\xdf\xe1\x00\x40\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x10\x00\xd1\xcf\x27\xfc\x00\x03\x10\x80\x0b\x21\x2a\xf8\x9d\x0e\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x01\x10\xfd\x7c\xc2\x0f\x30\x00\x01\xb8\x10\xa2\x82\xdf\xe9\x00\x40\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x40\x00\x44\x3f\x9f\xf0\x03\x0c\x40\x00\x2e\x84\xa8\xe0\x77\x3a\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x10\x00\xc1\xcf\x27\xfc\x00\x03\x10\x80\x0b\x21\x2a\xf8\x1d\x0e\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07\x03\x11\xfd\xff\xe2\x0f\x02\x00\x08\x78\x00\xa0\x0a\x67\xfe\xff\xd7\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x04\x40\xf4\xf3\x09\x3f\xc0\x00\x04\xe0\x42\x88\x0a\x7e\xa7\x03\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x01\x10\xfd\x7f\xc2\x0f\x00\x00\x00\x00\x00\x00\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x40\x00\x04\x3f\x9f\xf0\x03\x0c\x40\x00\x2e\x84\xa8\xe0\x77\x38\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x00\xe2\x07\x00\x20\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x04\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x30\x10\xd1\xff\x2f\xfe\x00\x00\x80\x80\x07\x00\xaa\x70\xe6\xff\x7f\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x30\x10\xd1\xff\x2f\xfe\x20\x00\x90\x80\x0f\x01\xba\xfc\xff\xff\x7f\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x0c\x44\xf4\xff\x8b\x3f\x08\x00\xa4\xe0\x43\x80\x2a\xfe\xff\xff\x5f\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xc1\x40\x44\xff\xbf\xf8\x03\x00\x00\x02\x1c\x00\xa8\xc2\x99\xff\xff\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x40\x00\x44\xff\x9f\xf0\x03\x00\x00\x00\x00\x00\x00\x80\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x10\x00\xd1\xff\x27\xfc\x00\x00\x10\x80\x08\x01\x3a\xe4\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x01\x10\xfd\x7f\xc2\x0f\x00\x00\x00\x00\x00\x80\x00\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x80\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x04\x40\xf4\xff\x09\x3f\x00\x00\x00\x00\x00\x00\x02\x88\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x01\x10\xfd\x7c\xc2\x0f\x30\x00\x01\xb8\x10\xa2\x82\xdf\xe9\x00\x40\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x40\x00\x44\xff\x9f\xf0\x03\x00\x00\x00\x00\x00\xa8\x80\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07\x73\x11\xfd\xff\xf2\x7f\x82\x20\x08\x78\x00\xa0\x0a\x67\xfe\xff\xd7\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xc1\x5c\x44\xff\xbf\xfc\x9f\x20\x08\x02\x1e\x00\xa8\xc2\x99\xff\xff\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x10\x00\xd1\xff\x27\xfc\x00\x00\x00\x00\x00\x00\x08\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x04\x40\xf4\xf3\x09\x3f\xc0\x00\x04\xe0\x42\x88\x0a\x7e\xa7\x03\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x88\x10\x00\x80\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x88\x00\x01\x10\x84\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x20\x42\x00\x00\x62\x06\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x30\x10\xd1\xff\x3f\xfe\x20\x00\x80\x80\x07\x00\xaa\x70\xe6\xff\x7f\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x0c\x44\xf4\xff\x8f\x3f\x08\x00\x20\xe0\x01\x80\x2a\x9c\xf9\xff\x5f\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x20\x42\x00\x04\x61\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xc1\x40\x44\xff\xbf\xf8\x83\x00\x40\x02\x3e\x04\xa8\xf3\xff\xff\xff\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x20\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x0c\x44\xf4\xff\x0b\x3f\x00\x00\x20\xc0\x01\x82\x2a\x9c\xf9\xff\x5f\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xc1\x40\x44\xff\xbf\xf0\x03\x00\x00\x02\x1c\x00\xa8\xc2\x99\xff\xff\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xc1\x40\x44\xff\xbf\xf8\x83\x00\x00\x02\x1e\x00\xa8\xc2\x99\xff\xff\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07\x03\x11\xfd\xff\xc2\x0f\x00\x00\x08\x70\x00\xa0\x0a\x67\xfe\xff\xd7\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xc1\x40\x44\xff\xbf\xf8\x83\x00\x00\x02\x1e\x00\xa8\xc2\x99\xff\xff\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x04\x40\xf4\xff\x09\x3f\x00\x00\x02\x00\x00\x00\x02\x88\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x40\x00\x04\x3f\x9f\xf0\x03\x00\x00\x00\x2c\x80\xa8\xc0\x11\x38\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x04\x40\xf4\xf3\x09\x3f\xc0\x00\x04\xe0\x42\x88\x0a\x7e\xa7\x03\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07\x03\x11\xfd\xff\xe2\x0f\x02\x00\x08\x78\x00\xa0\x0a\x67\xfe\xff\xd7\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xc1\x40\x44\xff\xbf\xf8\x83\x00\x00\x02\x1e\x00\xa8\xc2\x99\xff\xff\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x30\x10\xd1\xff\x2f\xfe\x20\x00\x80\x80\x07\x00\xaa\x70\xe6\xff\x7f\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x0c\x44\xf4\xff\x8b\x3f\x08\x00\x20\xe0\x01\x80\x2a\x9c\xf9\xff\x5f\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x04\x40\xf4\xf3\x09\x3f\xc0\x00\x04\xe0\x42\x88\x0a\x7e\xa7\x03\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x01\x10\xfd\x7c\xc2\x0f\x30\x00\x01\xb8\x10\xa2\xc3\xdf\xe9\x00\x40\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x40\x00\x44\xff\x9f\xf0\x03\x00\x00\x00\x00\x00\x00\x80\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x22\x04\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x04\x40\xf4\xff\x09\x3f\x00\x00\x00\x00\x00\x80\x0a\x18\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x01\x10\xfc\x7c\xc2\x0f\x00\x00\x00\x00\x00\x82\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x04\x40\xf0\xf3\x09\x3f\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x01\x10\xfc\x7c\xc2\x0f\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x40\x00\x04\x3f\x9f\xf0\x03\x0c\x40\x00\x2e\x84\xa8\xe0\x77\x38\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x10\x00\xc1\xcf\x27\xfc\x00\x00\x00\x00\x0b\x20\x2a\x70\x04\x0e\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x01\x10\xfc\x7c\xc2\x0f\x30\x00\x01\xb8\x10\xa2\x82\xdf\xe1\x00\x40\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x10\x00\xc1\xcf\x27\xfc\x00\x00\x00\x00\x0b\x20\x2a\x70\x04\x0e\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x01\x10\xfd\x7c\xc2\x0f\x30\x00\x01\xb8\x10\xa2\x82\xdf\xe9\x00\x40\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x40\x00\x44\x3f\x9f\xf0\x03\x0c\x40\x00\x2e\x84\xa8\xe0\x77\x3a\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x10\x00\xc1\xcf\x27\xfc\x00\x00\x00\x00\x0b\x20\x2a\x70\x04\x0e\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x04\x40\xf4\xf3\x09\x3f\xc0\x00\x04\xe0\x42\x88\x0a\x7e\xa7\x03\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x01\x10\xfd\x7c\xc2\x0f\x30\x00\x01\xb8\x10\xa2\x82\xdf\xe9\x00\x40\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x40\x00\x04\x07\x9f\xf0\x03\x00\x00\x00\x00\x00\x00\x80\x01\x10\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x10\x00\xd1\xcf\x27\xfc\x00\x03\x10\x80\x0b\x21\x2a\xf8\x9d\x0e\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x40\x00\x44\xff\x9f\xf0\x03\x00\x00\x00\x00\x00\x20\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x04\x40\xf4\xf3\x09\x3f\xc0\x00\x04\xe0\x42\x88\x0a\x7e\xa7\x03\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x01\x10\xfd\x7f\xc2\x0f\x00\x00\x00\x00\x00\x80\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x10\x00\xd1\xcf\x27\xfc\x00\x03\x10\x80\x0b\x21\x2a\xf8\x9d\x0e\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x01\x10\xfd\x7c\xc2\x0f\x30\x00\x01\xb8\x10\xa2\x82\xdf\xe9\x00\x40\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x01\x10\xfd\x7c\xc2\x0f\x30\x00\x01\xb8\x10\xa2\x82\xdf\xe9\x00\x40\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x40\x00\x44\x3f\x9f\xf0\x03\x0c\x40\x00\x2e\x84\xa8\xe0\x77\x3a\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xc1\x40\x44\xff\xbf\xf8\x83\x00\x00\x02\x1e\x00\xa8\xc2\x99\xff\xff\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x30\x10\xd1\xff\x2f\xfe\x20\x00\x80\x80\x07\x00\xaa\x70\xe6\xff\x7f\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x30\x10\xd1\xff\x2f\xfe\x20\x00\x80\x80\x07\x40\xaa\x72\xe6\xff\x7f\x7d\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x0c\x44\xf4\xff\x8b\x3f\x08\x00\x20\xe0\x01\xc0\xaa\x9c\xf9\xff\x5f\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07\x03\x11\xfd\xff\xc2\x0f\x00\x00\x08\x70\x00\xa0\x0a\x67\xfe\xff\xd7\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x30\x10\xd1\xff\x2f\xfe\x20\x00\x90\x80\x0f\x01\xaa\xf8\xff\xff\x7f\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07\x03\x11\xfd\xff\xe2\x0f\x02\x00\x08\x78\x00\xa0\x0a\x67\xfe\xff\xd7\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xc1\x40\x4c\xff\xbf\xf8\x83\x00\x00\x02\x1e\x00\xa8\xc2\x99\xff\xff\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x30\x10\xd1\xff\x2f\xfe\x20\x00\x90\x80\x0f\x01\xaa\xf8\xff\xff\x7f\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07\x03\x11\xfd\xff\xe2\x0f\x02\x00\x09\xf8\x10\xa0\xca\xff\xff\xff\xd7\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x0c\x44\xf4\xff\x0b\x3f\x00\x00\x20\xc0\x01\x80\x6a\x9c\xf9\xff\x5f\x5f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfc\xcd\x57\xfd\xff\xcb\xff\x3d\x83\x20\xe0\x01\x80\x2a\x9c\xf9\xff\x5f\x5f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x40\x00\x44\xff\x9f\xf0\x03\x00\x00\x00\x00\x00\x00\x80\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x40\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x88\x10\x00\x80\x98\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x01\x10\xfd\x7f\xc2\x0f\x00\x00\x00\x00\x00\xa0\x02\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x40\x00\x44\xff\x9f\xf0\x03\x00\x00\x00\x00\x00\xa8\x80\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x02\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa8\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x88\x10\x00\x80\x98\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xc1\x40\x44\xff\xbf\xf8\x83\x00\x00\x02\x1e\x00\xa8\xc2\x99\xff\xff\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x30\x10\xd1\xff\x2f\xfe\x20\x00\x90\x80\x0f\x01\xaa\xf8\xff\xff\x7f\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x01\x10\xfd\x7c\xc2\x0f\x30\x00\x01\xb8\x10\xa2\x82\xdf\xe1\x00\x40\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xc1\x40\x44\xff\xbf\xf8\x83\x00\x00\x02\x1e\x00\xa8\xc2\x99\xff\xff\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x30\x10\xd1\xff\x2f\xfe\x20\x00\x80\x80\x07\x00\xaa\x70\xe6\xff\x7f\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x0c\x44\xf4\xff\x8b\x3f\x08\x00\x20\xe0\x01\x80\x2a\x9c\xf9\xff\x5f\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x01\x10\xfc\x7c\xc2\x0f\x30\x00\x01\xb8\x10\xa2\x82\xdf\xe1\x00\x40\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x20\x40\x00\x00\x60\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x04\x40\xf0\xf3\x09\x3f\x00\x00\x00\x00\x00\x08\x02\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x01\x10\xfd\x7c\xc2\x0f\x30\x00\x01\xb8\x10\xa2\x82\xdf\xe9\x00\x40\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x40\x00\x44\x3f\x9f\xf0\x03\x0c\x40\x00\x2e\x84\xa8\xe0\x77\x3a\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x40\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x04\x40\xf4\xff\x09\x3f\x00\x00\x00\x00\x00\x00\x02\x08\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x40\x00\x44\xff\x9f\xf0\x03\x00\x00\x00\x00\x00\x20\x80\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x10\x00\xd1\xff\x27\xfc\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x01\x10\xfd\x7c\xc2\x0f\x30\x00\x01\xb8\x10\xa2\x82\xdf\xe9\x00\x40\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x10\x00\xd1\xff\x27\xfc\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x04\x40\xf4\xff\x09\x3f\x00\x00\x00\x00\x00\x00\x02\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07\x03\x11\xfd\xff\xe2\x0f\x02\x00\x08\x78\x00\xa0\x0a\x67\xfe\xff\xd7\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xc1\x40\x44\xff\xbf\xf8\x83\x00\x00\x02\x1e\x00\xa8\xc2\x99\xff\xff\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x08\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x04\x40\xf4\xff\x09\x3f\x00\x00\x00\x00\x00\x80\x0a\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x01\x10\xfd\x7f\xc2\x0f\x00\x00\x00\x00\x00\xa0\x02\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x04\x40\xf4\xff\x09\x3f\x00\x00\x00\x00\x00\x80\x0a\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xc1\x40\x44\xff\xbf\xf0\x03\x00\x00\x02\x1c\x00\xa8\xc2\x99\xff\xff\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x80\x00\x01\x00\x80\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xdf\x7c\xd5\xff\xbf\xfc\xdf\x33\x08\x02\x1e\x00\xa8\xc2\x99\xff\xff\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x04\x48\xf5\xff\x49\x3f\x00\x00\x00\x00\x00\x00\x02\x99\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x0c\x44\xf4\xff\x8b\x3f\x00\x00\x20\xe0\x01\x80\x2a\x9c\xf9\xff\x5f\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x01\x10\xfd\x7f\xc2\x0f\x00\x00\x00\x00\x00\x80\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x40\x00\x44\xff\x9f\xf0\x03\x00\x00\x00\x00\x00\x20\x80\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x04\x40\xf4\xff\x09\x3f\x00\x00\x00\x00\x00\x00\x02\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x40\x00\x44\x3f\x9f\xf0\x03\x0c\x40\x00\x2e\x84\xa8\xe0\x77\x3a\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x04\x40\xf4\xf3\x09\x3f\xc0\x00\x04\xe0\x42\x88\x0a\x7e\xa7\x03\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x01\x10\xfc\x7c\xc2\x0f\x00\x00\x00\x00\x00\x82\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x01\x10\xfd\x7c\xc2\x0f\x30\x00\x01\xb8\x10\xa2\x82\xdf\xe9\x00\x40\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x40\x00\x44\x3f\x9f\xf0\x03\x0c\x40\x00\x2e\x84\xa8\xe0\x77\x3a\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x01\x10\xfd\x7c\xc2\x0f\x30\x00\x01\xb8\x10\xa2\x82\xdf\xe9\x00\x40\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x04\x40\xf0\xf3\x09\x3f\x00\x00\x00\x02\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x04\x40\xf4\xf3\x09\x3f\xc0\x00\x04\xe0\x42\x88\x0a\x7e\xa7\x03\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x01\x10\xfc\x7c\xc2\x0f\x00\x00\x00\x00\x00\x82\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x40\x00\x44\x3f\x9f\xf0\x03\x0c\x40\x00\x2e\x84\xa8\xe0\x77\x3a\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x01\x10\xfd\x7c\xc2\x0f\x30\x00\x01\xb8\x10\xa2\x82\xdf\xe9\x00\x40\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x30\x17\xd1\xff\x2f\xff\x27\x08\x82\x80\x07\x00\xaa\x70\xe6\xff\x7f\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x0c\x44\xf4\xff\x8b\x3f\x08\x00\x20\xe0\x01\x80\x2a\x9c\xf9\xff\x5f\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x10\x00\xd1\xcf\x27\xfc\x00\x03\x10\x80\x0b\x21\x2a\xf8\x9d\x0e\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x22\x42\x00\x00\x62\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07\x03\x11\xfd\xff\xe3\x0f\x02\x00\x08\x78\x00\xa0\x0a\x67\xfe\xff\xd7\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x30\x10\xd1\xff\x2f\xfe\x20\x00\x80\x80\x07\x00\xaa\x70\xe6\xff\x7f\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xc1\x40\x44\xff\xbf\xf8\x83\x00\x00\x02\x1e\x00\xa8\xc2\x99\xff\xff\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07\x03\x11\xfd\xff\xe2\x0f\x02\x00\x08\x78\x00\xa0\x2a\x67\xfe\xff\xd7\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xc1\x40\x44\xff\xbf\xf8\x83\x00\x00\x02\x1e\x00\xa8\xc2\x99\xff\xff\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x30\x10\xd1\xff\x2f\xfe\x20\x00\x80\x80\x07\x00\xaa\x70\xe6\xff\x7f\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x0c\x44\xf4\xff\x8b\x3f\x08\x00\x20\xe0\x01\x80\x2a\x9c\xf9\xff\x5f\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x0c\x44\xf4\xff\x8b\x3f\x08\x00\x24\xe0\x43\x80\x2a\xfe\xff\xff\x5f\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x01\x10\xfd\x7f\xc2\x0f\x00\x80\x00\x00\x00\x80\x00\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x04\x40\xf4\xf3\x09\x3f\xc0\x00\x04\xe0\x42\x88\x0a\x7e\xa7\x03\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x10\x00\xd1\xcf\x27\xfc\x00\x03\x10\x80\x0b\x21\x2a\xf8\x9d\x0e\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x01\x10\xfd\x7c\xc2\x0f\x30\x00\x01\xb8\x10\xa2\x82\xdf\xe9\x00\x40\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x10\x00\xc1\xc1\x27\xfc\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\xc0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xc1\x40\x44\xff\xbf\xf8\x83\x00\x00\x02\x1e\x00\xa8\xc2\x99\xff\xff\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x30\x10\xd1\xff\x2f\xfe\x20\x00\x80\x80\x07\x00\xaa\x70\xe6\xff\x7f\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x0c\xc4\xf4\xff\x8b\x3f\x08\x00\x20\xe0\x01\x80\x2a\x9c\xf9\xff\x5f\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07\x03\x31\xfd\xff\xe2\x0f\x02\x00\x08\x78\x00\xa0\x0a\x67\xfe\xff\xd7\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xc1\x40\x44\xff\xbf\xf8\x83\x00\x00\x02\x1e\x00\xa8\xc2\x99\xff\xff\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x40\x00\x04\x3f\x9f\xf0\x03\x0c\x40\x00\x2e\x84\xa8\xe0\x77\x38\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x10\x00\xc1\xcf\x27\xfc\x00\x03\x10\x80\x0b\x21\x2a\xf8\x1d\x0e\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x04\x40\xf0\xf3\x09\x3f\x00\x00\x00\x00\x00\x08\x02\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\xc0\x00\x00\x00\x00\x00\x00\x80\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xc1\x40\x44\xff\xbf\xf8\x83\x00\x00\x02\x1e\x00\xa8\xc2\x99\xff\xff\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdc\xcc\x45\xf5\xff\xcb\xff\x09\x82\x20\xe0\x01\x80\x2a\x9c\xf9\xff\x5f\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x73\x51\xfd\xff\xf2\x7f\x82\x20\x08\x78\x00\xa0\x0a\x67\xfe\xff\xd7\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x73\x55\xfd\xff\xf2\x7f\x82\x20\x08\x78\x00\xa0\x0a\x67\xfe\xff\xd7\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xc5\x5c\x55\xff\xbf\xfc\x9f\x20\x08\x02\x1e\x00\xa8\xc2\x99\xff\xff\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x10\x00\xc1\xcf\x27\xfc\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x01\x10\xfc\x7c\xc2\x0f\x30\x00\x01\xb8\x10\xa2\x82\xdf\xe1\x00\x40\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x10\x00\xd1\xcf\x27\xfc\x00\x03\x10\x80\x0b\x21\x2a\xf8\x9d\x0e\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x40\x00\x44\xff\x9f\xf0\x03\x00\x00\x00\x00\x00\x20\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x10\x00\xd1\xff\x27\xfc\x00\x00\x00\x00\x00\x00\x08\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x01\x10\xfd\x7f\xc2\x0f\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x01\x22\x04\x00\x20\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2a\x40\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x20\x42\x00\x00\x60\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x10\x04\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x10\x00\xd5\xff\x27\xfc\x00\x00\x08\x00\x00\x00\x08\x60\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x04\x48\xf5\xff\x49\x3f\x00\x00\x00\x00\x00\x00\x02\x98\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xc1\x40\x44\xff\xbf\xf8\x83\x00\x00\x02\x1e\x00\xa8\xc2\x99\xff\xff\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xc1\x5c\x44\xff\xbf\xfc\x9f\x20\x08\x02\x1e\x00\xa8\xc2\x99\xff\xff\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x30\x17\xd1\xff\x2f\xff\x27\x08\x82\x80\x07\x00\xaa\x70\xe6\xff\x7f\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x40\x00\x44\x3f\x9f\xf0\x03\x0c\x40\x00\x2e\x84\xa8\xe0\x77\x3a\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x01\x10\xfc\x7c\xc2\x0f\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x30\x10\xd1\xff\x2f\xfe\x00\x00\x80\x80\x07\x00\xaa\x70\xe6\xff\x7f\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x04\x42\xf4\xf7\x09\x3f\xc0\x00\x04\xe0\x42\x88\x0a\x7e\x87\x03\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x04\x40\xf4\xf3\x09\x3f\xc0\x00\x04\xe0\x42\x88\x0e\x7e\xa7\x03\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x10\x00\xc1\xcf\x27\xfc\x00\x03\x10\x80\x0b\x21\x2a\xf8\x1d\x0e\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x40\x00\x44\x3f\x9f\xf0\x03\x0c\x40\x00\x2e\x84\xa8\xe0\x77\x3a\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x30\x10\xd1\xff\x2f\xfe\x20\x00\x80\x80\x07\x00\xaa\x70\xe6\xff\x7f\x7d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x0c\x44\xf4\xff\x8b\x3f\x08\x00\x20\xe0\x01\x80\x2a\x9c\xf9\xff\x5f\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07\x03\x11\xfd\xff\xe2\x0f\x02\x00\x08\x78\x00\xa0\x0a\x67\xfe\xff\xd7\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xc1\x40\x44\xff\xbf\xf8\x83\x00\x40\x02\x3e\x04\xa8\xe2\xff\xff\xff\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x10\x00\xc1\xc1\x27\xfc\x00\x00\x00\x00\x00\x00\x00\x60\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x10\x00\xc1\xc1\x27\xfc\x00\x00\x00\x00\x00\x00\x00\x60\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07\x03\x11\xfd\xff\xe2\x0f\x02\x00\x08\x78\x00\xa0\x0a\x67\xfe\xff\xd7\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x40\x00\x04\x3f\x9f\xf0\x03\x0c\x40\x00\x2e\x84\xa8\xe0\x77\x38\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2a\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xcd\x5c\x54\xff\xbf\xfc\x9f\x20\x08\x02\x1e\x00\xa8\xc2\x99\xff\xff\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x01\x10\xfd\x7c\xc2\x0f\x30\x00\x01\xb8\x10\xa2\x82\xdf\xe1\x00\x40\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x40\x00\x04\x3f\x9f\xf0\x03\x0c\x40\x00\x2e\x84\xa8\xe0\x77\x38\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x80\x08\x01\x00\x88\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x04\x40\xf0\xf3\x09\x3f\xc0\x00\x04\xe0\x42\x88\x0a\x7e\x87\x03\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\xcc\x55\xf5\xff\xcb\xff\x09\x82\x20\xe0\x01\x80\x2a\x9c\xf9\xff\x5f\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x01\x10\xfd\x7c\xc2\x0f\x30\x00\x01\xb8\x10\xa2\x82\xdf\xe1\x00\x40\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x40\x00\x44\x3f\x9f\xf0\x03\x0c\x60\x00\x2e\x84\xa8\xe0\x77\x38\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x10\x00\xd1\xcf\x27\xfc\x00\x03\x18\x80\x0b\x21\x2a\xf8\x1d\x0e\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x04\x40\xf0\xf3\x09\x3f\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x01\x10\xfd\x7c\xc2\x0f\x30\x00\x01\xb8\x10\xa2\x82\xdf\xe9\x00\x40\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x01\x10\xfd\x7f\xc2\x0f\x00\x00\x00\x00\x00\x80\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x40\x00\x44\x3f\x9f\xf0\x03\x0c\x40\x00\x2e\x84\xa8\xe0\x77\x3a\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x40\x00\x54\xff\x9f\xf0\x03\x00\x20\x00\x00\x00\x20\x80\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x10\x00\xc1\xcf\x27\xfc\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x40\x00\x44\x3f\x9f\xf0\x03\x0c\x40\x00\x2e\x84\xa8\xe0\x77\x38\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x40\x00\x44\x3f\x9f\xf0\x03\x0c\x40\x00\x2e\x84\xa8\xe0\x77\x3a\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x40\x00\x44\x3f\x9f\xf0\x03\x0c\x40\x00\x2e\x84\xa8\xe0\x77\x3a\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x10\x00\xd1\xcf\x27\xfc\x00\x03\x10\x80\x0b\x21\x2a\xf8\x9d\x0e\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x40\x00\x44\x3f\x9f\xf0\x03\x0c\x40\x00\x2e\x84\xa8\xe0\x77\x3a\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x01\x10\xfc\x7c\xc2\x0f\x30\x00\x01\xb8\x10\xa2\x82\xdf\xe1\x00\x40\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\xc1\x40\x44\xff\xbf\xf8\x83\x00\x00\x02\x1e\x00\xa8\xc2\x99\xff\xff\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x10\x00\xd1\xcf\x27\xfc\x00\x03\x10\x80\x0b\x21\x2a\xf8\x9d\x0e\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x40\x00\x44\x3f\x9f\xf0\x03\x0c\x40\x20\x2e\x84\xe8\xf0\x77\x3a\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x01\x10\xfc\x7c\xc2\x0f\x00\x00\x00\x00\x00\x80\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x10\x00\xd1\xcf\x27\xfc\x00\x03\x10\x80\x0b\x21\x2a\xf8\x1d\x0e\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x01\x52\xfd\x7f\xd2\x0f\x00\x00\x00\x00\x00\x80\x40\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x04\x48\xf5\xff\x49\x3f\x00\x00\x00\x00\x00\x00\x02\x99\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x01\x10\xfc\x7c\xc2\x0f\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x01\x10\x1c\x7c\xc2\x0f\x00\x00\x00\x00\x00\x00\x00\x0e\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#--{-# NOINLINE happyExpListPerState #-}-happyExpListPerState st =- token_strs_expected- where token_strs = ["error","%dummy","%start_parseModuleNoHaddock","%start_parseSignature","%start_parseImport","%start_parseStatement","%start_parseDeclaration","%start_parseExpression","%start_parsePattern","%start_parseTypeSignature","%start_parseStmt","%start_parseIdentifier","%start_parseType","%start_parseBackpack","%start_parseHeader","identifier","backpack","units","unit","unitid","msubsts","msubst","moduleid","pkgname","litpkgname_segment","HYPHEN","litpkgname","mayberns","rns","rn","unitbody","unitdecls","unitdecl","signature","module","missing_module_keyword","implicit_top","maybemodwarning","body","body2","top","top1","header","header_body","header_body2","header_top","header_top_importdecls","maybeexports","exportlist","exportlist1","export","export_subspec","qcnames","qcnames1","qcname_ext_w_wildcard","qcname_ext","qcname","semis1","semis","importdecls","importdecls_semi","importdecl","maybe_src","maybe_safe","maybe_pkg","optqualified","maybeas","maybeimpspec","impspec","prec","infix","ops","topdecls","topdecls_semi","topdecls_cs","topdecls_cs_semi","topdecl_cs","topdecl","cl_decl","ty_decl","standalone_kind_sig","sks_vars","inst_decl","overlap_pragma","deriv_strategy_no_via","deriv_strategy_via","deriv_standalone_strategy","opt_injective_info","injectivity_cond","inj_varids","where_type_family","ty_fam_inst_eqn_list","ty_fam_inst_eqns","ty_fam_inst_eqn","at_decl_cls","opt_family","opt_instance","at_decl_inst","data_or_newtype","opt_kind_sig","opt_datafam_kind_sig","opt_tyfam_kind_sig","opt_at_kind_inj_sig","tycl_hdr","datafam_inst_hdr","capi_ctype","stand_alone_deriving","role_annot","maybe_roles","roles","role","pattern_synonym_decl","pattern_synonym_lhs","vars0","cvars1","where_decls","pattern_synonym_sig","qvarcon","decl_cls","decls_cls","decllist_cls","where_cls","decl_inst","decls_inst","decllist_inst","where_inst","decls","decllist","binds","wherebinds","rules","rule","rule_activation","rule_activation_marker","rule_explicit_activation","rule_foralls","rule_vars","rule_var","warnings","warning","deprecations","deprecation","strings","stringlist","annotation","fdecl","callconv","safety","fspec","opt_sig","opt_tyconsig","sigktype","sigtype","sig_vars","sigtypes1","unpackedness","forall_telescope","ktype","ctype","context","type","mult","btype","infixtype","ftype","tyarg","tyop","atype","inst_type","deriv_types","comma_types0","comma_types1","bar_types2","tv_bndrs","tv_bndr","tv_bndr_no_braces","fds","fds1","fd","varids0","kind","gadt_constrlist","gadt_constrs","gadt_constr","constrs","constrs1","constr","forall","constr_stuff","fielddecls","fielddecls1","fielddecl","maybe_derivings","derivings","deriving","deriv_clause_types","decl_no_th","decl","rhs","gdrhs","gdrh","sigdecl","activation","explicit_activation","quasiquote","exp","infixexp","exp10p","exp10","optSemi","prag_e","fexp","aexp","aexp1","aexp2","projection","splice_exp","splice_untyped","splice_typed","cmdargs","acmd","cvtopbody","cvtopdecls0","texp","tup_exprs","commas_tup_tail","tup_tail","list","lexps","flattenedpquals","pquals","squals","transformqual","guardquals","guardquals1","altslist","alts","alts1","alt","alt_rhs","ralt","gdpats","ifgdpats","gdpat","pat","bindpat","apat","apats","stmtlist","stmts","maybe_stmt","e_stmt","stmt","qual","fbinds","fbinds1","fbind","fieldToUpdate","dbinds","dbind","ipvar","overloaded_label","name_boolformula_opt","name_boolformula","name_boolformula_and","name_boolformula_and_list","name_boolformula_atom","namelist","name_var","qcon_nowiredlist","qcon","gen_qcon","con","con_list","sysdcon_nolist","sysdcon","conop","qconop","gtycon","ntgtycon","oqtycon","oqtycon_no_varcon","qtyconop","qtycon","tycon","qtyconsym","tyconsym","otycon","op","varop","qop","qopm","hole_op","qvarop","qvaropm","tyvar","tyvarop","tyvarid","var","qvar","field","qvarid","varid","qvarsym","qvarsym_no_minus","qvarsym1","varsym","varsym_no_minus","special_id","special_sym","qconid","conid","qconsym","consym","literal","close","modid","commas","bars0","bars","exp_prag__exp__","exp_prag__exp10p__","'_'","'as'","'case'","'class'","'data'","'default'","'deriving'","'else'","'hiding'","'if'","'import'","'in'","'infix'","'infixl'","'infixr'","'instance'","'let'","'module'","'newtype'","'of'","'qualified'","'then'","'type'","'where'","'forall'","'foreign'","'export'","'label'","'dynamic'","'safe'","'interruptible'","'unsafe'","'family'","'role'","'stdcall'","'ccall'","'capi'","'prim'","'javascript'","'proc'","'rec'","'group'","'by'","'using'","'pattern'","'static'","'stock'","'anyclass'","'via'","'unit'","'signature'","'dependency'","'{-# INLINE'","'{-# SPECIALISE'","'{-# SPECIALISE_INLINE'","'{-# SOURCE'","'{-# RULES'","'{-# SCC'","'{-# DEPRECATED'","'{-# WARNING'","'{-# UNPACK'","'{-# NOUNPACK'","'{-# ANN'","'{-# MINIMAL'","'{-# CTYPE'","'{-# OVERLAPPING'","'{-# OVERLAPPABLE'","'{-# OVERLAPS'","'{-# INCOHERENT'","'{-# COMPLETE'","'#-}'","'..'","':'","'::'","'='","'\\\\'","'lcase'","'|'","'<-'","'->'","'->.'","TIGHT_INFIX_AT","'=>'","'-'","PREFIX_TILDE","PREFIX_BANG","PREFIX_MINUS","'*'","'-<'","'>-'","'-<<'","'>>-'","'.'","PREFIX_PROJ","TIGHT_INFIX_PROJ","PREFIX_AT","PREFIX_PERCENT","'{'","'}'","vocurly","vccurly","'['","']'","'('","')'","'(#'","'#)'","'(|'","'|)'","';'","','","'`'","SIMPLEQUOTE","VARID","CONID","VARSYM","CONSYM","QVARID","QCONID","QVARSYM","QCONSYM","DO","MDO","IPDUPVARID","LABELVARID","CHAR","STRING","INTEGER","RATIONAL","PRIMCHAR","PRIMSTRING","PRIMINTEGER","PRIMWORD","PRIMFLOAT","PRIMDOUBLE","'[|'","'[p|'","'[t|'","'[d|'","'|]'","'[||'","'||]'","PREFIX_DOLLAR","PREFIX_DOLLAR_DOLLAR","TH_TY_QUOTE","TH_QUASIQUOTE","TH_QQUASIQUOTE","%eof"]- bit_start = st Prelude.* 470- bit_end = (st Prelude.+ 1) Prelude.* 470- read_bit = readArrayBit happyExpList- bits = Prelude.map read_bit [bit_start..bit_end Prelude.- 1]- bits_indexed = Prelude.zip bits [0..469]- token_strs_expected = Prelude.concatMap f bits_indexed- f (Prelude.False, _) = []- f (Prelude.True, nr) = [token_strs Prelude.!! nr]--happyActOffsets :: HappyAddr-happyActOffsets = HappyA# "\x39\x00\x54\x00\x5e\x00\x14\x2a\x05\x1e\xf3\x2c\xf3\x2c\x0f\x26\x14\x2a\xe0\x44\x65\x3d\x5a\x00\x56\x01\x9d\x52\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc2\x03\x00\x00\x00\x00\x00\x00\xc5\x00\x00\x00\x51\x01\x51\x01\x00\x00\x75\x00\x16\x01\x16\x01\xc0\x42\x65\x3d\xc7\x00\x21\x01\x2a\x01\x00\x00\x01\x1a\x00\x00\x42\x18\x00\x00\x00\x00\x00\x00\x00\x00\x38\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x18\x00\x00\x6c\x19\x00\x00\x00\x00\x00\x00\x00\x00\x94\x5d\x00\x00\x00\x00\x00\x00\x73\x01\xa7\x01\x00\x00\x00\x00\x39\x43\x39\x43\x00\x00\x00\x00\xe4\x5c\x76\x3b\xf6\x39\x76\x3a\xc9\x47\x45\x45\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x63\x39\x00\x00\x00\x00\x68\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4e\x01\xe5\x02\xd8\x01\x69\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x02\x2b\x1b\x00\x00\xf3\x2c\xc0\x1b\x00\x00\x4b\x03\x00\x00\x00\x00\x00\x00\x16\x02\x85\x01\x00\x00\x00\x00\x18\x17\x00\x00\x00\x00\x37\x02\x00\x00\x00\x00\x00\x00\xf3\x2c\xee\x28\xcb\x01\xdc\x37\xa5\x02\xdc\x37\x40\x00\x23\x36\xb6\x36\xdc\x37\xdc\x37\xdc\x37\xa2\x26\x2b\x1f\xc3\x23\xdc\x37\x4a\x46\xa5\x02\xa5\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf3\x2c\x1e\x32\x65\x3d\x30\x04\xf3\x2c\x63\x39\xad\x17\x1f\x02\x00\x00\x14\x02\x70\x04\x4b\x02\x55\x02\x00\x00\x00\x00\x00\x00\x6d\x04\xf9\x02\x76\x46\xc2\x4e\x5d\x51\x9d\x52\x46\x5b\xf9\x02\x2b\x1f\x00\x00\x39\x02\x39\x02\x39\x02\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x06\xc0\x42\xb6\x02\x8b\x02\x0d\x02\x41\x04\x00\x00\xef\x3b\x7b\x00\xa1\x5b\x68\x02\xcd\x5b\xcd\x5b\x1a\x5b\x66\x02\x00\x00\x66\x02\xe6\x02\xa8\x02\x74\x01\xa8\x02\x00\x00\x00\x00\x74\x01\x00\x00\xe0\x02\xdc\x02\x75\x02\x00\x00\x00\x00\x55\x00\x75\x02\x3a\x03\x0c\x03\xdc\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdc\x37\x31\x01\xbf\x05\xfa\xff\x00\x00\x42\x01\xfa\x02\x34\x00\x00\x00\x42\x01\x36\x00\x00\x00\xb1\x32\x74\x02\xaf\x5c\x80\x03\x87\x00\xad\x01\x00\x00\x88\x05\x88\x05\x16\x00\x30\x03\x96\x1a\x42\x00\x5b\x40\xc0\x42\x4a\x02\x65\x3d\xc5\x03\xcc\x03\xd0\x03\xda\x03\x00\x00\x14\x04\x00\x00\x00\x00\x00\x00\x65\x3d\x65\x3d\xc0\x42\xd9\x03\xeb\x03\x00\x00\x45\x03\x00\x00\xf3\x2c\x00\x00\x00\x00\x65\x3d\xa8\x45\xc0\x42\x04\x04\xcb\x03\xff\x03\x4f\x48\xe6\x00\x9b\x01\xf4\x03\x00\x00\x44\x33\x00\x00\x00\x00\x00\x00\x10\x04\x16\x04\x24\x04\x33\x04\xe9\x24\x35\x27\x00\x00\xb6\x36\xe2\x03\x00\x00\x00\x00\xa8\x45\xfe\x03\x5a\x04\x62\x04\x00\x00\x5f\x04\x00\x00\x43\x04\x00\x00\xb5\x5a\x2c\x00\x9d\x52\x00\x00\xc1\x00\x9d\x52\x65\x3d\xd6\x46\x00\x00\xb0\x04\xc8\x27\xc8\x27\xe4\x5c\x65\x3d\x20\x06\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x04\xef\x03\x6b\x03\x00\x00\x00\x00\x2a\x04\x46\x04\x00\x00\x00\x00\x4d\x04\xcd\x05\x69\x04\x00\x00\x14\x2a\x14\x2a\x00\x00\x00\x00\x00\x00\xd8\x09\x00\x00\xde\x01\x60\x04\x00\x00\x00\x00\x7c\x25\x00\x00\x7d\x04\x3d\x01\x9c\x04\x73\x04\x00\x00\x00\x00\x00\x00\x00\x00\x55\x1c\x00\x00\xdc\x37\x78\x04\xb6\x04\xc4\x04\x00\x00\x00\x00\xd6\x04\x3b\x05\xe3\x04\x6a\x00\x00\x00\x00\x00\x86\x2d\x12\x05\x56\x05\xdc\x37\x19\x2e\x0b\x05\x89\x51\x00\x00\x39\x43\x00\x00\x65\x3d\x19\x2e\x19\x2e\x19\x2e\x19\x2e\x19\x05\x1c\x05\x79\x03\x38\x05\x48\x05\xed\x02\x52\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x3d\xf6\x3a\x9d\x47\x21\x05\x50\x05\xfc\xff\x16\x05\x5f\x05\x96\x03\x00\x00\x15\x03\x6f\x38\x25\x03\x6b\x05\x00\x00\x9b\x00\x00\x00\x9e\x00\x76\x05\x00\x00\x6e\x05\x00\x00\x3e\x01\x00\x00\x3d\x47\x00\x00\x00\x00\x00\x00\xb3\x00\x94\x5d\x00\x00\x00\x00\x8e\x4c\x8e\x4c\xc0\x42\x39\x43\x00\x00\xc0\x42\x00\x00\x39\x43\x93\x05\x65\x3d\x65\x3d\x39\x43\x65\x3d\x65\x3d\x00\x00\x00\x00\xb5\x02\x00\x00\x47\x44\x8f\x00\x00\x00\x78\x05\x75\x02\x75\x02\x00\x00\x8d\x05\x42\x01\x42\x01\x8d\x05\x00\x00\x00\x00\xde\x05\x00\x00\x00\x00\x00\x00\x00\x00\xd3\x05\xf6\x05\x18\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x3d\x00\x00\x00\x00\x00\x00\x00\x00\xd6\x05\xd1\x01\x00\x00\x00\x00\x00\x00\xc0\x05\xe4\x5c\x00\x00\x65\x3d\xe4\x5c\x00\x00\x65\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x3d\x00\x00\x00\x00\x00\x00\x65\x3d\x65\x3d\x00\x00\x00\x00\xbb\x05\xc2\x05\xcc\x05\xd5\x05\xda\x05\xdf\x05\xe1\x05\xe9\x05\xff\x05\xf0\x05\x0c\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x06\x00\x00\x0a\x06\x38\x06\x2c\x06\x00\x00\x3b\x06\x00\x00\x00\x00\x00\x00\x00\x00\x78\x04\x3f\x01\x2e\x06\x23\x06\x00\x00\x00\x00\x00\x00\x88\x06\x00\x00\x19\x2e\x19\x2e\x00\x00\x00\x00\x00\x00\x81\x29\xea\x1c\xdc\x37\x57\x06\x5b\x28\x00\x00\x19\x2e\xa7\x2a\x5b\x28\x00\x00\x3e\x06\x00\x00\x00\x00\x00\x00\x56\x24\x62\x06\x00\x00\x49\x37\x19\x01\x00\x00\xdd\x02\x00\x00\x00\x00\x00\x00\x00\x00\x05\x1e\x55\x00\x51\x06\x00\x00\x00\x00\x00\x00\x4d\x06\x00\x00\x48\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf4\x49\x00\x00\x00\x00\x0d\x01\x1c\x01\x00\x00\x00\x00\xaf\x0b\x00\x00\xbe\x1f\x51\x20\x1e\x01\x00\x00\xe4\x20\xf8\x02\x0f\x03\x72\x06\x00\x00\x00\x00\x00\x00\x73\x06\x6e\x06\x3f\x06\x00\x00\x00\x00\x54\x06\x74\x06\x00\x00\x79\x06\x58\x06\x59\x06\x28\x5c\x28\x5c\x00\x00\x7c\x06\x31\x03\xf9\x02\x55\x06\x5c\x06\x00\x00\x76\x06\x00\x00\x5a\x06\xa0\x0a\x00\x00\x00\x00\x5b\x06\x00\x00\x19\x2e\x5b\x28\x2d\x00\xd6\x40\xe8\x02\x4f\x03\x00\x00\x00\x00\x19\x2e\x00\x00\x00\x00\x30\x00\x00\x00\x19\x2e\xac\x2e\xc0\x42\xb8\x06\x00\x00\x8d\x06\x78\x06\x00\x00\x00\x00\x93\x06\x41\x04\x00\x00\x00\x00\x00\x00\x00\x00\xc7\x06\x2f\x00\xfc\x01\x6f\x03\x00\x00\x97\x06\x94\x5d\x65\x3d\x65\x3d\x4a\x02\xb4\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\x43\xb0\x4b\x80\x06\x65\x3d\x00\x00\xb0\x4b\xe4\x5c\x3f\x2f\x3f\x2f\xd7\x33\x00\x00\x10\x01\x00\x00\x68\x06\x00\x00\x6c\x06\x00\x00\x00\x00\x54\x5c\x54\x5c\x00\x00\x00\x00\x54\x5c\x00\x00\xdc\x37\x6e\x01\xa5\x06\xa8\x06\x00\x00\xdf\x06\x00\x00\x90\x06\x00\x00\x90\x06\x00\x00\x00\x00\xea\x06\x00\x00\x9d\x06\x00\x00\x05\x1e\xe6\x06\xd4\x45\xe9\x06\x86\x06\x00\x00\x00\x00\x00\x00\x9f\x06\xc2\x06\x00\x00\x00\x00\x00\x00\x9f\x00\x00\x00\x00\x00\xb0\x01\xa6\x06\x6a\x34\x10\x5d\xf4\x06\x00\x00\xab\x06\xa0\x06\x00\x00\x00\x00\xa1\x06\x00\x00\x1b\x44\x00\x00\xc6\x06\xc8\x06\xc9\x06\xcc\x06\x3c\x5d\x00\x00\x00\x00\x00\x00\x00\x00\xba\x06\x65\x3d\xca\x06\x65\x3d\x94\x5d\x00\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x96\x04\x65\x3d\x65\x3d\x00\x00\x00\x00\x65\x3d\xaa\x06\x00\x00\x1f\x4c\x00\x00\xa5\x04\x00\x00\xcf\x06\x03\x07\x00\x00\x00\x00\xac\x04\x00\x00\x04\x07\x16\x07\x65\x3d\x07\x07\x17\x04\xce\x06\x00\x00\x94\x5d\x00\x00\xdd\x06\x00\x00\x00\x00\x00\x00\xd7\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x3d\x00\x00\xc0\x06\x65\x3d\x00\x00\x00\x00\x00\x00\xad\x06\x00\x00\xc8\x27\x3f\x2f\x00\x00\x00\x00\x65\x3d\x20\x06\x00\x00\x00\x00\xc5\x06\x00\x00\x3a\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x01\x00\x00\x00\x00\x00\x00\xa3\x01\x00\x00\x00\x00\xd2\x2f\x00\x00\x00\x00\x65\x30\x00\x00\x55\x00\xd1\x06\x00\x00\xa0\x03\x00\x00\xcd\x2b\xd2\x06\x00\x00\x00\x00\x00\x00\x65\x30\xf8\x30\x8b\x31\x00\x00\x00\x00\xd0\x06\x5b\x28\x89\x51\x00\x00\x00\x00\x65\x3d\x00\x00\x00\x00\xdc\x06\x00\x00\xd3\x06\xd9\x06\x00\x00\x00\x00\x00\x00\x00\x00\x65\x3d\x00\x00\x65\x3d\x00\x00\x41\x4b\x00\x00\x00\x00\x00\x00\xbb\x04\x00\x00\x20\x07\xfa\x06\xfc\x06\x2d\x07\xf9\x04\x00\x00\x00\x00\xf9\x04\x00\x00\x4c\x01\x4c\x01\x00\x00\xe0\x06\xe8\x06\x00\x00\x00\x00\xe3\x06\x00\x00\x00\x00\x52\x01\x00\x00\x00\x00\x00\x00\xe7\x06\x00\x00\x00\x00\x00\x00\x3e\x07\x0b\x07\x8b\x31\x8b\x31\x00\x00\x00\x00\x2f\x07\x98\x1e\x60\x2c\x60\x2c\x8b\x31\x00\x00\xee\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x07\xf6\x06\x21\x07\x00\x00\x25\x07\x00\x00\x13\x07\xc0\x42\x5b\x07\x6d\x07\x27\x07\x00\x00\xc0\x42\x94\x5d\x00\x00\x00\x00\x6f\x07\x00\x00\x73\x02\x6f\x07\x02\x05\x00\x00\x00\x00\x8b\x31\x00\x00\x77\x21\x77\x21\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x22\x0a\x22\x00\x00\x00\x00\x00\x00\x67\x07\x8e\x4c\x00\x00\xc0\x42\x36\x07\x65\x3d\x00\x00\x00\x00\x3c\x5d\x00\x00\x00\x00\x18\x05\x26\x07\x68\x5d\x00\x00\xb0\x4b\x99\x0c\x00\x00\x00\x00\x1b\x07\x00\x00\x05\x07\x00\x00\x00\x00\x91\x03\x00\x00\x61\x05\x23\x07\x1e\x07\x00\x00\x22\x07\x00\x00\x00\x00\x00\x00\x00\x00\x91\x03\x4a\x02\xb8\x04\x8e\x03\x00\x00\x61\x05\x24\x07\x00\x00\x28\x07\x00\x00\x28\x07\x00\x00\x00\x00\x00\x00\x2a\x07\x31\x07\x33\x07\x00\x00\xa2\x02\x00\x00\x00\x00\x00\x00\x02\x47\x0e\x46\x00\x00\x00\x00\x7a\x07\x00\x00\x00\x00\x8b\x31\x46\x07\x00\x00\xfd\x34\xc8\x27\xc8\x27\x00\x00\x00\x00\x65\x3d\x4d\x07\x00\x00\x41\x07\x00\x00\x6f\x05\x00\x00\x8d\x07\x00\x00\x37\x01\x00\x00\x00\x00\x8d\x07\x17\x03\x00\x00\x8e\x4c\x00\x00\x00\x00\x4b\x01\x00\x00\x7e\x07\x90\x35\x6a\x3c\x27\x03\x00\x00\x79\x04\x79\x04\x00\x00\x81\x02\x70\x07\x00\x00\x00\x00\x00\x00\x00\x00\xe5\x3c\x00\x00\x43\x07\x57\x07\x00\x00\x58\x07\x00\x00\x93\x07\x00\x00\xa6\x07\x00\x00\xc0\x42\x00\x00\x00\x00\x65\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x8b\x31\x8b\x31\x8b\x31\x00\x00\x00\x00\x00\x00\xa7\x07\x5b\x28\x3c\x07\x00\x00\x00\x00\x00\x00\x61\x01\x00\x00\x78\x07\x91\x03\x7b\x44\x35\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x01\x49\x07\x4f\x07\x9b\x44\x82\x01\x91\x03\x00\x00\x00\x00\x00\x00\x8b\x31\x00\x00\x00\x00\x8b\x07\x00\x00\x66\x07\x00\x00\x00\x00\x00\x00\xc0\x42\x00\x00\x4c\x07\x53\x07\x00\x00\x00\x00\x00\x00\x55\x00\x4a\x07\xf9\x02\x5e\x07\x00\x00\x9d\x22\x00\x00\x1f\x04\x51\x41\xc0\x42\x83\x0d\xc0\x42\x00\x00\x00\x00\x00\x00\x30\x23\x51\x41\x00\x00\x00\x00\x7d\x07\x00\x00\xe5\x3d\x60\x3e\x8e\x4c\xdb\x3e\x00\x00\x77\x01\x46\x03\x68\x5d\xdb\x3e\x00\x00\xc4\x07\x00\x00\x63\x07\x5f\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x6a\x07\x00\x00\x00\x00\x02\x47\x00\x00\x26\x00\x91\x03\x68\x07\x72\x07\x00\x00\x00\x00\x00\x00\x8e\x4c\x00\x00\x78\x01\x00\x00\x55\x00\x50\x03\x74\x07\xcc\x41\x00\x00\x00\x00\x86\x07\xdb\x3e\x4c\x04\x00\x00\x00\x00\xdb\x3e\x5b\x3f\x00\x00\x00\x00\x88\x07\x79\x04\x00\x00\x00\x00\xdb\x3f\x00\x00\x00\x00\xc0\x42\x8b\x31\x00\x00\x82\x01\x71\x07\x00\x00\x91\x03\x00\x00\x91\x03\x00\x00\x38\x03\x00\x00\xdb\x07\xca\x01\x00\x00\x0f\x00\xc8\x07\x7c\x07\x00\x00\x00\x00\x00\x00\x00\x00\xdb\x3f\x9c\x07\x7e\x1d\xf6\x39\x00\x00\x00\x00\xc0\x5d\x00\x00\x00\x00\x56\x04\x00\x00\x00\x00\x47\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x07\xd4\x45\x00\x00\x84\x07\xd4\x45\x00\x00\xd6\x07\xe8\x07\xe8\x38\x8e\x4c\x00\x00\xd8\x07\x96\x05\x8f\x39\x91\x03\x00\x00\x91\x03\x91\x03\x00\x00\x91\x03\x00\x00\x00\x00\x00\x00\x87\x07\xae\x07\x00\x00\x91\x03\x00\x00\x96\x05\x00\x00\x00\x00\xf7\x07\x97\x07\x00\x00\x00\x00\x00\x00\x00\x00\x8e\x07\x91\x03\x00\x00\x00\x00\x00\x00\x00\x00"#--happyGotoOffsets :: HappyAddr-happyGotoOffsets = HappyA# "\x0a\x04\xef\x07\xd5\x07\x40\x4e\x60\x01\xf8\x4d\x98\x52\x1f\x06\x88\x4e\x01\x00\xd9\x0e\xee\x01\xc8\x03\xf3\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x04\x00\x00\x00\x00\x10\x02\x00\x00\x00\x00\xd8\x06\xe1\x06\x5f\x02\x00\x00\xd3\x04\xe8\x04\xec\x07\x44\x12\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x07\x00\x00\x55\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb4\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x00\xb6\x03\x00\x00\x00\x00\x94\xff\x6c\x0f\xe8\x08\x8e\x08\x6a\x01\xb9\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3f\x04\xeb\x06\x87\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x0d\x00\x00\x2b\x53\xf7\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9a\x53\x03\x51\xa2\x04\x24\x5f\x1d\x07\x37\x5f\x00\x00\x3e\x5e\xa7\x5e\x64\x5f\xa4\x5f\xb4\x5f\x2a\x49\xcb\x47\xb5\x48\xf4\x5f\xc3\x07\x2b\x07\x2c\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaa\x53\x88\x48\x8d\x0f\x48\x07\x19\x54\xdb\x13\x5d\x07\xd9\x07\x00\x00\x00\x00\x84\x0d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xce\x04\xd3\x00\x88\x04\x42\x05\x62\x05\x0e\x04\x66\x06\xd7\x00\x40\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7c\x02\x65\x07\x00\x00\x00\x00\xe0\x05\xd4\x07\x00\x00\xd6\x01\x98\x07\xa5\xff\xc7\x05\xcd\x01\x94\x01\x33\x06\x00\x00\x00\x00\x00\x00\xed\x07\x00\x00\xf0\x06\x00\x00\xa6\x01\x00\x00\xf1\x06\x0a\x02\x00\x00\x7f\x02\x05\x08\x00\x00\x00\x00\xf3\x06\x0b\x08\xf3\x07\x00\x00\x21\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x34\x60\xec\x02\xde\x03\x00\x00\x00\x00\xb1\x07\x00\x00\x00\x00\x00\x00\xb7\x07\x00\x00\x00\x00\x8c\x05\x00\x00\xac\xff\x00\x00\x44\xff\x00\x03\x00\x00\xa3\x07\xaa\x07\x00\x00\x00\x00\x9f\x07\x00\x00\xa3\x02\x31\x14\xe9\x02\x39\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe2\x09\x86\x0d\x50\x14\x99\x07\x00\x00\x00\x00\xbd\x03\x00\x00\x42\x47\x00\x00\x00\x00\xb6\x0b\x87\x03\x94\x07\xde\x07\x00\x00\x00\x00\x49\x0f\x00\x00\xaf\xff\x00\x00\x00\x00\x3a\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x99\x49\x77\x4a\x00\x00\xa7\x5e\x1f\x07\x00\x00\x00\x00\xcf\x03\x00\x00\xb4\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0f\x07\x00\x00\x39\x04\x00\x00\xc9\x07\x54\x04\x75\x0a\xab\x00\x00\x00\x00\x00\xc2\x02\x0a\x03\xa2\xff\xf2\x0b\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x64\x01\x12\x07\x00\x00\x00\x00\x00\x00\x00\x00\xef\xff\xf4\xff\x00\x00\x6a\x0f\x00\x00\x00\x00\xd0\x4e\x18\x4f\x00\x00\x00\x00\x00\x00\x3f\x04\x75\x07\xaf\xff\x00\x00\x00\x00\x00\x00\x99\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x60\x00\x00\xc7\x5d\x6c\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x07\x56\xff\x00\x00\x00\x00\x60\x4f\x28\x05\x00\x00\xa1\x60\x29\x54\x2e\x07\xef\x00\x00\x00\x34\x04\x00\x00\x8d\x12\x98\x54\xa8\x54\x17\x55\x27\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc6\x0d\x45\x08\x7b\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x04\x00\x00\x9b\x06\x00\x00\x00\x00\x00\x00\x00\x00\xc6\xff\x00\x00\x00\x00\x7c\x01\x3d\x02\x7b\x14\xaa\x04\x00\x00\x0b\x10\x00\x00\xea\x04\x00\x00\xab\x12\xe7\x12\xf3\x04\x3a\x13\xc1\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x30\x07\x00\x00\xb0\x02\x36\x08\x37\x08\x00\x00\x2e\x08\xda\x07\xdc\x07\x3a\x08\x00\x00\x00\x00\x29\x08\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x08\x00\x00\x58\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0\xff\x00\x00\x76\x13\xbb\x01\x00\x00\xdb\x0d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x0e\x00\x00\x00\x00\x00\x00\x6e\x0e\x90\x0e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x07\x7f\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x96\x55\xa6\x55\x00\x00\x00\x00\x00\x00\xaf\x4f\x60\x4d\x2e\x5e\x00\x00\xe6\x4a\x00\x00\x15\x56\x11\x4d\x55\x4b\x00\x00\x63\xff\x00\x00\x00\x00\x00\x00\x08\x4a\x00\x00\x00\x00\xb7\x5e\x3b\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x3f\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x02\x00\x00\x00\x00\x00\x00\x4e\x07\x00\x00\x00\x00\x7c\x02\x00\x00\x00\x00\x00\x00\x59\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x04\x3c\x08\x00\x00\x00\x00\x53\x03\x43\x02\x00\x00\x00\x00\x00\x00\x1d\x05\x00\x00\x00\x00\x6a\x0f\x00\x00\x00\x00\x5c\x07\x00\x00\x42\x47\xc4\x4b\x00\x00\xb2\x07\xec\xff\x00\x00\x00\x00\x00\x00\x59\x47\x00\x00\x00\x00\xc7\xff\x00\x00\x25\x56\xf7\x4f\xbb\x14\x0c\x08\x23\x04\x26\x08\x00\x00\x00\x00\x00\x00\x00\x00\x42\x08\x00\x00\x00\x00\x00\x00\x00\x00\x19\x08\xec\x04\x49\x05\x32\x08\x00\x00\x00\x00\xdb\x00\x20\x10\x1e\x0a\x3b\x03\x8f\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xda\xff\xad\x02\x61\x07\x0d\x0c\x00\x00\xc5\xff\xce\xff\xac\x52\x1b\x53\x14\x08\x00\x00\x17\x08\x00\x00\x1a\x08\x00\x00\x11\x08\x00\x00\x00\x00\x18\x03\xd7\x05\x00\x00\x00\x00\x17\x00\x00\x00\xb1\x60\x89\x07\x00\x00\x00\x00\x00\x00\x63\x08\x00\x00\x79\x08\x00\x00\x7a\x08\x00\x00\x00\x00\xde\x02\x00\x00\x71\x08\x00\x00\x33\x01\x00\x00\x24\x00\x00\x00\x6d\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x5d\xa1\xff\x40\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xed\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x10\x5d\x08\x69\x10\x8b\xff\x00\x00\x47\x08\x00\x00\x00\x00\x00\x00\x00\x00\x3b\x08\xcc\x0a\xb3\x10\x00\x00\x00\x00\xfc\x10\x00\x00\x00\x00\x5b\x02\x00\x00\x3e\x08\x00\x00\x00\x00\x38\x08\x00\x00\x00\x00\x01\x06\x00\x00\x09\x08\xe4\x04\x1e\x11\xfa\x04\x04\x00\x00\x00\x00\x00\x2e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x0b\x00\x00\x00\x00\x23\x0b\x00\x00\x00\x00\x00\x00\x81\x05\x00\x00\xd2\x05\x94\x56\x00\x00\x00\x00\x49\x0c\x54\x03\x00\x00\x00\x00\x81\x08\x00\x00\x17\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x56\x00\x00\x00\x00\x13\x57\x00\x00\x85\x07\x00\x00\x00\x00\xd8\x04\x00\x00\x46\x50\x00\x00\x00\x00\x00\x00\x00\x00\x23\x57\x15\x52\x92\x57\x00\x00\x00\x00\x67\xff\x33\x4c\x88\x01\x00\x00\x00\x00\xc4\x0e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x52\x11\x00\x00\xb1\x11\x00\x00\x19\x00\x00\x00\x00\x00\x00\x00\xa1\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x96\x08\x00\x00\x00\x00\x97\x08\x00\x00\x6b\x06\x71\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf2\x07\x00\x00\x00\x00\x00\x00\x43\x08\xd3\x07\xa2\x57\x29\x52\x00\x00\x00\x00\x00\x00\x00\x00\xa9\x4d\x86\x51\x11\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xda\x14\x12\x08\x68\x05\x00\x00\x00\x00\xe4\x13\x69\x01\x00\x00\x00\x00\x15\x08\x00\x00\xc8\xff\x71\x05\x00\x00\x00\x00\x00\x00\x21\x58\x00\x00\x8c\x03\xd4\x03\x00\x00\x20\x08\xe2\x05\x00\x00\x00\x00\x00\x00\x00\x00\xd3\xff\x49\x02\x00\x00\x00\x00\x00\x00\x82\x08\xbe\xff\x00\x00\x05\x15\x00\x00\xa0\x0c\x00\x00\x00\x00\xd1\xff\x00\x00\x00\x00\x00\x00\x00\x00\xbd\xff\x00\x00\xba\x02\x6a\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x07\x00\x00\xae\x08\x00\x00\x00\x00\x00\x00\xab\x08\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x07\xb4\x03\xd5\x01\xbc\x04\x00\x00\xb9\x08\xb1\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x21\x02\x4f\x02\x00\x00\x00\x00\x00\x00\x00\x00\x02\x03\x00\x00\x00\x00\x00\x00\x50\x00\x44\x00\x00\x00\x00\x00\xac\x08\x00\x00\x00\x00\x90\x58\x00\x00\x00\x00\x00\x00\x11\x05\x8a\x05\x00\x00\x00\x00\xdc\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x98\x08\x00\x00\x92\x08\x00\x00\xb9\x07\x00\x00\x00\x00\x95\x08\x00\x00\x00\x00\x5b\x02\x00\x00\x00\x00\xbb\x07\x00\x00\x99\x08\xb7\x5d\x9a\x06\x00\x00\x00\x00\xf6\x01\x2b\x02\x00\x00\x7e\xff\xa6\x08\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf7\x05\x00\x00\xa9\x05\x00\x00\x1c\x14\x00\x00\x00\x00\x5f\x0b\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x58\x0f\x59\x1f\x59\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x4c\xd0\x07\x00\x00\x00\x00\x00\x00\xc2\x07\x00\x00\xc0\x08\xc5\x07\x0e\x00\x00\x00\x00\x00\x6f\x02\x8c\x02\x00\x00\x00\x00\x00\x00\x00\x00\xdf\x08\xe5\x08\x00\x00\x14\x00\xdd\x08\xcf\x07\x00\x00\x00\x00\x00\x00\x8e\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x63\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xca\x07\x00\x00\x4e\x02\x00\x00\x00\x00\xc9\x04\x00\x00\xa7\x08\xbc\x06\x1a\x15\x6a\x0f\x45\x15\x00\x00\x00\x00\x00\x00\x50\x04\xda\x06\x00\x00\x00\x00\xa3\x08\x00\x00\x90\x04\x6f\x06\xc1\xff\xe5\x11\x00\x00\xd7\x07\x00\x00\xc2\xff\x91\x13\x00\x00\xcc\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\x07\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x77\x06\xe3\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x02\x00\x00\xe6\x07\x00\x00\xe7\x07\x00\x00\x00\x00\xff\x07\x00\x00\x00\x00\xbf\x08\xf7\x0c\xa9\x08\x00\x00\x00\x00\xfa\x11\x23\x0f\x00\x00\x00\x00\x00\x00\x6e\x02\x00\x00\x00\x00\x8b\x09\x00\x00\x00\x00\x64\x15\x9e\x59\x00\x00\xeb\x08\xf5\x08\x00\x00\xff\xff\x00\x00\xf5\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x08\x00\x00\x00\x00\x00\x00\x00\x00\x33\x0d\x00\x00\x00\x00\x31\x09\x00\x00\x00\x00\x9d\xff\x00\x00\x00\x00\x0d\x00\x00\x00\x00\x00\x47\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x83\x08\xb4\x05\x00\x00\xc0\xff\x00\x00\x00\x00\x09\x09\x08\x00\xfa\x07\x00\x00\x02\x00\xfb\x07\x00\x00\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x15\x09\x00\x00\x00\x00\xb9\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x08\x00\x00\x00\x00\x00\x00\x00\x00"#--happyAdjustOffset :: Happy_GHC_Exts.Int# -> Happy_GHC_Exts.Int#-happyAdjustOffset off = off--happyDefActions :: HappyAddr-happyDefActions = HappyA# "\xbe\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\xfd\x00\x00\x00\x00\xbd\xff\xbe\xff\x00\x00\xf2\xff\x15\xfd\x11\xfd\x0e\xfd\xfe\xfc\xfc\xfc\xfd\xfc\x0a\xfd\xfb\xfc\xfa\xfc\xf9\xfc\x0c\xfd\x0b\xfd\x0d\xfd\x09\xfd\x08\xfd\xf8\xfc\xf7\xfc\xf6\xfc\xf5\xfc\xf4\xfc\xf3\xfc\xf2\xfc\xf1\xfc\xf0\xfc\xef\xfc\xed\xfc\xee\xfc\x00\x00\x0f\xfd\x10\xfd\x8d\xff\x00\x00\xaf\xff\x00\x00\x00\x00\x8d\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x99\xfe\x00\x00\x94\xfe\x92\xfe\x8d\xfe\x8c\xfe\x88\xfe\x89\xfe\x72\xfe\x71\xfe\x00\x00\x7f\xfe\x48\xfd\x83\xfe\x43\xfd\x3a\xfd\x3d\xfd\x36\xfd\x7e\xfe\x82\xfe\x1e\xfd\x1b\xfd\x68\xfe\x5d\xfe\x19\xfd\x18\xfd\x1a\xfd\x00\x00\x00\x00\x33\xfd\x32\xfd\x00\x00\x00\x00\x7d\xfe\x31\xfd\x40\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\xfd\x39\xfd\x34\xfd\x35\xfd\x3b\xfd\x37\xfd\x38\xfd\x6f\xfd\x6a\xfe\x69\xfe\x6b\xfe\x00\x00\x17\xfe\x16\xfe\x00\x00\xf1\xff\x5e\xfd\x51\xfd\x5d\xfd\xef\xff\xf0\xff\x22\xfd\x06\xfd\x07\xfd\x02\xfd\xff\xfc\x5c\xfd\xea\xfc\x4d\xfd\xe7\xfc\xe4\xfc\xed\xff\x01\xfd\xeb\xfc\xec\xfc\x00\x00\x00\x00\x00\x00\x00\x00\xe8\xfc\x00\xfd\xe5\xfc\xe9\xfc\x03\xfd\xe6\xfc\xd5\xfd\x80\xfd\x10\xfe\x0e\xfe\x00\x00\x09\xfe\x01\xfe\xf3\xfd\xf0\xfd\xe1\xfd\xe0\xfd\x00\x00\x00\x00\x86\xfd\x83\xfd\xed\xfd\xec\xfd\xee\xfd\xef\xfd\xeb\xfd\x0f\xfe\xe2\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\xfd\xe3\xfc\xe2\xfc\xea\xfd\xe9\xfd\xdf\xfc\xde\xfc\xe1\xfc\xe0\xfc\xdd\xfc\xdc\xfc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdb\xfd\x7a\xff\x24\xfe\x00\x00\x00\x00\x00\x00\x11\xfd\x78\xff\x77\xff\x76\xff\x00\x00\x00\x00\x1b\xfe\x1b\xfe\x1b\xfe\x00\x00\x6c\xfd\x00\x00\x00\x00\x91\xfd\x00\x00\x00\x00\x00\x00\x6c\xff\x6b\xff\x6a\xff\x69\xff\x12\xff\x68\xff\x67\xff\x2f\xfe\x61\xff\x60\xff\x31\xfe\x5f\xff\x00\x00\x26\xff\x00\x00\x44\xff\x4d\xff\x25\xff\x00\x00\x00\x00\x00\x00\xd7\xfe\xbf\xfe\xc4\xfe\x00\x00\x00\x00\x84\xfd\x00\x00\x87\xff\x00\x00\x00\x00\x00\x00\x8d\xff\xbf\xff\x00\x00\x8d\xff\x00\x00\x8a\xff\xba\xff\xd9\xfc\xd8\xfc\x00\x00\xba\xff\x85\xff\x00\x00\x00\x00\x61\xfd\x58\xfd\x62\xfd\x17\xfd\x5a\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xc5\xfe\x00\x00\x64\xfd\x00\x00\xc0\xfe\x00\x00\x00\x00\xd8\xfe\xd5\xfe\x00\x00\x57\xfd\x00\x00\x00\x00\x00\x00\x65\xff\x00\x00\x00\x00\x00\x00\x00\x00\x92\xfe\x48\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x45\xff\x00\x00\x46\xff\x48\xff\x47\xff\x00\x00\x63\xfe\x00\x00\x57\xfe\x00\x00\x19\xff\x00\x00\x28\xfd\x00\x00\x27\xfd\x29\xfd\x00\x00\x00\x00\x00\x00\x12\xff\x00\x00\xc6\xfd\x10\xfe\x00\x00\x00\x00\x00\x00\x25\xfd\x00\x00\x24\xfd\x26\xfd\x20\xfd\x04\xfd\x00\x00\x05\xfd\x4d\xfd\x00\x00\x00\x00\xd2\xfc\x01\xfd\x00\x00\x55\xfd\xd6\xfc\x00\x00\x57\xfd\xa6\xfe\x00\x00\x6d\xfd\x6b\xfd\x69\xfd\x68\xfd\x65\xfd\x00\x00\x00\x00\x00\x00\x1a\xfe\x00\x00\x00\x00\x00\x00\x00\x00\xdf\xfe\x00\x00\xe2\xfe\xe2\xfe\x00\x00\x00\x00\x00\x00\x79\xff\xdc\xfd\x4b\xfd\xdd\xfd\x00\x00\x00\x00\x00\x00\xce\xfd\xef\xfd\x00\x00\x00\x00\x71\xff\x71\xff\x00\x00\x00\x00\x00\x00\xf5\xfd\x87\xfd\x87\xfd\xf6\xfd\xde\xfd\xdf\xfd\x00\x00\xcc\xfd\x00\x00\x00\x00\x04\xfd\x05\xfd\x00\x00\x53\xfd\x00\x00\xba\xfd\x00\x00\xb9\xfd\x50\xfd\xfd\xfd\xfe\xfd\xff\xfd\x0a\xfe\x8f\xfd\x8d\xfd\x00\x00\x00\x00\x00\x00\x02\xfe\x82\xfd\x00\x00\x7f\xfd\x07\xfe\x00\x00\xf8\xfd\x95\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7d\xfd\x04\xfe\x00\x00\xd1\xfc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcf\xfd\x70\xfe\x60\xfd\x5f\xfd\x81\xfe\x80\xfe\x6d\xfe\x2b\xfd\x63\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x62\xfe\x00\x00\x00\x00\x00\x00\x77\xfe\x00\x00\x3d\xfd\x00\x00\x00\x00\x79\xfe\x00\x00\x44\xfd\x00\x00\x00\x00\x3f\xfe\x3d\xfe\xa0\xfe\x00\x00\x7b\xfe\x00\x00\x7c\xfe\x9c\xfe\x9d\xfe\x00\x00\x5d\xfe\x5c\xfe\x59\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x87\xfe\x00\x00\x85\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x97\xfe\x8a\xfe\x00\x00\xe8\xff\x00\x00\x00\x00\xac\xff\x8a\xff\xba\xff\xba\xff\xab\xff\xa6\xff\x00\x00\x00\x00\xa6\xff\xaa\xff\xa8\xff\xa9\xff\x8e\xff\xec\xff\xda\xfc\xdb\xfc\xe9\xff\x00\x00\xd5\xff\xdc\xff\xd9\xff\xdb\xff\xda\xff\xdd\xff\xeb\xff\x50\xfe\x98\xfe\x96\xfe\x8e\xfe\x8f\xfe\x91\xfe\x00\x00\x86\xfe\x8b\xfe\x84\xfe\x95\xfe\x00\x00\x00\x00\x5e\xfe\x9a\xfe\x9b\xfe\x00\x00\x00\x00\x7a\xfe\x00\x00\x00\x00\x74\xfe\x00\x00\x45\xfd\x47\xfd\xd7\xfc\x42\xfd\x73\xfe\x00\x00\x46\xfd\x75\xfe\x76\xfe\x00\x00\x00\x00\x1d\xfd\x3c\xfd\x00\x00\x00\x00\x33\xfd\x32\xfd\x7d\xfe\x31\xfd\x34\xfd\x35\xfd\x38\xfd\x62\xfe\x00\x00\x64\xfe\xee\xff\x54\xfd\x5b\xfd\x13\xfd\x52\xfd\x4c\xfd\x21\xfd\x11\xfe\x12\xfe\x13\xfe\x14\xfe\x15\xfe\x03\xfe\x00\x00\x7e\xfd\x7b\xfd\x78\xfd\x00\x00\x7a\xfd\x0f\xfd\xf1\xfd\x12\xfd\x81\xfd\x00\xfe\x00\x00\x00\x00\x00\x00\xa6\xfd\xa4\xfd\x96\xfd\x93\xfd\x00\x00\x08\xfe\x00\x00\x00\x00\x06\xfe\x05\xfe\xfa\xfd\x00\x00\x00\x00\x8d\xfd\x00\x00\x00\x00\xe3\xfd\xb8\xfd\x00\x00\x00\x00\x14\xfd\xbc\xfd\xc1\xfd\xe4\xfd\xc2\xfd\xbb\xfd\xc0\xfd\xe5\xfd\x00\x00\x00\x00\x88\xfd\x00\x00\xda\xfd\xd7\xfd\xd8\xfd\xc7\xfd\xc8\xfd\x00\x00\x00\x00\xd6\xfd\xd9\xfd\x49\xfd\x00\x00\x4a\xfd\x25\xfe\x2d\xfd\x74\xff\x2e\xfd\x4f\xfd\x2c\xfd\x00\x00\x27\xfe\xa2\xfe\x00\x00\x00\x00\x2e\xfe\xe3\xfe\xa8\xfe\x2d\xfe\xd1\xfd\xd0\xfd\x00\x00\x71\xfd\xed\xfd\x00\x00\x00\x00\x00\x00\xfb\xfe\xfc\xfe\x67\xfe\x00\x00\x00\x00\x00\x00\xd3\xfe\xd2\xfe\x00\x00\x00\x00\x21\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd2\xfd\xd4\xfc\xd3\xfc\x14\xfd\xc4\xfd\xe7\xfd\xe8\xfd\x00\x00\xe6\xfd\xc5\xfd\x00\x00\x00\x00\x00\x00\x24\xff\xa2\xfe\x0d\xfe\x0c\xfe\x00\x00\x0b\xfe\x30\xfe\xdb\xfe\x29\xfe\x00\x00\x00\x00\x00\x00\xf0\xfe\x52\xfe\x22\xff\x00\x00\x49\xff\xa4\xfe\xa2\xfe\x4d\xff\x4e\xff\x4f\xff\x51\xff\x50\xff\xe6\xfe\x0f\xff\x00\x00\x20\xff\x54\xff\x00\x00\x5d\xfe\x00\x00\x00\x00\x00\x00\x00\x00\xb2\xfe\xb1\xfe\xb0\xfe\xaf\xfe\xae\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x06\xff\x03\xff\x00\x00\x00\x00\x00\x00\xcc\xfe\xd4\xfe\x00\x00\x62\xff\xd9\xfe\xbe\xfe\xb9\xfe\xbd\xfe\x64\xff\xc1\xfe\x00\x00\xc3\xfe\x63\xff\xc6\xfe\x30\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x88\xff\x81\xff\x86\xff\xa6\xff\xb6\xff\xa6\xff\xb5\xff\xb2\xff\x6e\xff\xb7\xff\x8c\xff\xb3\xff\xb4\xff\x00\x00\xa4\xff\x00\x00\x83\xff\x82\xff\xb8\xfe\xb6\xfe\x00\x00\x00\x00\xc7\xfe\x63\xfd\xc2\xfe\x00\x00\xba\xfe\xda\xfe\x00\x00\x00\x00\x00\x00\xca\xfe\x08\xff\x09\xff\x00\x00\x01\xff\x02\xff\xfd\xfe\x00\x00\x05\xff\x00\x00\xb4\xfe\x00\x00\xac\xfe\xab\xfe\xad\xfe\x00\x00\xb3\xfe\x57\xff\x58\xff\x5d\xff\x00\x00\x00\x00\x43\xff\x00\x00\x00\x00\x10\xff\x0e\xff\x0d\xff\x0a\xff\x0b\xff\x55\xff\x00\x00\x00\x00\x00\x00\x66\xff\x59\xff\x00\x00\x56\xfe\x54\xfe\x00\x00\x5e\xff\x00\x00\x1a\xff\x00\x00\xdb\xfe\x2b\xfe\x2a\xfe\x00\x00\xd0\xfc\x4d\xfe\x3b\xfe\x00\x00\x42\xfe\x24\xff\x00\x00\x15\xff\x5d\xfe\x13\xff\x00\x00\xc3\xfd\xd3\xfd\xbf\xfd\xd5\xfc\x23\xfd\x1f\xfd\x56\xfd\xa5\xfe\x23\xfe\x6a\xfd\x67\xfd\x59\xfd\x66\xfd\x20\xfe\x00\x00\x19\xfe\x00\x00\x00\x00\x1d\xfe\x22\xfe\xde\xfe\x72\xfd\xe1\xfe\xe4\xfe\x00\x00\xdd\xfe\xe0\xfe\x00\x00\x00\x00\xca\xfd\xc9\xfd\x73\xff\x8c\xfd\x89\xfd\x8b\xfd\xcb\xfd\xcd\xfd\xd4\xfd\xbe\xfd\xbd\xfd\xc6\xfd\xb2\xfd\xb4\xfd\xb1\xfd\xaf\xfd\xac\xfd\xab\xfd\x00\x00\xb6\xfd\xb3\xfd\x00\x00\x8e\xfd\x00\x00\x9f\xfd\x9b\xfd\x00\x00\xa0\xfd\x00\x00\x00\x00\xa1\xfd\xf4\xfd\xfb\xfd\x00\x00\x00\x00\x00\x00\x94\xfd\xf7\xfd\x00\x00\x00\x00\x00\x00\xf2\xfd\x6e\xfe\x00\x00\x2a\xfd\x61\xfe\x60\xfe\x5f\xfe\x00\x00\x00\x00\xa1\xfe\x3c\xfe\x3e\xfe\x16\xfd\x00\x00\x5b\xfe\x00\x00\x90\xfe\x00\x00\xd8\xff\xd7\xff\xd6\xff\x00\x00\xea\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbc\xff\xbb\xff\x00\x00\xe7\xff\x00\x00\x00\x00\xd4\xff\x00\x00\x00\x00\x6c\xfe\x78\xfe\x00\x00\x7c\xfd\x79\xfd\x76\xfd\x74\xfd\x92\xfd\xa5\xfd\x07\xfe\xa3\xfd\x9e\xfd\x9a\xfd\xdb\xfe\x97\xfd\x00\x00\x9c\xfd\xa2\xfd\xfc\xfd\xaa\xfd\xf3\xfc\x00\x00\x00\x00\xb7\xfd\x8a\xfd\x72\xff\x8f\xff\x75\xff\x26\xfe\x70\xfd\xe5\xfe\x73\xfd\x00\x00\x9f\xfe\x00\x00\x18\xfe\x00\x00\x14\xff\x00\x00\x00\x00\x4d\xfe\x3b\xfe\x48\xfe\x46\xfe\x00\x00\x5d\xfe\x23\xff\x5b\xff\x3a\xfe\x38\xfe\x00\x00\x3b\xfe\x00\x00\xdc\xfe\x2c\xfe\x00\x00\xf1\xfe\xf4\xfe\xf4\xfe\x51\xfe\x52\xfe\x52\xfe\x21\xff\xa3\xfe\x11\xff\xe7\xfe\xea\xfe\xea\xfe\x0c\xff\x1e\xff\x1f\xff\x3e\xff\x00\x00\x33\xff\x00\x00\x00\x00\x00\x00\xb5\xfe\x4e\xfd\x00\x00\x04\xff\x07\xff\x00\x00\x00\x00\xca\xfe\xc9\xfe\x00\x00\x00\x00\xd1\xfe\xcf\xfe\x00\x00\xbc\xfe\x00\x00\xb7\xfe\x2f\xfd\x00\x00\x84\xff\x00\x00\x00\x00\xa5\xff\xa0\xff\x9c\xff\x94\xff\x91\xff\x41\xfd\x92\xff\x00\x00\x00\x00\x00\x00\x00\x00\xa2\xff\x00\x00\x70\xff\x6d\xff\x8b\xff\x90\xff\x6f\xff\xc0\xff\x8d\xff\x8d\xff\x00\x00\x00\x00\x00\x00\x9d\xff\x00\x00\x93\xff\x9e\xff\x9f\xff\x9a\xff\xa3\xff\xa7\xff\xc1\xff\x81\xff\xbb\xfe\xd0\xfe\x00\x00\x00\x00\xcb\xfe\xcd\xfe\xe2\xfe\xe2\xfe\x00\xff\xa9\xfe\x00\x00\x00\x00\x42\xff\x00\x00\x5c\xff\x00\x00\xef\xfe\x2b\xff\xeb\xfe\x00\x00\xee\xfe\x26\xff\x2b\xff\x00\x00\x55\xfe\x53\xfe\xfa\xfe\xf5\xfe\x00\x00\xf9\xfe\x2d\xff\x00\x00\x00\x00\x00\x00\x28\xfe\x4a\xfe\x4a\xfe\x5a\xff\x00\x00\x37\xfe\x34\xfe\x4a\xff\x4c\xff\x4b\xff\x00\x00\x39\xfe\x00\x00\x00\x00\x93\xfe\x41\xfe\x44\xfe\x42\xfe\x53\xff\x3b\xfe\x16\xff\x00\x00\x1e\xfe\x1f\xfe\x00\x00\xb5\xfd\xae\xfd\xad\xfd\xb0\xfd\x00\x00\x00\x00\x00\x00\x9d\xfd\x98\xfd\x99\xfd\x00\x00\x00\x00\x00\x00\x6f\xfe\x5a\xfe\x58\xfe\x00\x00\xc8\xff\x87\xff\x00\x00\x00\x00\x00\x00\xb0\xff\x8d\xff\x8d\xff\xb1\xff\xad\xff\xae\xff\xcc\xff\xc9\xff\xd3\xff\xe6\xff\xed\xfc\xc4\xff\x00\x00\xcb\xff\x75\xfd\x77\xfd\x00\x00\xa9\xfd\xa8\xfd\x00\x00\x9e\xfe\x00\x00\x17\xff\x52\xff\x47\xfe\x00\x00\x43\xfe\x66\xfe\x00\x00\x33\xfe\x35\xfe\x36\xfe\x00\x00\x4b\xfe\x00\x00\x00\x00\xf3\xfe\xf6\xfe\x2f\xff\x1d\xff\x00\x00\x00\x00\x00\x00\x00\x00\x2c\xff\xf2\xfe\xe9\xfe\xec\xfe\x00\x00\x2a\xff\xe8\xfe\x12\xff\x3d\xff\x35\xff\x35\xff\x00\x00\x00\x00\xaa\xfe\x00\x00\x00\x00\xca\xfe\x00\x00\xd6\xfe\x7f\xff\xa1\xff\x00\x00\x99\xff\x97\xff\x96\xff\x95\xff\x40\xfd\x3f\xfd\x3e\xfd\x00\x00\x00\x00\xb9\xff\xb8\xff\x00\x00\x9b\xff\x7d\xff\x00\x00\x00\x00\x00\x00\xff\xfe\xfe\xfe\x34\xff\x41\xff\x3f\xff\x00\x00\x36\xff\x00\x00\x00\x00\x00\x00\x00\x00\x29\xff\xed\xfe\x22\xff\x00\x00\x1d\xff\x2e\xff\x31\xff\x00\x00\x00\x00\xf7\xfe\x4f\xfe\x00\x00\x4a\xfe\x4e\xfe\x32\xfe\x00\x00\x41\xfe\x45\xfe\x00\x00\x00\x00\xf9\xfd\xc5\xff\xa6\xff\xc2\xff\x00\x00\xc3\xff\x00\x00\xca\xff\x00\x00\xcf\xff\xcd\xff\x00\x00\xe2\xff\x00\x00\x00\x00\xa6\xff\xa7\xfd\x18\xff\x65\xfe\x4c\xfe\x00\x00\x00\x00\x7e\xfe\x00\x00\x1c\xff\x30\xff\x00\x00\xf8\xfe\x32\xff\x24\xff\x3a\xff\x3c\xff\x37\xff\x39\xff\x3b\xff\x40\xff\xce\xfe\xc8\xfe\x80\xff\x89\xff\x7e\xff\x00\x00\xa4\xff\x98\xff\x00\x00\xa4\xff\x38\xff\x4d\xfe\x3b\xfe\x7e\xfe\x00\x00\x49\xfe\x00\x00\x00\x00\x00\x00\x00\x00\xe5\xff\xe3\xff\x00\x00\xd2\xff\xd0\xff\xd1\xff\xce\xff\xe4\xff\x00\x00\x00\x00\xe1\xff\x00\x00\xc6\xff\x00\x00\x1b\xff\x28\xff\x3b\xfe\x00\x00\x7c\xff\x7b\xff\x27\xff\xc7\xff\x00\x00\x00\x00\xe0\xff\xde\xff\xdf\xff"#--happyCheck :: HappyAddr-happyCheck = HappyA# "\xff\xff\x00\x00\x0d\x00\x0e\x00\x05\x00\x06\x00\x61\x00\x49\x00\x06\x00\x49\x00\x37\x00\x4a\x00\x04\x00\x45\x00\x62\x00\x07\x00\x08\x00\x09\x00\x04\x00\x0b\x00\x85\x00\x0e\x00\x08\x00\x09\x00\x04\x00\x0b\x00\x79\x00\x7a\x00\x08\x00\x09\x00\x8a\x00\x0b\x00\x08\x00\x09\x00\x09\x00\x0b\x00\x0b\x00\x52\x00\x53\x00\x62\x00\x39\x00\x3a\x00\x9f\x00\xa0\x00\x8a\x00\x39\x00\x3a\x00\x09\x00\x01\x00\x63\x00\xb4\x00\x60\x00\x63\x00\xd2\x00\x79\x00\x7a\x00\x65\x00\x72\x00\xe4\x00\x79\x00\x7a\x00\xa0\x00\x6b\x00\x6c\x00\x54\x00\x47\x00\xae\x00\xaf\x00\xb0\x00\x21\x00\x22\x00\x23\x00\x18\x00\x05\x01\x4e\x00\x12\x00\x28\x00\x29\x00\x10\x00\x21\x00\x22\x00\x23\x00\x9e\x00\x9f\x00\xa0\x00\x00\x00\x28\x00\x29\x00\x54\x00\xf2\x00\x4b\x00\x21\x00\x22\x00\x23\x00\x84\x00\x85\x00\x4a\x00\x54\x00\x28\x00\x29\x00\x9e\x00\x9f\x00\xa0\x00\x23\x00\x6e\x00\x0b\x00\x00\x00\x6f\x00\x28\x00\x29\x00\x2a\x01\x27\x00\x28\x00\x29\x00\x85\x00\x47\x00\x47\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x8a\x00\x47\x00\xb4\x00\x47\x00\x4e\x00\x41\x00\xb9\x00\xd2\x00\x2c\x01\x74\x00\x1d\x01\x6f\x00\x0b\x00\x33\x00\xb5\x00\xb6\x00\x0c\x01\x0d\x01\x4a\x00\xba\x00\x68\x00\x00\x00\xbd\x00\x2e\x01\xbf\x00\x7c\x00\xc1\x00\xa9\x00\x1b\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x62\x00\xc9\x00\xca\x00\xcb\x00\xaf\x00\xb0\x00\x72\x00\x6e\x00\x18\x01\x6e\x00\x1a\x01\x01\x01\x02\x01\x03\x01\x04\x01\x1b\x01\x7f\x00\x7f\x00\xa9\x00\x1f\x01\x1b\x01\x25\x01\x6f\x00\x72\x00\x1f\x01\x25\x01\x18\x01\xa9\x00\x1a\x01\x4e\x00\x25\x01\x65\x00\x38\x00\x62\x00\x1b\x01\xcf\x00\x7f\x00\x1f\x01\x1f\x01\x25\x01\xcf\x00\x1f\x01\x00\x00\x25\x01\x25\x01\xf5\x00\xf6\x00\x25\x01\x1f\x01\x18\x01\x28\x01\x1a\x01\x65\x00\x49\x00\x25\x01\xff\x00\x00\x01\x0c\x01\x0d\x01\x03\x01\x04\x01\x1a\x01\x25\x01\x1a\x01\x1a\x01\x1f\x01\x2e\x01\x18\x01\x30\x01\x1a\x01\x1f\x01\x25\x01\x25\x01\x1f\x01\x25\x01\x25\x01\x25\x01\x4a\x00\x1b\x01\x25\x01\x25\x01\x1b\x01\x1f\x01\x1b\x01\x1c\x01\x1f\x01\x1e\x01\x1f\x01\x25\x01\x65\x00\x1b\x01\x25\x01\x70\x00\x25\x01\x1f\x01\x27\x01\x28\x01\x75\x00\x6e\x00\x2b\x01\x25\x01\xff\x00\x00\x01\x67\x00\x50\x00\x03\x01\x04\x01\x67\x00\x06\x01\x1b\x01\x94\x00\x6f\x00\x1b\x01\x1f\x01\x6f\x00\x6f\x00\x1f\x01\x5d\x00\x66\x00\x25\x01\xfc\x00\xfd\x00\x25\x01\x55\x00\x16\x01\x01\x01\x00\x00\x03\x01\x04\x01\x00\x00\x1c\x01\x00\x00\x1e\x01\x1f\x01\x20\x01\x2d\x01\x22\x01\x23\x01\x24\x01\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2d\x01\x25\x01\x0a\x01\x2d\x01\x0c\x01\x0d\x01\x1b\x01\x25\x01\x2d\x01\x74\x00\x1f\x01\x00\x00\x0a\x01\x25\x01\x0c\x01\x0d\x01\x25\x01\x25\x01\x25\x01\x28\x01\x1c\x01\x80\x00\x1e\x01\x1f\x01\x0a\x01\x5f\x00\x0c\x01\x0d\x01\x32\x00\x25\x01\x1c\x01\x00\x00\x1e\x01\x1f\x01\x0a\x01\x69\x00\x0c\x01\x0d\x01\x0a\x01\x25\x01\x0c\x01\x0d\x01\x1c\x01\x4a\x00\x1e\x01\x1f\x01\x0a\x01\x94\x00\x0c\x01\x0d\x01\x12\x00\x25\x01\x1c\x01\x00\x00\x1e\x01\x1f\x01\x1c\x01\x55\x00\x1e\x01\x1f\x01\x12\x00\x25\x01\x37\x00\x4a\x00\x1c\x01\x25\x01\x1e\x01\x1f\x01\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x25\x01\x43\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\xa0\x00\x6f\x00\x53\x00\x65\x00\x33\x00\x34\x00\x65\x00\x4a\x00\x65\x00\x74\x00\x48\x00\x53\x00\x6e\x00\x05\x01\x33\x00\x6e\x00\x4e\x00\x6e\x00\x4e\x00\x5b\x00\x5c\x00\x80\x00\x98\x00\x54\x00\x60\x00\x11\x01\x12\x01\x58\x00\x37\x00\x65\x00\x68\x00\x18\x00\x5d\x00\x65\x00\x4b\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x63\x00\x43\x00\x73\x00\x6e\x00\x23\x01\x24\x01\x66\x00\x26\x01\xff\x00\x00\x01\x6f\x00\x2a\x01\x03\x01\x04\x01\x65\x00\x5f\x00\x74\x00\x53\x00\x81\x00\x67\x00\xbd\x00\x49\x00\x62\x00\x6e\x00\x47\x00\x5b\x00\x5c\x00\x3b\x00\x3c\x00\x19\x00\x60\x00\x7f\x00\x54\x00\xca\x00\x73\x00\x65\x00\x65\x00\x1c\x01\x77\x00\x1e\x01\x1f\x01\x5d\x00\x9e\x00\x9f\x00\xa0\x00\x6e\x00\x25\x01\x2b\x00\x27\x01\x28\x01\x01\x01\x02\x01\x03\x01\x04\x01\x01\x01\x02\x01\x03\x01\x04\x01\x65\x00\x65\x00\xef\x00\xf0\x00\xf1\x00\x81\x00\x74\x00\x75\x00\x48\x00\x6e\x00\x6e\x00\x73\x00\xb5\x00\x4e\x00\x68\x00\x77\x00\x50\x00\xba\x00\x47\x00\x01\x00\xbd\x00\x4e\x00\xbf\x00\x18\x01\xc1\x00\x1a\x01\x49\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x28\x01\x94\x00\xca\x00\xcb\x00\x28\x01\x25\x01\x08\x01\x09\x01\x15\x00\x69\x00\x0c\x01\x0d\x01\x9e\x00\x9f\x00\xa0\x00\x6f\x00\x1c\x01\x1d\x01\x1e\x01\x1f\x01\x7b\x00\x7c\x00\x18\x01\x6f\x00\x1a\x01\x25\x01\xb5\x00\x69\x00\x67\x00\x42\x00\x94\x00\xba\x00\x4a\x00\x6f\x00\xbd\x00\x25\x01\xbf\x00\x13\x00\xc1\x00\x75\x00\x19\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xf5\x00\xf6\x00\xca\x00\xcb\x00\x4e\x00\x62\x00\x1e\x00\x64\x00\x80\x00\x67\x00\xff\x00\x00\x01\x63\x00\x2b\x00\x03\x01\x04\x01\x37\x00\x6f\x00\x19\x00\x2b\x00\x2f\x00\x30\x00\x31\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x6b\x00\x43\x00\x49\x00\x18\x01\x6f\x00\x1a\x01\x6b\x00\x7d\x00\x7e\x00\x2b\x00\x6f\x00\x1b\x01\x1c\x01\x54\x00\x1e\x01\x1f\x01\x25\x01\x53\x00\xf5\x00\xf6\x00\x4f\x00\x25\x01\x5d\x00\x27\x01\x28\x01\x5b\x00\x5c\x00\x2b\x01\xff\x00\x00\x01\x60\x00\x8c\x00\x03\x01\x04\x01\x4f\x00\x65\x00\x91\x00\x19\x00\x93\x00\x94\x00\x95\x00\x54\x00\x97\x00\x98\x00\x57\x00\x74\x00\x75\x00\x0e\x01\x0f\x01\x78\x00\x79\x00\x0c\x01\x0d\x01\xf0\x00\xf1\x00\x2b\x00\x1b\x01\x1c\x01\x1e\x00\x1e\x01\x1f\x01\x37\x00\x18\x01\x81\x00\x1a\x01\x1a\x01\x25\x01\x13\x00\x27\x01\x28\x01\x52\x00\x2b\x00\x2b\x01\x74\x00\x1e\x00\x25\x01\x25\x01\xfc\x00\xfd\x00\x2e\x01\xbd\x00\x18\x01\x01\x01\x1a\x01\x03\x01\x04\x01\x1a\x00\x2b\x00\x52\x00\x53\x00\xa7\x00\xa8\x00\x80\x00\xca\x00\x25\x01\x2f\x00\x30\x00\x1c\x01\x1d\x01\x1e\x01\x1f\x01\x94\x00\x60\x00\x1e\x00\x2c\x00\x2d\x00\x25\x01\x65\x00\x1b\x01\x3b\x00\x3c\x00\x68\x00\x1f\x01\x6b\x00\x6c\x00\xb5\x00\x2b\x00\xc2\x00\x25\x01\x6f\x00\xba\x00\x28\x01\x73\x00\xbd\x00\x4b\x00\xbf\x00\x77\x00\xc1\x00\x4f\x00\x6f\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xfc\x00\xfd\x00\xca\x00\xcb\x00\x94\x00\x01\x01\x1f\x00\x03\x01\x04\x01\xa7\x00\xa8\x00\xff\x00\x00\x01\x1b\x01\x21\x00\x03\x01\x04\x01\x1f\x01\x68\x00\x2c\x00\x2d\x00\x08\x01\x09\x01\x25\x01\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\x73\x00\x7f\x00\x1b\x01\x68\x00\x77\x00\x49\x00\x1f\x01\xc2\x00\x18\x01\x19\x01\x1a\x01\x4e\x00\x25\x01\x68\x00\x73\x00\x28\x01\xf5\x00\xf6\x00\x77\x00\x37\x00\x94\x00\x25\x01\x27\x01\x28\x01\xb5\x00\xb6\x00\xff\x00\x00\x01\x86\x00\xba\x00\x03\x01\x04\x01\xbd\x00\x62\x00\xbf\x00\x64\x00\xc1\x00\x69\x00\x2e\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x6f\x00\xc9\x00\xca\x00\xcb\x00\xa7\x00\xa8\x00\x75\x00\x63\x00\x3b\x00\x3c\x00\x79\x00\x1b\x01\x1c\x01\x38\x00\x1e\x01\x1f\x01\x1b\x01\x60\x00\x6e\x00\x1f\x01\x1f\x01\x25\x01\x65\x00\x27\x01\x28\x01\x25\x01\x25\x01\x2b\x01\x28\x01\x49\x00\x8c\x00\xc2\x00\x6f\x00\x4a\x00\x4b\x00\x91\x00\x50\x00\x93\x00\x94\x00\x95\x00\x54\x00\x97\x00\x98\x00\x94\x00\x58\x00\xf5\x00\xf6\x00\x63\x00\x37\x00\x5d\x00\x63\x00\x01\x01\x02\x01\x03\x01\x04\x01\xff\x00\x00\x01\x6e\x00\x6e\x00\x03\x01\x04\x01\x69\x00\x01\x01\x02\x01\x03\x01\x04\x01\x47\x00\x6f\x00\x18\x01\x69\x00\x1a\x01\x1e\x00\x74\x00\x75\x00\x63\x00\x6f\x00\x78\x00\x79\x00\x66\x00\xbd\x00\x68\x00\x25\x01\x6a\x00\x1b\x01\x1c\x01\x6e\x00\x1e\x01\x1f\x01\x6f\x00\x60\x00\x28\x01\x73\x00\xca\x00\x25\x01\x65\x00\x27\x01\x28\x01\x63\x00\x18\x01\x2b\x01\x1a\x01\x28\x01\xb5\x00\xb6\x00\x6f\x00\x63\x00\x4b\x00\xba\x00\x6e\x00\x69\x00\xbd\x00\x25\x01\xbf\x00\x06\x01\xc1\x00\x6f\x00\x6e\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x63\x00\xc9\x00\xca\x00\xcb\x00\x69\x00\x13\x01\x4b\x00\x15\x01\x16\x01\x4e\x00\x6f\x00\x6e\x00\x7e\x00\x66\x00\x63\x00\x68\x00\x4b\x00\x6a\x00\x20\x01\x4e\x00\x22\x01\x23\x01\x24\x01\x69\x00\x26\x01\x6e\x00\x73\x00\x29\x01\x2a\x01\x6f\x00\x77\x00\x63\x00\x5f\x00\x08\x01\x09\x01\x62\x00\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\x63\x00\x6e\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\x4a\x00\x4b\x00\x18\x01\x19\x01\x1a\x01\x6e\x00\xb5\x00\xb6\x00\xff\x00\x00\x01\x37\x00\xba\x00\x03\x01\x04\x01\xbd\x00\x25\x01\xbf\x00\x4a\x00\xc1\x00\x1f\x01\x1a\x01\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x25\x01\xc9\x00\xca\x00\xcb\x00\x6b\x00\x49\x00\x25\x01\x1f\x01\x6f\x00\x4f\x00\x14\x00\x1b\x01\x1c\x01\x25\x01\x1e\x01\x1f\x01\x54\x00\x1b\x00\x6b\x00\x1d\x00\x58\x00\x25\x01\x6f\x00\x27\x01\x28\x01\x5d\x00\x60\x00\x2b\x01\x4e\x00\x8c\x00\x50\x00\x65\x00\x09\x01\x67\x00\x68\x00\x0c\x01\x0d\x01\x94\x00\x95\x00\x0d\x01\x97\x00\x98\x00\x10\x01\xf3\x00\xf4\x00\xf5\x00\xf6\x00\x6b\x00\x74\x00\x75\x00\x73\x00\x6f\x00\x78\x00\x79\x00\x77\x00\xff\x00\x00\x01\x37\x00\x47\x00\x03\x01\x04\x01\x1c\x01\xad\x00\x1e\x01\x1f\x01\x47\x00\xfc\x00\xfd\x00\x54\x00\x47\x00\x25\x01\x01\x01\x58\x00\x03\x01\x04\x01\x13\x00\x14\x00\x5d\x00\xbd\x00\x47\x00\x18\x00\x4f\x00\x10\x00\x1b\x01\x1c\x01\x4e\x00\x1e\x01\x1f\x01\x2a\x01\x29\x01\x2a\x01\xca\x00\x2e\x01\x25\x01\x2e\x01\x27\x01\x28\x01\x1b\x01\x60\x00\x2b\x01\x74\x00\x1f\x01\x49\x00\x65\x00\x78\x00\x67\x00\x68\x00\x25\x01\x53\x00\x50\x00\x28\x01\xb5\x00\xb6\x00\x54\x00\x09\x01\x41\x00\xba\x00\x0c\x01\x0d\x01\xbd\x00\x7f\x00\xbf\x00\x5d\x00\xc1\x00\x98\x00\x50\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x72\x00\xc9\x00\xca\x00\xcb\x00\x69\x00\x05\x01\x07\x01\x08\x01\x09\x01\x69\x00\x6f\x00\x0c\x01\x0d\x01\x4a\x00\x4b\x00\x74\x00\x75\x00\x11\x01\x12\x01\x78\x00\x79\x00\x4a\x00\x4b\x00\x08\x01\x09\x01\x6f\x00\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xbd\x00\xb7\x00\xb8\x00\xb9\x00\x23\x01\x24\x01\x69\x00\x26\x01\x18\x01\x19\x01\x1a\x01\x2a\x01\x69\x00\xca\x00\xf5\x00\xf6\x00\x42\x00\x43\x00\x44\x00\x45\x00\x37\x00\x25\x01\xb5\x00\xb6\x00\xff\x00\x00\x01\x69\x00\xba\x00\x03\x01\x04\x01\xbd\x00\x62\x00\xbf\x00\x64\x00\xc1\x00\x4a\x00\x4b\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x69\x00\xc9\x00\xca\x00\xcb\x00\x4a\x00\x4b\x00\x52\x00\x53\x00\x4a\x00\x1e\x01\x1f\x01\x1b\x01\x1c\x01\x47\x00\x1e\x01\x1f\x01\x25\x01\x4e\x00\x27\x01\x28\x01\x60\x00\x25\x01\x6f\x00\x27\x01\x28\x01\x65\x00\x67\x00\x2b\x01\x8e\x00\x49\x00\x4a\x00\x6b\x00\x0c\x00\x09\x01\x08\x01\x09\x01\x0c\x01\x0d\x01\x0c\x01\x0d\x01\x54\x00\xa2\x00\xa3\x00\xa4\x00\x58\x00\xf5\x00\xf6\x00\x6b\x00\x98\x00\x5d\x00\x18\x01\x62\x00\x1a\x01\x64\x00\x8c\x00\xff\x00\x00\x01\x02\x00\x03\x00\x03\x01\x04\x01\x8c\x00\x62\x00\x25\x01\x64\x00\x4d\x00\x4e\x00\x66\x00\x70\x00\x68\x00\x6f\x00\x6a\x00\x74\x00\x75\x00\x69\x00\x6e\x00\x78\x00\x79\x00\x02\x00\x03\x00\x73\x00\x1e\x01\x1f\x01\x1b\x01\x1c\x01\xbd\x00\x1e\x01\x1f\x01\x25\x01\x8c\x00\x27\x01\x28\x01\x62\x00\x25\x01\x64\x00\x27\x01\x28\x01\x47\x00\xca\x00\x2b\x01\x37\x00\x23\x01\x24\x01\x67\x00\x26\x01\xb5\x00\xb6\x00\x62\x00\x2a\x01\x64\x00\xba\x00\x47\x00\x2e\x01\xbd\x00\x62\x00\xbf\x00\x64\x00\xc1\x00\x70\x00\x71\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x4f\x00\xc9\x00\xca\x00\xcb\x00\x8c\x00\x62\x00\x66\x00\x64\x00\x68\x00\x91\x00\x6a\x00\x93\x00\x94\x00\x95\x00\x50\x00\x97\x00\x98\x00\x60\x00\x1c\x01\x73\x00\x1e\x01\x1f\x01\x65\x00\x77\x00\x67\x00\xfa\x00\xfb\x00\x25\x01\xfd\x00\x22\x01\x23\x01\x24\x01\x01\x01\x26\x01\x03\x01\x04\x01\x08\x01\x09\x01\x70\x00\x71\x00\x0c\x01\x0d\x01\x98\x00\xbb\x00\xbc\x00\xf5\x00\xf6\x00\x0c\x00\x37\x00\x5d\x00\x5e\x00\x5f\x00\x18\x01\xbd\x00\x1a\x01\xff\x00\x00\x01\x6e\x00\x1b\x01\x03\x01\x04\x01\x1c\x01\x1f\x01\x1e\x01\x1f\x01\x25\x01\xca\x00\x62\x00\x25\x01\x64\x00\x25\x01\x28\x01\x4e\x00\x22\x01\x23\x01\x24\x01\x62\x00\x26\x01\x64\x00\xbd\x00\x29\x01\x2a\x01\x14\x00\x1b\x01\x1c\x01\x2e\x01\x1e\x01\x1f\x01\x1c\x01\x60\x00\x1e\x01\x1f\x01\xca\x00\x25\x01\x65\x00\x27\x01\x28\x01\x25\x01\x62\x00\x2b\x01\x64\x00\x72\x00\xb5\x00\xb6\x00\x6f\x00\x6b\x00\x98\x00\xba\x00\x23\x01\x24\x01\xbd\x00\x26\x01\xbf\x00\x70\x00\xc1\x00\x98\x00\x70\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x70\x00\xc9\x00\xca\x00\xcb\x00\xb1\x00\xb2\x00\xb3\x00\x08\x01\x09\x01\x1f\x01\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\x25\x01\x69\x00\x27\x01\x28\x01\xaa\x00\xab\x00\xac\x00\xbd\x00\x18\x01\x19\x01\x1a\x01\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xbd\x00\x69\x00\x08\x01\x09\x01\xca\x00\x25\x01\x0c\x01\x0d\x01\xe0\x00\xe1\x00\xe2\x00\x69\x00\xe4\x00\xca\x00\xf5\x00\xf6\x00\x70\x00\x37\x00\x18\x01\x62\x00\x1a\x01\x64\x00\xb5\x00\xb6\x00\xff\x00\x00\x01\x6b\x00\xba\x00\x03\x01\x04\x01\xbd\x00\x25\x01\xbf\x00\x62\x00\xc1\x00\x64\x00\x69\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x63\x00\xc9\x00\xca\x00\xcb\x00\x6f\x00\x22\x01\x23\x01\x24\x01\x8c\x00\x26\x01\x50\x00\x1b\x01\x1c\x01\x6e\x00\x1e\x01\x1f\x01\x0b\x00\x60\x00\x96\x00\x97\x00\x98\x00\x25\x01\x65\x00\x27\x01\x28\x01\x08\x01\x09\x01\x2b\x01\x68\x00\x0c\x01\x0d\x01\x62\x00\x6f\x00\x64\x00\x08\x01\x09\x01\xbb\x00\xbc\x00\x0c\x01\x0d\x01\x75\x00\x18\x01\x77\x00\x1a\x01\x32\x00\xf5\x00\xf6\x00\x49\x00\x37\x00\xe2\x00\x18\x01\xe4\x00\x1a\x01\x18\x00\x25\x01\xff\x00\x00\x01\xbd\x00\x54\x00\x03\x01\x04\x01\x49\x00\x58\x00\x25\x01\xb1\x00\xb2\x00\xb3\x00\x5d\x00\xbb\x00\xbc\x00\xca\x00\x4a\x00\x54\x00\xb1\x00\xb2\x00\xb3\x00\x58\x00\x46\x00\x47\x00\x69\x00\x69\x00\x5d\x00\x70\x00\x1b\x01\x1c\x01\x6f\x00\x1e\x01\x1f\x01\x6f\x00\x60\x00\x74\x00\x75\x00\x69\x00\x25\x01\x65\x00\x27\x01\x28\x01\x73\x00\x74\x00\x2b\x01\x70\x00\x69\x00\xb5\x00\xb6\x00\x74\x00\x75\x00\x69\x00\xba\x00\x78\x00\x79\x00\xbd\x00\x69\x00\xbf\x00\x69\x00\xc1\x00\x2f\x01\x30\x01\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x69\x00\xc9\x00\xca\x00\xcb\x00\x37\x00\x0e\x01\x0f\x01\x8c\x00\xb1\x00\xb2\x00\xb3\x00\x08\x01\x09\x01\x6f\x00\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xb1\x00\xb2\x00\xb3\x00\x69\x00\x49\x00\xb1\x00\xb2\x00\xb3\x00\x18\x01\x19\x01\x1a\x01\x50\x00\x70\x00\x71\x00\x67\x00\x54\x00\xf4\x00\xf5\x00\x63\x00\x58\x00\x6f\x00\x25\x01\x10\x00\x11\x00\x5d\x00\x50\x00\xf5\x00\xf6\x00\x10\x00\x11\x00\x4b\x00\x65\x00\xa3\x00\xa4\x00\xb5\x00\xb6\x00\xff\x00\x00\x01\x5f\x00\xba\x00\x03\x01\x04\x01\xbd\x00\x70\x00\xbf\x00\x6f\x00\xc1\x00\x74\x00\x75\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x5f\x00\xc9\x00\xca\x00\xcb\x00\x16\x00\x49\x00\x4a\x00\x4b\x00\xab\x00\xac\x00\x4e\x00\x1b\x01\x1c\x01\x50\x00\x1e\x01\x1f\x01\x54\x00\x34\x00\x35\x00\x6f\x00\x58\x00\x25\x01\x4e\x00\x27\x01\x28\x01\x5d\x00\x63\x00\x2b\x01\x69\x00\x6f\x00\x4a\x00\x47\x00\x47\x00\x67\x00\x4d\x00\x4e\x00\x4a\x00\x80\x00\x47\x00\x69\x00\x69\x00\x47\x00\x4e\x00\x70\x00\x70\x00\xf5\x00\xf6\x00\x6f\x00\x74\x00\x75\x00\x70\x00\x72\x00\x78\x00\x79\x00\x18\x00\xff\x00\x00\x01\xfc\x00\xfd\x00\x03\x01\x04\x01\x4a\x00\x01\x01\xba\x00\x03\x01\x04\x01\xbd\x00\x4a\x00\xbf\x00\x18\x00\xc1\x00\x69\x00\x4b\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x7f\x00\x4e\x00\xca\x00\xcb\x00\x7f\x00\x47\x00\x1b\x01\x1c\x01\x47\x00\x1e\x01\x1f\x01\x1b\x01\x73\x00\x15\x00\x0b\x00\x1f\x01\x25\x01\x68\x00\x27\x01\x28\x01\x8c\x00\x25\x01\x2b\x01\x18\x00\x28\x01\x91\x00\x18\x00\x93\x00\x94\x00\x95\x00\x7f\x00\x97\x00\x98\x00\x69\x00\x47\x00\x4e\x00\x6e\x00\x18\x00\x67\x00\x63\x00\x6f\x00\x4a\x00\x70\x00\x4a\x00\x4a\x00\xf5\x00\xf6\x00\x4a\x00\x5d\x00\x4e\x00\x6f\x00\x4b\x00\x18\x00\x18\x00\x07\x00\xff\x00\x00\x01\x19\x00\x53\x00\x03\x01\x04\x01\x47\x00\x4e\x00\x8c\x00\x67\x00\x4e\x00\x7c\x00\x4e\x00\x91\x00\xbd\x00\x93\x00\x94\x00\x95\x00\xfd\x00\x97\x00\x98\x00\x6e\x00\x01\x01\x63\x00\x03\x01\x04\x01\x18\x00\xca\x00\x1b\x01\x1c\x01\x69\x00\x1e\x01\x1f\x01\x6e\x00\x67\x00\x47\x00\x72\x00\x47\x00\x25\x01\x18\x00\x27\x01\x28\x01\x8c\x00\x69\x00\x2b\x01\x63\x00\x69\x00\x91\x00\x1b\x01\x93\x00\x94\x00\x95\x00\x1f\x01\x97\x00\x98\x00\x6e\x00\x18\x00\xbd\x00\x25\x01\x4e\x00\x2b\x00\x28\x01\x6e\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\x4b\x00\xfd\x00\xca\x00\x6f\x00\x8c\x00\x01\x01\x47\x00\x03\x01\x04\x01\x91\x00\x47\x00\x93\x00\x94\x00\x95\x00\x5d\x00\x97\x00\x98\x00\x18\x00\x07\x00\x4e\x00\x07\x00\x08\x01\x09\x01\xbd\x00\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\x18\x00\x4a\x00\x1b\x01\x67\x00\x5d\x00\x7f\x00\x1f\x01\xca\x00\x18\x01\x19\x01\x1a\x01\x68\x00\x25\x01\x69\x00\x6f\x00\x28\x01\x15\x00\x4a\x00\x50\x00\x6e\x00\x69\x00\x25\x01\x4e\x00\x6e\x00\xbd\x00\x4b\x00\xfe\x00\x69\x00\x00\x01\x69\x00\x10\x00\x03\x01\x21\x00\x5d\x00\x31\x00\x08\x01\x09\x01\xca\x00\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\x53\x00\x53\x00\x19\x00\x07\x00\x72\x00\x08\x00\x38\x00\x68\x00\x18\x01\x19\x01\x1a\x01\x66\x00\x1b\x01\x2c\x00\x6e\x00\x53\x00\x1f\x01\x6f\x00\x69\x00\x58\x00\x41\x00\x25\x01\x25\x01\x63\x00\x27\x01\x28\x01\x08\x01\x09\x01\x02\x00\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\x69\x00\x63\x00\x6f\x00\x5d\x00\x4a\x00\x69\x00\x4a\x00\x8c\x00\x18\x01\x19\x01\x1a\x01\x63\x00\x91\x00\x68\x00\x93\x00\x94\x00\x95\x00\x02\x00\x97\x00\x98\x00\x18\x00\x25\x01\x08\x01\x09\x01\x68\x00\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\x4e\x00\x68\x00\x58\x00\x69\x00\x18\x00\x07\x00\x18\x00\x8c\x00\x18\x01\x19\x01\x1a\x01\x90\x00\x91\x00\x49\x00\x93\x00\x94\x00\x95\x00\x74\x00\x97\x00\x98\x00\x07\x00\x25\x01\x69\x00\x12\x00\x74\x00\x2e\x00\xbd\x00\x2d\x01\xe9\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\x59\x00\xfd\x00\x92\x00\x2d\x01\x36\x00\x01\x01\xca\x00\x03\x01\x04\x01\xe9\x00\xe9\x00\xce\x00\x5a\x00\x44\x00\x2e\x01\x82\x00\x16\x00\x2f\x00\x2d\x01\x2d\x01\x2c\x01\x8c\x00\x16\x00\xbd\x00\x30\x00\x90\x00\x91\x00\x83\x00\x93\x00\x94\x00\x95\x00\x1b\x01\x97\x00\x98\x00\x83\x00\x1f\x01\xca\x00\x7f\x00\x92\x00\x23\x01\x24\x01\x25\x01\x26\x01\x7f\x00\x28\x01\x5a\x00\x2a\x01\xa1\x00\x87\x00\x1d\x01\x2e\x01\x8c\x00\x76\x00\x2e\x01\xcc\x00\x90\x00\x91\x00\xc2\x00\x93\x00\x94\x00\x95\x00\xdc\x00\x97\x00\x98\x00\x1d\x01\x16\x00\x16\x00\x20\x00\x08\x01\x09\x01\xbd\x00\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\x2e\x00\x59\x00\x7f\x00\x20\x00\x7f\x00\x2c\x01\x03\x00\xca\x00\x18\x01\x19\x01\x1a\x01\x0a\x00\xe4\x00\x07\x01\x08\x01\x09\x01\x2c\x01\xdc\x00\x0c\x01\x0d\x01\x2c\x01\x25\x01\x08\x01\x09\x01\xbd\x00\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\x18\x01\x6a\x00\x1a\x01\x8c\x00\x1d\x01\x2c\x01\x55\x00\xca\x00\x18\x01\x19\x01\x1a\x01\x94\x00\x95\x00\x25\x01\x97\x00\x98\x00\x2c\x01\x44\x00\x6e\x00\x56\x00\x28\x01\x25\x01\x8c\x00\x78\x00\x76\x00\x74\x00\x90\x00\x91\x00\x80\x00\x93\x00\x94\x00\x95\x00\x32\x00\x97\x00\x98\x00\x0f\x01\x20\x00\x20\x00\x2a\x00\x08\x01\x09\x01\x31\x00\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\x64\x00\x48\x00\x5f\x00\x69\x00\x6d\x00\xbd\x00\x72\x00\x2a\x00\x18\x01\x19\x01\x1a\x01\xa6\x00\x0f\x00\x2c\x01\x1c\x00\x1c\x00\xc2\x00\x72\x00\xca\x00\xe4\x00\xa6\x00\x25\x01\x08\x01\x09\x01\xbd\x00\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\x00\x00\x01\xa4\x00\x17\x00\x03\x01\x04\x01\xb3\x00\xca\x00\x18\x01\x19\x01\x1a\x01\x4b\x00\x2d\x01\x24\x00\x17\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x25\x01\x93\x00\x94\x00\x95\x00\x2a\x00\x97\x00\x98\x00\x32\x00\x1c\x01\x2d\x01\x1e\x01\x1f\x01\x51\x00\x4c\x00\x2c\x01\x51\x00\x2c\x01\x25\x01\x50\x00\x27\x01\x28\x01\x46\x00\x1d\x01\x2c\x01\x2f\x00\x11\x00\x0c\x00\x2d\x01\x16\x00\x08\x01\x09\x01\x2c\x01\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\x2d\x01\x5a\x00\x57\x00\x33\x00\x57\x00\x16\x00\xbd\x00\x2c\x01\x18\x01\x19\x01\x1a\x01\x08\x01\x09\x01\x2c\x01\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xca\x00\x2d\x01\x25\x01\x2c\x01\x2c\x01\x55\x00\x20\x00\x20\x00\x18\x01\x19\x01\x1a\x01\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x17\x00\x93\x00\x94\x00\x95\x00\x25\x01\x97\x00\x98\x00\x2d\x01\x2d\x01\xa6\x00\x9c\x00\x9d\x00\x17\x00\x2d\x01\x2d\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xff\xff\xfd\x00\xf5\x00\xff\xff\xff\xff\x01\x01\xff\xff\x03\x01\x04\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xbd\x00\xbd\x00\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xc7\x00\x1b\x01\xca\x00\xca\x00\xcb\x00\x1f\x01\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\x25\x01\xff\xff\xff\xff\x28\x01\xff\xff\xff\xff\xff\xff\x23\x01\x24\x01\x25\x01\x26\x01\xff\xff\xff\xff\x29\x01\x2a\x01\xff\xff\xff\xff\xff\xff\x2e\x01\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\xff\xff\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\xff\xff\xf5\x00\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\xff\xff\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xbd\x00\x18\x01\x19\x01\x1a\x01\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xca\x00\x25\x01\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\xff\xff\x2e\x01\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\xff\xff\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x88\x00\x89\x00\xff\xff\xff\xff\x8c\x00\x8d\x00\xf5\x00\x8f\x00\x90\x00\x91\x00\xff\xff\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\x9a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xbd\x00\xff\xff\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xbd\x00\x25\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x88\x00\x89\x00\xff\xff\x2e\x01\x8c\x00\x8d\x00\xca\x00\x8f\x00\x90\x00\x91\x00\xff\xff\x93\x00\x94\x00\x95\x00\x49\x00\x97\x00\x98\x00\xff\xff\x9a\x00\xf5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\x69\x00\xff\xff\xff\xff\xf5\x00\xff\xff\xff\xff\x6f\x00\xbd\x00\x18\x01\x19\x01\x1a\x01\x74\x00\x75\x00\xff\xff\xff\xff\x78\x00\x79\x00\xff\xff\xff\xff\xff\xff\xca\x00\x25\x01\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\x2e\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\x88\x00\x89\x00\xff\xff\xff\xff\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x25\x01\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\x88\x00\x89\x00\xff\xff\xff\xff\x8c\x00\x8d\x00\xca\x00\x8f\x00\x90\x00\x91\x00\x25\x01\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xfe\x00\xff\xff\x00\x01\xff\xff\xff\xff\x03\x01\xff\xff\xff\xff\x06\x01\xff\xff\xff\xff\x89\x00\xff\xff\xff\xff\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x12\x01\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\x99\x00\xff\xff\x1b\x01\xff\xff\xff\xff\xf5\x00\x1f\x01\xff\xff\xff\xff\xbd\x00\x23\x01\x24\x01\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\xff\xff\xff\xff\xff\xff\xff\xff\xca\x00\x49\x00\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\x54\x00\xff\xff\xbd\x00\xff\xff\x58\x00\xff\xff\x18\x01\x19\x01\x1a\x01\x5d\x00\x89\x00\xff\xff\xff\xff\x8c\x00\x8d\x00\xca\x00\x8f\x00\x90\x00\x91\x00\x25\x01\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\x99\x00\xff\xff\x70\x00\xff\xff\xff\xff\xf5\x00\x74\x00\x75\x00\xff\xff\xff\xff\x78\x00\x79\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xf5\x00\xff\xff\xff\xff\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xca\x00\xff\xff\x08\x01\x09\x01\x25\x01\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\x89\x00\xff\xff\xff\xff\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x25\x01\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\x99\x00\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\x89\x00\xff\xff\x8b\x00\x8c\x00\x8d\x00\xca\x00\x8f\x00\x90\x00\x91\x00\x25\x01\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\xff\xff\x8b\x00\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xff\xff\xff\xff\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xca\x00\xff\xff\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\x89\x00\xff\xff\x8b\x00\x8c\x00\x8d\x00\xca\x00\x8f\x00\x90\x00\x91\x00\x25\x01\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\x49\x00\x4a\x00\xff\xff\xff\xff\xff\xff\xf5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xf5\x00\xff\xff\xff\xff\xff\xff\xbd\x00\xff\xff\xff\xff\x70\x00\x18\x01\x19\x01\x1a\x01\x74\x00\x75\x00\xff\xff\xff\xff\x78\x00\x79\x00\xca\x00\xff\xff\x08\x01\x09\x01\x25\x01\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\x89\x00\xff\xff\xff\xff\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x25\x01\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\x89\x00\xff\xff\xff\xff\x8c\x00\x8d\x00\xca\x00\x8f\x00\x90\x00\x91\x00\x25\x01\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\xff\xff\xff\xff\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xff\xff\xff\xff\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xca\x00\xff\xff\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\x89\x00\xff\xff\xff\xff\x8c\x00\x8d\x00\xca\x00\x8f\x00\x90\x00\x91\x00\x25\x01\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\x49\x00\xff\xff\x4b\x00\xff\xff\xff\xff\xf5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xf5\x00\xff\xff\xff\xff\xff\xff\xbd\x00\xff\xff\xff\xff\x70\x00\x18\x01\x19\x01\x1a\x01\x74\x00\x75\x00\xff\xff\xff\xff\x78\x00\x79\x00\xca\x00\xff\xff\x08\x01\x09\x01\x25\x01\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\x89\x00\xff\xff\xff\xff\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x25\x01\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\x89\x00\xff\xff\xff\xff\x8c\x00\x8d\x00\xca\x00\x8f\x00\x90\x00\x91\x00\x25\x01\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\xff\xff\xff\xff\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xff\xff\xff\xff\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xca\x00\xff\xff\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\x89\x00\xff\xff\xff\xff\x8c\x00\x8d\x00\xca\x00\x8f\x00\x90\x00\x91\x00\x25\x01\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\x49\x00\x4a\x00\xff\xff\xff\xff\xff\xff\xf5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xf5\x00\xff\xff\xff\xff\xff\xff\xbd\x00\xff\xff\xff\xff\x70\x00\x18\x01\x19\x01\x1a\x01\x74\x00\x75\x00\xff\xff\xff\xff\x78\x00\x79\x00\xca\x00\xff\xff\x08\x01\x09\x01\x25\x01\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\xff\xff\x93\x00\x94\x00\x95\x00\x25\x01\x97\x00\x98\x00\xff\xff\xff\xff\x9b\x00\x9c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\xff\xff\xca\x00\xff\xff\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x25\x01\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\xff\xff\x9b\x00\x9c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\xff\xff\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\x9c\x00\xff\xff\xff\xff\xff\xff\xf5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x06\x01\xff\xff\xff\xff\xff\xff\x08\x01\x09\x01\xca\x00\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\x13\x01\xbd\x00\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\xff\xff\xff\xff\x20\x01\xca\x00\x22\x01\x23\x01\x24\x01\xff\xff\x26\x01\x25\x01\xff\xff\x29\x01\x2a\x01\xff\xff\xff\xff\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\xff\xff\x93\x00\x94\x00\x95\x00\xf5\x00\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\x9c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x08\x01\x09\x01\xf5\x00\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\xbd\x00\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\x25\x01\xff\xff\xff\xff\xff\xff\xca\x00\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x25\x01\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\x9d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xff\xff\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\xff\xff\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\xff\xff\xbd\x00\x9c\x00\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\xff\xff\xbd\x00\xff\xff\xff\xff\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\xff\xff\x93\x00\x94\x00\x95\x00\xca\x00\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\x9c\x00\xff\xff\xff\xff\xf5\x00\xff\xff\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\xff\xff\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xf5\x00\x18\x01\x19\x01\x1a\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\xff\xff\xbd\x00\xff\xff\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x25\x01\x93\x00\x94\x00\x95\x00\xf5\x00\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa0\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x08\x01\x09\x01\xf5\x00\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\xbd\x00\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\x25\x01\xff\xff\xff\xff\xff\xff\xca\x00\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x25\x01\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\xff\xff\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xbd\x00\xff\xff\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\xbd\x00\xff\xff\xff\xff\x8c\x00\x8d\x00\x06\x01\x8f\x00\x90\x00\x91\x00\xff\xff\x93\x00\x94\x00\x95\x00\xca\x00\x97\x00\x98\x00\xff\xff\xff\xff\x13\x01\xff\xff\x15\x01\x16\x01\xff\xff\xf5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xa5\x00\xff\xff\xff\xff\x20\x01\xff\xff\x22\x01\x23\x01\x24\x01\xff\xff\x26\x01\x06\x01\xff\xff\x29\x01\x2a\x01\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\x13\x01\xbd\x00\x15\x01\x16\x01\xff\xff\xf5\x00\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\xff\xff\xff\xff\x20\x01\xca\x00\x22\x01\x23\x01\x24\x01\xff\xff\x26\x01\x25\x01\xff\xff\x29\x01\x2a\x01\x08\x01\x09\x01\x8c\x00\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x25\x01\x93\x00\x94\x00\x95\x00\xf5\x00\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xbd\x00\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xca\x00\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\xbd\x00\xff\xff\xff\xff\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x25\x01\x93\x00\x94\x00\x95\x00\xca\x00\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa5\x00\xff\xff\xff\xff\xbd\x00\xff\xff\x08\x01\x09\x01\xf5\x00\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\xbd\x00\xff\xff\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\x25\x01\xff\xff\xff\xff\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x25\x01\x93\x00\x94\x00\x95\x00\xf5\x00\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa5\x00\xff\xff\xff\xff\xff\xff\x08\x01\x09\x01\xf5\x00\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\xbd\x00\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\x25\x01\xff\xff\xff\xff\xff\xff\xca\x00\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x25\x01\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xff\xff\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\xff\xff\xbd\x00\xff\xff\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xa5\x00\xff\xff\xff\xff\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\xff\xff\xbd\x00\xff\xff\xff\xff\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\x93\x00\x94\x00\x95\x00\xca\x00\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xf5\x00\x18\x01\x19\x01\x1a\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\xff\xff\xff\xff\xff\xff\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x25\x01\x93\x00\x94\x00\x95\x00\xf5\x00\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa5\x00\xff\xff\xff\xff\xff\xff\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\xbd\x00\xff\xff\xff\xff\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x25\x01\x93\x00\x94\x00\x95\x00\xca\x00\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa5\x00\xff\xff\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xf5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xbd\x00\xff\xff\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x25\x01\x93\x00\x94\x00\x95\x00\xf5\x00\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x08\x01\x09\x01\xf5\x00\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\xbd\x00\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\x25\x01\xff\xff\xff\xff\xff\xff\xca\x00\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x25\x01\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\x8d\x00\xf5\x00\x8f\x00\x90\x00\x91\x00\xff\xff\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xbd\x00\xff\xff\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xbd\x00\x25\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\x8d\x00\xca\x00\x8f\x00\x90\x00\x91\x00\xff\xff\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\xff\xff\xf5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\xf5\x00\xff\xff\xff\xff\xff\xff\xbd\x00\x18\x01\x19\x01\x1a\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xca\x00\x25\x01\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\x93\x00\x94\x00\x95\x00\x25\x01\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\xff\xff\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\x8c\x00\x8d\x00\xca\x00\x8f\x00\x90\x00\x91\x00\xff\xff\x93\x00\x94\x00\x95\x00\x25\x01\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\x8d\x00\xca\x00\x8f\x00\x90\x00\x91\x00\xff\xff\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xff\xff\xff\xff\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xca\x00\xff\xff\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xf5\x00\xff\xff\xff\xff\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xca\x00\xff\xff\x08\x01\x09\x01\x25\x01\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xff\xff\x18\x01\x19\x01\x1a\x01\x8c\x00\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x25\x01\x97\x00\x98\x00\xff\xff\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xf5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\xad\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xbd\x00\x08\x01\x09\x01\x25\x01\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xbd\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\x8c\x00\x18\x01\x19\x01\x1a\x01\x90\x00\x91\x00\xca\x00\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\x25\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x91\x00\xff\xff\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xbd\x00\xff\x00\x00\x01\x8c\x00\xff\xff\x03\x01\x04\x01\xff\xff\x91\x00\xff\xff\x93\x00\x94\x00\x95\x00\xca\x00\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\x08\x01\x09\x01\xbd\x00\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xca\x00\x18\x01\x19\x01\x1a\x01\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\x8c\x00\xff\xff\x25\x01\xff\xff\xff\xff\x91\x00\xbd\x00\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xca\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\xbd\x00\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\x25\x01\xff\xff\xff\xff\xff\xff\xca\x00\xff\xff\x8c\x00\xff\xff\x18\x01\x19\x01\x1a\x01\x91\x00\xff\xff\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\xff\xff\x25\x01\xff\xff\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xff\xff\x18\x01\x19\x01\x1a\x01\x91\x00\xff\xff\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\xff\xff\x25\x01\xff\xff\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x08\x01\x09\x01\xca\x00\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xff\xff\x18\x01\x19\x01\x1a\x01\x91\x00\xbd\x00\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\xff\xff\x25\x01\xff\xff\xff\xff\xff\xff\xca\x00\xff\xff\x8c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x91\x00\xff\xff\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xbd\x00\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xca\x00\xff\xff\x8c\x00\xff\xff\x18\x01\x19\x01\x1a\x01\x91\x00\xbd\x00\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\xff\xff\x25\x01\xff\xff\x08\x01\x09\x01\xca\x00\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x00\xff\xff\x18\x01\x19\x01\x1a\x01\x91\x00\xff\xff\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\xff\xff\x25\x01\xff\xff\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x08\x01\x09\x01\xca\x00\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\xbd\x00\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\x25\x01\xff\xff\xff\xff\xff\xff\xca\x00\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x08\x01\x09\x01\xff\xff\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x01\x19\x01\x1a\x01\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\x25\x01\x07\x00\x08\x00\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\x11\x00\xff\xff\xff\xff\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\xff\xff\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\xff\xff\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\xff\xff\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\x08\x00\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\x11\x00\xff\xff\xff\xff\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\xff\xff\x4e\x00\x4f\x00\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\xff\xff\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\xff\xff\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\x08\x00\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\x11\x00\xff\xff\xff\xff\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\xff\xff\x4e\x00\x4f\x00\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\xff\xff\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\xff\xff\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\x08\x00\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\x11\x00\xff\xff\xff\xff\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\xff\xff\x4e\x00\x4f\x00\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\xff\xff\xff\xff\x60\x00\x61\x00\x62\x00\x63\x00\xff\xff\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\x08\x00\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\x11\x00\xff\xff\xff\xff\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\xff\xff\x4e\x00\x4f\x00\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\xff\xff\xff\xff\x60\x00\x61\x00\x62\x00\x63\x00\xff\xff\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\x08\x00\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\x11\x00\xff\xff\xff\xff\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\xff\xff\x4e\x00\x4f\x00\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\xff\xff\xff\xff\x60\x00\x61\x00\x62\x00\x63\x00\xff\xff\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\x08\x00\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\x11\x00\xff\xff\xff\xff\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\xff\xff\x4e\x00\x4f\x00\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\xff\xff\xff\xff\x60\x00\x61\x00\xff\xff\x63\x00\xff\xff\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\x08\x00\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\x11\x00\xff\xff\xff\xff\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\xff\xff\x4e\x00\x4f\x00\x50\x00\x51\x00\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\xff\xff\xff\xff\x60\x00\x61\x00\xff\xff\x63\x00\xff\xff\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\xff\xff\x4e\x00\x4f\x00\x50\x00\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\xff\xff\xff\xff\x60\x00\xff\xff\xff\xff\x63\x00\xff\xff\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\xff\xff\x4e\x00\x4f\x00\x50\x00\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\xff\xff\xff\xff\x60\x00\xff\xff\xff\xff\x63\x00\xff\xff\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\xff\xff\x4e\x00\x4f\x00\x50\x00\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\xff\xff\xff\xff\x60\x00\xff\xff\xff\xff\x63\x00\xff\xff\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\x6e\x00\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x00\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\xff\xff\xff\xff\xff\xff\x4e\x00\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\xff\xff\x60\x00\x61\x00\x62\x00\x63\x00\xff\xff\x65\x00\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\x6e\x00\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\xff\xff\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\xff\xff\xff\xff\x7e\x00\x7f\x00\x80\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x8f\x00\x09\x00\x0a\x00\x92\x00\x93\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\xff\xff\x13\x00\xff\xff\x15\x00\xff\xff\x17\x00\xff\xff\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\x39\x00\x3a\x00\x3b\x00\x3c\x00\xff\xff\xff\xff\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\xff\xff\x4c\x00\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\x52\x00\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\xff\xff\x5f\x00\x60\x00\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\x66\x00\x67\x00\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\x4c\x00\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\x69\x00\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\x5f\x00\x60\x00\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\x5f\x00\x60\x00\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\x5f\x00\x60\x00\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\x17\x00\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\xff\xff\x11\x00\xff\xff\x13\x00\xff\xff\x15\x00\xff\xff\x17\x00\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\x17\x00\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\xff\xff\x11\x00\xff\xff\x13\x00\xff\xff\x15\x00\xff\xff\x17\x00\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\x4c\x00\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\x6b\x00\x6c\x00\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\x69\x00\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\x6b\x00\x6c\x00\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\x67\x00\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\x4c\x00\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\x0d\x00\x0e\x00\x0f\x00\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\x4e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\x6e\x00\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\x16\x00\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\x6e\x00\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\x16\x00\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\x4d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x55\x00\x56\x00\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x55\x00\x56\x00\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x55\x00\x56\x00\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\x6d\x00\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x55\x00\x56\x00\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\xff\xff\x60\x00\x61\x00\x62\x00\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\xff\xff\x77\x00\x78\x00\x79\x00\x01\x00\x02\x00\xff\xff\xff\xff\x7e\x00\x7f\x00\x80\x00\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\x8f\x00\xff\xff\xff\xff\x92\x00\x93\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\xff\xff\x60\x00\x61\x00\x62\x00\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\xff\xff\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\x01\x00\x02\x00\x7e\x00\x7f\x00\x80\x00\xff\xff\xff\xff\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8f\x00\x15\x00\xff\xff\x92\x00\x93\x00\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x02\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x00\x1c\x00\x1d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\xff\xff\x72\x00\x73\x00\x74\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\x7f\x00\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\xff\xff\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\x7f\x00\x80\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8f\x00\xff\xff\xff\xff\x92\x00\x93\x00\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\x6b\x00\xff\xff\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\xff\xff\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\x7f\x00\x80\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8f\x00\xff\xff\xff\xff\x92\x00\x93\x00\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\xff\xff\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\x7f\x00\x80\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8f\x00\xff\xff\xff\xff\x92\x00\x93\x00\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\x66\x00\x67\x00\x68\x00\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\xff\xff\x77\x00\x78\x00\x79\x00\x01\x00\x02\x00\x7c\x00\xff\xff\x7e\x00\x7f\x00\x80\x00\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\x8f\x00\xff\xff\xff\xff\x92\x00\x93\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\xff\xff\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\x01\x00\x02\x00\x7e\x00\x7f\x00\x80\x00\xff\xff\xff\xff\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\xff\xff\xff\xff\x8f\x00\x15\x00\xff\xff\x92\x00\x93\x00\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\xff\xff\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\x01\x00\x02\x00\x7e\x00\x7f\x00\x80\x00\xff\xff\xff\xff\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8f\x00\x15\x00\xff\xff\x92\x00\x93\x00\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\xff\xff\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\x7f\x00\x80\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8f\x00\xff\xff\xff\xff\x92\x00\x93\x00\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\xff\xff\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\x7f\x00\x80\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8f\x00\xff\xff\xff\xff\x92\x00\x93\x00\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\xff\xff\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\x01\x00\x02\x00\x7e\x00\x7f\x00\x80\x00\xff\xff\xff\xff\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8f\x00\x15\x00\xff\xff\x92\x00\x93\x00\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\xff\xff\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\x01\x00\x02\x00\x7e\x00\x7f\x00\x80\x00\xff\xff\xff\xff\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8f\x00\x15\x00\xff\xff\x92\x00\x93\x00\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\xff\xff\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\x7f\x00\x80\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8f\x00\xff\xff\xff\xff\x92\x00\x93\x00\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\xff\xff\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\x7f\x00\x80\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8f\x00\xff\xff\xff\xff\x92\x00\x93\x00\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\xff\xff\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\x7f\x00\x80\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8f\x00\xff\xff\xff\xff\x92\x00\x93\x00\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\xff\xff\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\x01\x00\x02\x00\x7e\x00\x7f\x00\x80\x00\xff\xff\xff\xff\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8f\x00\x15\x00\xff\xff\x92\x00\x93\x00\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\xff\xff\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\x01\x00\x02\x00\x7e\x00\x7f\x00\x80\x00\xff\xff\xff\xff\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8f\x00\x15\x00\xff\xff\x92\x00\x93\x00\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\xff\xff\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\x01\x00\x02\x00\x7e\x00\x7f\x00\x80\x00\xff\xff\xff\xff\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8f\x00\x15\x00\xff\xff\x92\x00\x93\x00\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\xff\xff\x77\x00\x78\x00\x79\x00\xff\xff\xff\xff\x01\x00\x02\x00\x7e\x00\x7f\x00\x80\x00\xff\xff\xff\xff\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8f\x00\x15\x00\xff\xff\x92\x00\x93\x00\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\xff\xff\x77\x00\x78\x00\x79\x00\x01\x00\x02\x00\xff\xff\xff\xff\x7e\x00\x7f\x00\x80\x00\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\x8f\x00\xff\xff\xff\xff\x92\x00\x93\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3d\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\x56\x00\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\xff\xff\x77\x00\x78\x00\x79\x00\x01\x00\x02\x00\xff\xff\xff\xff\x7e\x00\x7f\x00\x80\x00\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\x8f\x00\xff\xff\xff\xff\x92\x00\x93\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x55\x00\x56\x00\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\xff\xff\x77\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\x7e\x00\x7f\x00\x80\x00\xff\xff\xff\xff\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8f\x00\x15\x00\xff\xff\x92\x00\x93\x00\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x02\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\xff\xff\x72\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\x7f\x00\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\x68\x00\x02\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x09\x00\xff\xff\x72\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\x7f\x00\xff\xff\xff\xff\x1b\x00\x1c\x00\x1d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x00\x1c\x00\x1d\x00\xff\xff\x7f\x00\xff\xff\xff\xff\x02\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\x09\x00\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x15\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x00\x1c\x00\x1d\x00\x72\x00\x73\x00\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x7f\x00\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\x7f\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\x72\x00\x73\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\x02\x00\x68\x00\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\x09\x00\xff\xff\x70\x00\xff\xff\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x02\x00\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\x72\x00\x73\x00\x74\x00\x75\x00\xff\xff\x77\x00\x15\x00\x79\x00\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x02\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\xff\xff\xff\xff\x15\x00\xff\xff\x17\x00\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\x2d\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\xff\xff\xff\xff\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\x12\x00\xff\xff\xff\xff\x15\x00\xff\xff\x17\x00\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\x2d\x00\x68\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x6f\x00\xff\xff\xff\xff\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\x68\x00\xff\xff\x02\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x09\x00\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\x09\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\xff\xff\x15\x00\x76\x00\x77\x00\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x02\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\x17\x00\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\x02\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\xff\xff\x72\x00\x73\x00\x48\x00\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\x68\x00\x02\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x09\x00\xff\xff\x72\x00\x73\x00\xff\xff\xff\xff\x76\x00\x77\x00\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x02\x00\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\x09\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\xff\xff\x15\x00\xff\xff\x77\x00\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x02\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\xff\xff\x15\x00\x76\x00\x77\x00\xff\xff\xff\xff\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xc0\x00\xc1\x00\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\x72\x00\x73\x00\xff\xff\xff\xff\xff\xff\x77\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xc0\x00\xc1\x00\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\x72\x00\x73\x00\xff\xff\xff\xff\xff\xff\x77\x00\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x32\x01\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\xff\xff\xff\xff\xff\xff\xbd\x00\xbe\x00\xbf\x00\x32\x01\xc1\x00\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xff\xff\xca\x00\xcb\x00\x48\x00\x49\x00\x4a\x00\xff\xff\xd0\x00\xd1\x00\x4e\x00\xff\xff\x50\x00\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\xff\xff\x6f\x00\x70\x00\xf5\x00\xf6\x00\xff\xff\x74\x00\x75\x00\xff\xff\xff\xff\x78\x00\x79\x00\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\xff\xff\x17\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\x21\x01\x22\x01\x23\x01\x24\x01\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\xff\xff\xff\xff\x2e\x01\xff\xff\x30\x01\x31\x01\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xff\xff\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xd0\x00\xd1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xbd\x00\x06\x01\xbf\x00\xff\xff\xc1\x00\xff\xff\xff\xff\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\x14\x01\x15\x01\xff\xff\x17\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\x21\x01\x22\x01\x23\x01\x24\x01\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\xff\xff\xff\xff\x2e\x01\xff\xff\x30\x01\x31\x01\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xf5\x00\xf6\x00\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xd0\x00\xd1\x00\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\xff\xff\x17\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\x21\x01\x22\x01\xff\xff\x24\x01\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\xff\xff\xff\xff\x2e\x01\xff\xff\x30\x01\x31\x01\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\x02\x00\xff\xff\xff\xff\xff\xff\xd0\x00\xff\xff\xff\xff\x09\x00\xd4\x00\xd5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xf5\x00\xf6\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\xff\xff\x17\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\x21\x01\x22\x01\xff\xff\x24\x01\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\x31\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\x72\x00\x73\x00\xff\xff\xd0\x00\xff\xff\xff\xff\xd3\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\xff\xff\x17\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\x21\x01\x22\x01\xff\xff\x24\x01\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\x31\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xd0\x00\xff\xff\xff\xff\xd3\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\xff\xff\x17\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\x21\x01\x22\x01\xff\xff\x24\x01\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\x31\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\x02\x00\xff\xff\xff\xff\xff\xff\xd0\x00\xff\xff\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x00\x1c\x00\x1d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xf5\x00\xf6\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\xff\xff\x17\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\x21\x01\x22\x01\xff\xff\x24\x01\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\x31\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\x02\x00\x72\x00\x73\x00\xff\xff\xd0\x00\xff\xff\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xf5\x00\xf6\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\xff\xff\x17\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\x21\x01\x22\x01\xff\xff\x24\x01\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\x31\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\x02\x00\x72\x00\xff\xff\xff\xff\xd0\x00\xff\xff\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xf5\x00\xf6\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\xff\xff\x17\x01\xff\xff\xff\xff\x50\x00\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\x21\x01\x22\x01\xff\xff\x24\x01\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\x31\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\x02\x00\x72\x00\xff\xff\xff\xff\xd0\x00\xff\xff\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xf5\x00\xf6\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\xff\xff\x17\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\x21\x01\x22\x01\xff\xff\x24\x01\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\x31\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\x72\x00\xff\xff\xff\xff\xd0\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\xff\xff\x17\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\x21\x01\x22\x01\xff\xff\x24\x01\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\x31\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xd0\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\x06\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x15\x01\xff\xff\x17\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\x21\x01\x22\x01\xff\xff\x24\x01\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\x31\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\xdd\x00\xde\x00\xdf\x00\xff\xff\xff\xff\x31\x01\xff\xff\xff\xff\xe5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xd7\x00\xd8\x00\xd9\x00\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\x2c\x01\xff\xff\xff\xff\xe6\x00\xff\xff\x31\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\x02\x00\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\x09\x00\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\x10\x00\xff\xff\x2b\x01\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\x31\x01\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xf5\x00\xf6\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\xff\xff\xff\xff\xe6\x00\xff\xff\x66\x00\x31\x01\x68\x00\xff\xff\xec\x00\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\xf5\x00\xf6\x00\xff\xff\x76\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\xff\xff\xff\xff\xe6\x00\xff\xff\xff\xff\x31\x01\xff\xff\xeb\x00\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\xff\xff\xff\xff\xe6\x00\xff\xff\xff\xff\x31\x01\xea\x00\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\xff\xff\xff\xff\xe6\x00\xff\xff\xff\xff\x31\x01\xea\x00\xff\xff\xff\xff\xed\x00\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xda\x00\xdb\x00\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\xff\xff\xff\xff\xe6\x00\xff\xff\xff\xff\x31\x01\xff\xff\xff\xff\xff\xff\xff\xff\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\xdd\x00\xde\x00\xdf\x00\xff\xff\xff\xff\x31\x01\xff\xff\xff\xff\xe5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xda\x00\xdb\x00\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\xff\xff\xff\xff\xe6\x00\xff\xff\xff\xff\x31\x01\xff\xff\xff\xff\xff\xff\xff\xff\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\xdd\x00\xde\x00\xdf\x00\xff\xff\xff\xff\x31\x01\xff\xff\xff\xff\xe5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\x31\x01\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x02\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xbd\x00\xbe\x00\xbf\x00\x66\x00\xc1\x00\x68\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\x72\x00\xff\xff\x48\x00\xff\xff\x76\x00\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xff\xff\xe2\x00\xe3\x00\xe4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\x72\x00\xff\xff\xe6\x00\xff\xff\x76\x00\xff\xff\xff\xff\xff\x00\x00\x01\xed\x00\xee\x00\x03\x01\x04\x01\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\x31\x01\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\x31\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xee\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\x31\x01\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xee\x00\xff\xff\x68\x00\xff\xff\xff\xff\xdf\x00\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xe5\x00\x72\x00\xff\xff\xff\xff\xff\xff\x76\x00\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\x31\x01\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\x31\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xe5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\x31\x01\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\x31\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe5\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\x31\x01\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\x31\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\x31\x01\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\x31\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\x31\x01\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\x31\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\x31\x01\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\x31\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\x31\x01\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\x31\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\x31\x01\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\x31\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\x31\x01\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\x31\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\x31\x01\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\x31\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\x31\x01\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\x31\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\x31\x01\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\x31\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\x31\x01\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\x31\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\x31\x01\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\x31\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\x31\x01\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\x31\x01\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xbd\x00\xbe\x00\xbf\x00\xff\xff\xc1\x00\xff\xff\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\x02\x00\xff\xff\x2b\x01\x1c\x01\xff\xff\x1e\x01\x1f\x01\x09\x00\x31\x01\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\x31\x01\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\x02\x00\x68\x00\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x09\x00\x6f\x00\xff\xff\xff\xff\x72\x00\x73\x00\x74\x00\x75\x00\xff\xff\x12\x00\xff\xff\xff\xff\x15\x00\xff\xff\x17\x00\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x02\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\x72\x00\x73\x00\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x02\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\x72\x00\x73\x00\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x02\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x73\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\xff\xff\x66\x00\xff\xff\x68\x00\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\x72\x00\x73\x00\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\x4b\x00\xff\xff\xff\xff\x19\x00\x4f\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\x62\x00\x02\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\x72\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x02\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\x72\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x02\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\x72\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x02\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x02\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\xff\xff\x72\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\xff\xff\x62\x00\xbd\x00\xff\xff\xbf\x00\xff\xff\xc1\x00\x68\x00\xff\xff\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\x72\x00\xbd\x00\xff\xff\xbf\x00\xff\xff\xc1\x00\xff\xff\xff\xff\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\x72\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xbd\x00\x2b\x01\xbf\x00\xff\xff\xc1\x00\xff\xff\xff\xff\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xe7\x00\xe8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xbd\x00\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe7\x00\xe8\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xe7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xbd\x00\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\xff\xff\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xcd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xbd\x00\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xbd\x00\x2b\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xf5\x00\xf6\x00\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xbd\x00\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xbd\x00\x2b\x01\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xc5\x00\xc6\x00\xc7\x00\xf5\x00\xf6\x00\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xbd\x00\x2b\x01\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xbd\x00\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xbd\x00\x2b\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xf5\x00\xf6\x00\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xbd\x00\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xbd\x00\x2b\x01\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xc5\x00\xc6\x00\xc7\x00\xf5\x00\xf6\x00\xca\x00\xcb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xbd\x00\x2b\x01\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\xff\xff\xbd\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x00\xc6\x00\xc7\x00\xff\xff\xff\xff\xca\x00\xcb\x00\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xf5\x00\xf6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x01\xff\xff\xff\xff\x03\x01\x04\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\x1c\x01\xff\xff\x1e\x01\x1f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x01\xff\xff\x27\x01\x28\x01\xff\xff\xff\xff\x2b\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#--happyTable :: HappyAddr-happyTable = HappyA# "\x00\x00\x70\x00\x1f\x05\x20\x05\x22\x05\x23\x05\x20\x01\x60\x04\x56\x05\x5d\x05\xca\x00\xfb\x04\x58\x05\x7a\x04\xf2\x02\x59\x05\xae\x04\x0e\x02\xad\x04\x0f\x02\x39\x03\x54\x05\xae\x04\x0e\x02\x1a\x05\x0f\x02\x22\x04\x23\x04\xae\x04\x0e\x02\xd9\x01\x0f\x02\x0d\x02\x0e\x02\x0e\x02\x0f\x02\xcc\x03\x64\x04\x65\x04\x2e\x03\x83\x02\x84\x02\x14\x04\xe6\x01\x95\x02\x83\x02\x84\x02\x41\x05\x46\x03\x2c\x03\xc4\x04\xe7\x00\x5c\x04\x8b\x03\x58\x04\x23\x04\xcb\x00\x56\x03\x62\x02\xf7\x04\x23\x04\x2c\x05\x66\x04\x6b\x04\x5a\x03\x04\x03\xda\x01\xdb\x01\xdc\x01\x31\x04\x32\x04\x33\x04\x59\x03\xef\x02\x36\x02\x03\x01\x34\x04\x35\x04\x48\x01\x43\x05\x32\x04\x33\x04\xe4\x01\xe5\x01\xe6\x01\x0b\x02\x34\x04\x35\x04\xf7\x03\xd4\x03\x4e\x05\x60\x05\x32\x04\x33\x04\x32\x03\x33\x03\xe7\x02\x46\x05\x34\x04\x35\x04\x22\x02\xe5\x01\xe6\x01\xe5\x04\x05\x03\xfd\x00\x0b\x02\x37\x02\x34\x04\x35\x04\x90\x02\x42\x05\xe9\x04\x35\x04\x1c\x04\xae\x02\x63\x03\xe6\x04\xe7\x04\xe8\x04\xe9\x04\x35\x04\xd9\x01\x00\x03\x7b\x04\xfb\x02\xd1\x02\x49\x01\x57\x03\x78\x02\x63\x02\x4f\x05\xd5\x03\xe8\x02\x27\x01\xff\x00\x97\x02\x68\x04\x7c\x04\x48\x00\x56\xff\xea\x00\x42\x05\x0b\x02\x8f\x00\x79\x02\x99\x02\x20\x03\x92\x00\x5b\x03\x28\x01\x94\x00\x95\x00\x96\x00\x97\x00\x04\x01\x9a\x02\x9b\x02\x9c\x02\xb5\x03\xdc\x01\x47\x03\x01\x03\xe7\x01\xfc\x02\x4d\x00\x21\x01\x22\x01\x73\x00\x0f\x01\x34\x03\xaf\x02\x64\x03\xf8\x03\x11\x01\xdd\x01\x4e\x00\x56\xff\xa1\x01\x11\x01\x11\x00\xe7\x01\x47\x05\x4d\x00\xab\x01\x11\x00\x0c\x02\x8c\x02\x36\x00\xdd\x01\x86\x02\xa2\x01\x24\x04\x11\x01\x4e\x00\x85\x02\x23\x01\xff\xff\x11\x00\x11\x00\x9e\x00\x9f\x00\x11\x00\xf3\x02\xe7\x01\x12\x01\x4d\x00\x0c\x02\x81\x00\x11\x00\xa0\x00\x72\x00\x7c\x04\x48\x00\x73\x00\x74\x00\x61\x04\x4e\x00\x61\x04\xfc\x04\x24\x04\x79\x02\xe7\x01\x7a\x02\x4d\x00\x24\x04\x11\x00\x4e\x00\xf3\x02\x4e\x00\x4e\x00\x11\x00\x29\x02\x2d\x03\x11\x00\x4e\x00\x2d\x03\x11\x01\xce\x00\xa1\x00\x11\x01\x0f\x00\xcf\x00\x11\x00\x0c\x02\x34\x03\x11\x00\xf1\x02\x11\x00\x11\x01\x7c\x00\x7d\x00\x8c\x00\x0d\x02\xa2\x00\x11\x00\x71\x00\x72\x00\x2b\x02\x24\x02\x73\x00\x74\x00\x2b\x04\x75\x00\x34\x03\xff\xff\x2c\x02\xdd\x01\x11\x01\x2a\x02\x2c\x04\x11\x01\x25\x02\xa2\x02\x11\x00\x18\x01\x19\x01\x11\x00\xaa\x02\x76\x00\x0e\x01\x0b\x02\x73\x00\x0f\x01\x0b\x02\x0e\x00\x0b\x02\x0f\x00\x10\x00\x77\x00\x21\x05\x78\x00\x79\x00\x7a\x00\x11\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x24\x05\x10\x02\x36\x04\x24\x05\x37\x04\x48\x00\x10\x01\x10\x02\x21\x05\xab\x02\x11\x01\x0b\x02\x36\x04\x10\x02\x37\x04\x48\x00\x11\x00\x10\x02\x10\x02\x12\x01\x38\x04\xac\x02\x0f\x00\x10\x00\x36\x04\xc1\x02\x37\x04\x48\x00\xfb\x01\x11\x00\x38\x04\x0b\x02\x0f\x00\x10\x00\x36\x04\xc2\x02\x37\x04\x48\x00\x36\x04\x11\x00\x37\x04\x48\x00\x38\x04\x80\x03\x0f\x00\x10\x00\x36\x04\xff\xff\x37\x04\x48\x00\xa2\x04\x11\x00\x38\x04\x0b\x02\x0f\x00\x10\x00\x38\x04\xaa\x02\x0f\x00\x10\x00\x31\x00\x11\x00\xca\x00\xf6\x01\x38\x04\x11\x00\x0f\x00\x10\x00\x3f\x04\x40\x04\xe0\x00\xe1\x00\xe2\x00\x11\x00\xe3\x00\x0b\x02\x0b\x02\x3d\x03\xe5\x01\xe6\x01\x2a\x02\xf5\x01\x0c\x02\xa3\x04\xa4\x04\x0c\x02\xeb\x01\x0c\x02\xab\x02\x72\x02\xe4\x00\x86\x03\x8d\x02\x32\x00\x7c\x03\x73\x02\x7a\x03\xab\x01\xe5\x00\xe6\x00\x28\x03\xe1\x01\x83\x00\xe7\x00\x8e\x02\x8f\x02\x84\x00\xca\x00\xcb\x00\x08\x03\xba\xff\x85\x00\x0c\x02\x9b\x04\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xa6\x03\xe3\x00\x64\x00\xd5\x04\xc7\x01\x7a\x00\xfe\x02\x7b\x00\xa3\x02\x72\x00\x74\x02\x90\x02\x73\x00\x74\x00\x0c\x02\x9c\x04\x8b\x00\xe4\x00\xe8\x00\x99\x01\x41\x00\x57\x00\x33\x00\xcb\x04\xe4\x01\xe5\x00\xe6\x00\x03\x02\x04\x02\x09\x01\xe7\x00\xff\x02\x58\x00\x42\x00\x08\x01\xcb\x00\x0c\x02\xa4\x02\x09\x01\x0f\x00\x10\x00\x5c\x00\xf5\x03\xe5\x01\xe6\x01\xad\x04\x11\x00\x05\x01\x7c\x00\x7d\x00\x5f\x01\x22\x01\x73\x00\x0f\x01\x5f\x01\x60\x01\x73\x00\x0f\x01\x0c\x02\x0c\x02\x52\x02\x53\x02\x54\x02\xe8\x00\x65\x00\x66\x00\xe7\x03\x7c\x03\x38\x05\x08\x01\xe9\x00\x5a\x01\xba\xff\x09\x01\xc4\x02\xea\x00\xe3\x01\x33\x00\x8f\x00\xe5\x03\xeb\x00\xe7\x01\x92\x00\x4d\x00\x81\x00\x94\x00\x95\x00\x96\x00\x97\x00\x12\x01\xff\xff\x98\x00\x99\x00\x12\x01\x4e\x00\x44\x00\x45\x00\x34\x00\xc0\x02\x47\x00\x48\x00\x82\x04\xe5\x01\xe6\x01\x5e\x01\x55\x02\x56\x02\x0f\x00\x10\x00\x16\x01\x17\x01\x4b\x00\xe6\x03\x4d\x00\x11\x00\xe9\x00\x5d\x01\x29\x04\x28\x01\xff\xff\xea\x00\xb8\x03\x5e\x01\x8f\x00\x4e\x00\xeb\x00\x37\x01\x92\x00\x8c\x00\x04\x01\x94\x00\x95\x00\x96\x00\x97\x00\x9e\x00\x9f\x00\x98\x00\x99\x00\x5a\x01\x72\x01\x00\x02\x73\x01\x2a\x04\x50\x05\xa0\x00\x72\x00\xb9\x03\x05\x01\x73\x00\x74\x00\xca\x00\x51\x05\xef\x04\xfd\x01\x38\x01\x39\x01\x3a\x01\x83\x03\xe0\x00\xe1\x00\xe2\x00\x94\x01\xe3\x00\x57\x00\xe7\x01\x5e\x01\x4d\x00\x7c\x02\x1a\x01\x1b\x01\x05\x01\x5e\x01\xce\x00\xa1\x00\x58\x00\x0f\x00\xcf\x00\x4e\x00\xe4\x00\x9e\x00\x9f\x00\x90\xfd\x11\x00\x5c\x00\x7c\x00\x7d\x00\xe5\x00\xe6\x00\xa2\x00\xa0\x00\x72\x00\xe7\x00\x36\x00\x73\x00\x74\x00\xaf\x01\xcb\x00\x29\x01\xee\x04\x2a\x01\x3d\x00\x3e\x00\xbd\x03\x3f\x00\x40\x00\xbe\x03\x65\x00\x66\x00\x8a\x02\x4a\x00\x68\x00\x69\x00\xcb\x01\x48\x00\xd2\x03\x54\x02\x05\x01\xce\x00\xa1\x00\xfc\x01\x0f\x00\xcf\x00\xca\x00\xe7\x01\xe8\x00\x4d\x00\xcc\x01\x11\x00\x7e\x04\x7c\x00\x7d\x00\xae\x01\xfd\x01\xa2\x00\xbf\x03\xaa\x04\x4e\x00\x4e\x00\x18\x01\x19\x01\xd4\x01\x41\x00\x21\x02\x0e\x01\x4d\x00\x73\x00\x0f\x01\x10\x03\xfd\x01\x64\x04\x65\x04\xc8\x04\xc6\x04\x77\x01\x42\x00\x4e\x00\x7f\x04\x80\x04\x55\x02\x56\x02\x0f\x00\x10\x00\xff\xff\xe7\x00\xa9\x04\x11\x03\x12\x03\x11\x00\xcb\x00\x10\x01\x03\x02\x04\x02\xe1\x02\x11\x01\x66\x04\x67\x04\xe9\x00\xfd\x01\xc7\x04\x11\x00\x74\x01\xea\x00\x12\x01\x64\x00\x8f\x00\xf6\x02\xeb\x00\x67\x00\x92\x00\xf7\x02\x17\xfd\x94\x00\x95\x00\x96\x00\x97\x00\x1c\x01\x19\x01\x98\x00\x99\x00\xff\xff\x0e\x01\x05\x02\x73\x00\x0f\x01\xc5\x04\xc6\x04\x4a\x04\x72\x00\xb3\x03\x3c\x01\x73\x00\x74\x00\x11\x01\x81\x04\x06\x02\x07\x02\x44\x00\x2b\x01\x11\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x64\x00\x20\x01\x10\x01\x81\x04\x67\x00\x81\x00\x11\x01\xc7\x04\x4b\x00\x4c\x00\x4d\x00\xe2\x02\x11\x00\x3b\x01\x64\x00\x12\x01\x9e\x00\x9f\x00\x67\x00\xca\x00\xff\xff\x4e\x00\x7c\x00\x7d\x00\x97\x02\x68\x04\xa0\x00\x72\x00\x3f\x01\xea\x00\x73\x00\x74\x00\x8f\x00\x88\x01\x99\x02\x89\x01\x92\x00\x5d\x01\x14\x03\x94\x00\x95\x00\x96\x00\x97\x00\x5e\x01\x9a\x02\x9b\x02\x9c\x02\x2a\x05\xc6\x04\x8c\x00\x15\x02\x15\x03\x16\x03\x8f\x00\xce\x00\xa1\x00\x0d\x01\x0f\x00\xcf\x00\x1a\x04\xe7\x00\x0d\x02\x39\x02\x11\x01\x11\x00\xcb\x00\x7c\x00\x7d\x00\x11\x00\x11\x00\xa2\x00\x30\x03\x81\x00\x36\x00\xc7\x04\xa0\x02\x5d\x03\x5e\x03\xe3\x02\xc0\x01\x2a\x01\x3d\x00\x3e\x00\x83\x00\x3f\x00\x40\x00\xff\xff\x84\x00\x9e\x00\x9f\x00\x85\x03\xca\x00\x85\x00\x14\x03\x5f\x01\x6a\x03\x73\x00\x0f\x01\xa0\x00\x72\x00\x09\x02\x86\x03\x73\x00\x74\x00\x5d\x01\x5f\x01\x0e\x05\x73\x00\x0f\x01\x0b\x03\x5e\x01\x20\x02\x47\x02\x4d\x00\x0d\x03\x8b\x00\x8c\x00\x7b\x03\x2f\x02\x8e\x00\x8f\x00\x86\x00\x41\x00\x25\x01\x4e\x00\x88\x00\xce\x00\xa1\x00\x7c\x03\x0f\x00\xcf\x00\x02\x03\xe7\x00\x12\x01\x8a\x00\x42\x00\x11\x00\xcb\x00\x7c\x00\x7d\x00\x79\x03\x0a\x04\xa2\x00\x4d\x00\x12\x01\x97\x02\x98\x02\x96\x02\xd4\x04\xe6\x02\xea\x00\x7a\x03\x31\x02\x8f\x00\x4e\x00\x99\x02\x40\x01\x92\x00\x32\x02\xd5\x04\x94\x00\x95\x00\x96\x00\x97\x00\xca\x04\x9a\x02\x9b\x02\x9c\x02\x2e\x02\x41\x01\xd0\x02\x42\x01\x43\x01\xd1\x02\x2f\x02\xcb\x04\x22\x03\x7b\x01\xac\x04\x7c\x01\xa7\xfe\x7d\x01\x77\x00\xa7\xfe\x78\x00\x79\x00\x7a\x00\x53\x05\x7b\x00\xad\x04\x64\x00\x7e\x00\x7f\x00\x54\x05\x67\x00\xf9\x04\xb0\x01\x44\x00\x45\x00\xb1\x01\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x37\x05\x7c\x03\xa1\x02\x9e\x02\x9f\x02\x9f\x00\x41\x03\x42\x03\x4b\x00\x4c\x00\x4d\x00\x38\x05\x97\x02\x98\x02\xa0\x00\x72\x00\xca\x00\xea\x00\x73\x00\x74\x00\x8f\x00\x4e\x00\x99\x02\xf2\x02\x92\x00\x31\x03\x3a\x05\x94\x00\x95\x00\x96\x00\x97\x00\x11\x00\x9a\x02\x9b\x02\x9c\x02\x8a\x02\x48\x04\x4e\x00\x57\x04\x5e\x01\x6e\x04\x2d\x00\xce\x00\xa1\x00\x11\x00\x0f\x00\xcf\x00\x83\x00\x2e\x00\x4a\x02\x2f\x00\x84\x00\x11\x00\x2f\x02\x7c\x00\x7d\x00\x85\x00\xe7\x00\xa2\x00\xab\x01\x36\x00\xdf\x03\xcb\x00\xdf\x02\x6f\x04\x75\x04\x47\x00\x48\x00\x13\x05\x3e\x00\x05\x03\x3f\x00\x40\x00\x06\x03\x9d\x02\x9e\x02\x9f\x02\x9f\x00\x33\x02\x8b\x00\x49\x04\x08\x01\x2f\x02\x8e\x00\x4a\x04\x09\x01\xa0\x00\x72\x00\xca\x00\xde\x02\x73\x00\x74\x00\x0e\x00\x14\x05\x0f\x00\x10\x00\xdd\x02\x1c\x01\x19\x01\x83\x00\xdc\x02\x11\x00\x0e\x01\x84\x00\x73\x00\x0f\x01\xff\x00\x00\x01\x85\x00\x41\x00\xdb\x02\x01\x01\x6e\x04\xda\x02\xce\x00\xa1\x00\xd4\x02\x0f\x00\xcf\x00\xb0\x02\xbd\x01\x7f\x00\x42\x00\xbe\x01\x11\x00\xbe\x01\x7c\x00\x7d\x00\x10\x01\xe7\x00\xa2\x00\x8b\x00\x11\x01\x57\x00\xcb\x00\x8e\x00\x6f\x04\x70\x04\x11\x00\xd2\x02\xd6\x01\x12\x01\x97\x02\x71\x04\x58\x00\x3a\x03\x49\x01\xea\x00\x47\x00\x48\x00\x8f\x00\xc5\x02\x99\x02\x5c\x00\x92\x00\xdf\x01\xc4\x02\x94\x00\x95\x00\x96\x00\x97\x00\x5b\x02\x9a\x02\x9b\x02\x9c\x02\x8c\x02\x8d\x02\x6b\x03\x78\x01\x45\x00\xbf\x02\x5e\x01\x47\x00\x48\x00\x5d\x03\x5e\x03\x65\x00\x66\x00\xea\x03\x8f\x02\x68\x00\x69\x00\x0b\x05\x0c\x05\x44\x00\x45\x00\xb7\x02\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x41\x00\xcc\x02\xcd\x02\xce\x02\xc7\x01\x7a\x00\x49\x02\x7b\x00\x4b\x00\x4c\x00\x4d\x00\x90\x02\xbd\x02\x42\x00\x9e\x00\x9f\x00\x31\x01\x32\x01\x33\x01\x34\x01\xca\x00\x4e\x00\x97\x02\x71\x04\xa0\x00\x72\x00\x02\xfd\xea\x00\x73\x00\x74\x00\x8f\x00\x82\x01\x99\x02\x83\x01\x92\x00\x0b\x05\x32\x05\x94\x00\x95\x00\x96\x00\x97\x00\x48\x02\x9a\x02\x9b\x02\x9c\x02\x5d\x03\x5e\x03\x64\x04\x65\x04\xb6\x02\xb9\x01\x10\x00\xce\x00\xa1\x00\xb4\x02\x0f\x00\xcf\x00\x11\x00\xb3\x02\xba\x01\x7d\x00\xe7\x00\x11\x00\xb2\x02\x7c\x00\x7d\x00\xcb\x00\xd9\x01\xa2\x00\x89\x02\x81\x00\x75\x01\x04\x05\x67\x02\x4c\x04\x44\x00\x45\x00\x47\x00\x48\x00\x47\x00\x48\x00\x83\x00\x4e\x03\x4f\x03\x50\x03\x84\x00\x9e\x00\x9f\x00\x78\x02\x51\x02\x85\x00\x4b\x00\x72\x01\x4d\x00\x73\x01\x88\x02\xa0\x00\x72\x00\xfb\x01\xf9\x01\x73\x00\x74\x00\x83\x02\x6c\x02\x4e\x00\x6d\x02\x00\x05\xfe\x04\x07\xfe\x46\x01\x07\xfe\x70\x02\x07\xfe\x8b\x00\x8c\x00\x75\x02\x66\x02\x8e\x00\x8f\x00\xf8\x01\xf9\x01\x07\xfe\xb7\x02\x10\x00\xce\x00\xa1\x00\x41\x00\x0f\x00\xcf\x00\x11\x00\x81\x02\xba\x01\x7d\x00\x12\x04\x11\x00\x13\x04\x7c\x00\x7d\x00\x6a\x02\x42\x00\xa2\x00\xca\x00\x25\x02\x7a\x00\x71\x02\x7b\x00\x97\x02\x68\x04\x09\x04\xb0\x02\x0a\x04\xea\x00\x69\x02\xbe\x01\x8f\x00\x72\x01\x99\x02\x73\x01\x92\x00\x6f\x01\xa5\x01\x94\x00\x95\x00\x96\x00\x97\x00\x6e\x04\x9a\x02\x9b\x02\x9c\x02\x36\x00\xcb\x03\x86\x00\xcc\x03\x4c\x04\xe3\x02\x88\x00\x2a\x01\x3d\x00\x3e\x00\x68\x02\x3f\x00\x40\x00\xe7\x00\x68\x01\x8a\x00\x0f\x00\x10\x00\xcb\x00\x8d\x00\x0c\x05\x6e\x03\x65\x01\x11\x00\x66\x01\xbc\x01\x94\x01\x7a\x00\x0e\x01\x7b\x00\x73\x00\x0f\x01\x44\x00\x45\x00\x6f\x01\x70\x01\x47\x00\x48\x00\x1e\x02\x6e\x01\x6a\x01\x9e\x00\x9f\x00\x67\x02\xca\x00\x42\x03\x43\x03\x44\x03\x4b\x00\x41\x00\x4d\x00\xa0\x00\x72\x00\x66\x02\x10\x01\x73\x00\x74\x00\xac\x02\x11\x01\x0f\x00\x10\x00\x4e\x00\x42\x00\xa7\x04\x11\x00\xa8\x04\x11\x00\x12\x01\xab\x01\xbc\x01\x94\x01\x7a\x00\x78\x04\x7b\x00\x79\x04\x41\x00\xbd\x01\x7f\x00\x5e\x02\xce\x00\xa1\x00\xbe\x01\x0f\x00\xcf\x00\xa7\x02\xe7\x00\x0f\x00\x10\x00\x42\x00\x11\x00\xcb\x00\x7c\x00\x7d\x00\x11\x00\x5b\x04\xa2\x00\x5c\x04\x5b\x02\x97\x02\x71\x04\xe0\x04\x35\x02\x1c\x02\xea\x00\x25\x02\x7a\x00\x8f\x00\x7b\x00\x99\x02\x4c\x02\x92\x00\x18\x02\x4b\x02\x94\x00\x95\x00\x96\x00\x97\x00\x39\x02\x9a\x02\x9b\x02\x9c\x02\xfe\x03\xff\x03\x00\x04\x44\x00\x45\x00\x39\x02\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x11\x00\x49\x02\xba\x01\x7d\x00\xf9\x03\xfa\x03\xfb\x03\x41\x00\x4b\x00\x4c\x00\x4d\x00\xea\x02\xeb\x02\xec\x02\xed\x02\xee\x02\x41\x00\x48\x02\x44\x00\x45\x00\x42\x00\x4e\x00\x47\x00\x48\x00\xdb\x03\xdc\x03\xdd\x03\x46\x02\xa9\x01\x42\x00\x9e\x00\x9f\x00\x38\x02\xca\x00\x4b\x00\x46\x04\x4d\x00\x47\x04\x97\x02\x98\x02\xa0\x00\x72\x00\x34\x02\xea\x00\x73\x00\x74\x00\x8f\x00\x4e\x00\x99\x02\xdb\x04\x92\x00\xdc\x04\x2d\x02\x94\x00\x95\x00\x96\x00\x97\x00\x28\x02\x9a\x02\x9b\x02\x9c\x02\x27\x02\xbc\x01\x94\x01\x7a\x00\xeb\x01\x7b\x00\x1c\x02\xce\x00\xa1\x00\x09\x02\x0f\x00\xcf\x00\xfd\x00\xe7\x00\xec\x01\xed\x01\xee\x01\x11\x00\xcb\x00\x7c\x00\x7d\x00\x44\x00\x45\x00\xa2\x00\x19\x03\x47\x00\x48\x00\x46\x04\xdf\x04\x47\x04\x44\x00\x45\x00\x6c\x01\x6a\x01\x47\x00\x48\x00\xf7\x02\x4b\x00\xf8\x02\x4d\x00\xfb\x01\x9e\x00\x9f\x00\x81\x00\xca\x00\x5e\x02\x4b\x00\xa9\x01\x4d\x00\xc0\x03\x4e\x00\xa0\x00\x72\x00\x41\x00\x83\x00\x73\x00\x74\x00\x81\x00\x84\x00\x4e\x00\x88\x04\xff\x03\x00\x04\x85\x00\x69\x01\x6a\x01\x42\x00\xba\x03\x83\x00\x79\x04\xff\x03\x00\x04\x84\x00\x34\x01\x35\x01\x5d\x01\xb7\x03\x85\x00\xae\x03\xce\x00\xa1\x00\x5e\x01\x0f\x00\xcf\x00\xad\x03\xe7\x00\x8b\x00\x8c\x00\xe4\xfc\x11\x00\xcb\x00\x7c\x00\x7d\x00\x1d\x01\x1e\x01\xa2\x00\x46\x01\x01\xfd\x97\x02\x98\x02\x8b\x00\x8c\x00\xeb\xfc\xea\x00\x8e\x00\x8f\x00\x8f\x00\xec\xfc\x99\x02\x00\xfd\x92\x00\x66\x03\x67\x03\x94\x00\x95\x00\x96\x00\x97\x00\xe5\xfc\x9a\x02\x9b\x02\x9c\x02\xca\x00\x8a\x02\x4a\x00\x82\x02\xbc\x04\xff\x03\x00\x04\x44\x00\x45\x00\x37\x02\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x5e\x05\xff\x03\x00\x04\xe6\xfc\x81\x00\x63\x05\xff\x03\x00\x04\x4b\x00\x4c\x00\x4d\x00\x92\x02\x6f\x01\x04\x04\xac\x03\x83\x00\xee\x03\xef\x03\xab\x03\x84\x00\xaa\x03\x4e\x00\xa4\x04\xa0\x04\x85\x00\xa5\x03\x9e\x00\x9f\x00\x9f\x04\xa0\x04\xa9\x03\xcb\x00\x6c\x04\x50\x03\x97\x02\xed\x03\xa0\x00\x72\x00\xa8\x03\xea\x00\x73\x00\x74\x00\x8f\x00\x93\x02\x99\x02\xa4\x03\x92\x00\x8b\x00\x8c\x00\x94\x00\x95\x00\x96\x00\x97\x00\x12\xfd\x9a\x02\x9b\x02\x9c\x02\xa3\x03\x81\x00\x45\x01\xa8\xfe\xbd\x04\xfb\x03\xa8\xfe\xce\x00\xa1\x00\x97\x03\x0f\x00\xcf\x00\x83\x00\x3e\x05\x3f\x05\x5e\x01\x84\x00\x11\x00\xbc\x02\x7c\x00\x7d\x00\x85\x00\x82\x03\xa2\x00\x30\x02\x81\x03\x76\x03\x78\x03\x77\x03\x74\x03\xfd\x04\xfe\x04\x73\x03\x75\x03\x72\x03\x71\x03\x70\x03\x6d\x03\x5a\x01\x6a\x03\x46\x01\x9e\x00\x9f\x00\x16\xfd\x8b\x00\x8c\x00\x69\x03\x5b\x02\x8e\x00\x8f\x00\x53\x03\xa0\x00\x72\x00\x21\x03\x19\x01\x73\x00\x74\x00\x4e\x03\x0e\x01\xcc\x00\x73\x00\x0f\x01\x8f\x00\x4b\x03\xcd\x00\x49\x03\x92\x00\x4c\x03\x3f\x03\x94\x00\x95\x00\x96\x00\x97\x00\x20\x01\xcb\x04\x98\x00\x99\x00\x25\x03\x1e\x03\xce\x00\xa1\x00\x1d\x03\x0f\x00\xcf\x00\x10\x01\x8a\x00\x1c\x03\xfd\x00\x11\x01\x11\x00\x19\x03\x7c\x00\x7d\x00\x36\x00\x11\x00\xa2\x00\x3f\x04\x12\x01\xe3\x02\x31\x04\x2a\x01\x3d\x00\x3e\x00\x30\x04\x3f\x00\x40\x00\x2e\x04\x2d\x04\x08\x05\xea\x03\x22\x04\x28\x04\x20\x04\x1f\x04\x1c\x04\x1e\x04\x0c\xfd\x0b\xfd\x9e\x00\x9f\x00\x0d\xfd\x1a\x04\x18\x04\x0d\x04\x07\x04\x59\x03\x04\x04\x02\x04\xa0\x00\x72\x00\xfd\x03\xf7\x03\x73\x00\x74\x00\xf5\x03\xbc\x02\x36\x00\xf3\x03\x03\x05\x6a\x00\x36\x02\xcc\x04\x41\x00\x2a\x01\x3d\x00\x3e\x00\x0d\x01\x3f\x00\x40\x00\xea\x03\x0e\x01\xda\x03\x73\x00\x0f\x01\xc9\x03\x42\x00\xce\x00\xa1\x00\xd1\x03\x0f\x00\xcf\x00\xe0\x03\xd0\x03\xc8\x03\x5b\x02\xc7\x03\x11\x00\xc6\x03\x7c\x00\x7d\x00\x36\x00\x9f\x04\xa2\x00\x9e\x04\x9d\x04\xe3\x02\x10\x01\x2a\x01\x3d\x00\x3e\x00\x11\x01\x3f\x00\x40\x00\x66\x02\x59\x03\x41\x00\x11\x00\xab\x01\x96\x04\x12\x01\x43\x04\x61\x01\x62\x01\x63\x01\x64\x01\x65\x01\x7d\x03\x66\x01\x42\x00\x8f\x04\x36\x00\x0e\x01\x8e\x04\x73\x00\x0f\x01\xe3\x02\x8d\x04\x2a\x01\x3d\x00\x3e\x00\x8c\x04\x3f\x00\x40\x00\x04\x04\x02\x04\x88\x04\x02\x04\x44\x00\x45\x00\x41\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x64\x04\x5f\x04\x10\x01\x56\x04\x5a\x04\x55\x04\x11\x01\x42\x00\x4b\x00\x4c\x00\x4d\x00\x50\x04\x11\x00\x52\x04\x51\x04\x12\x01\x1c\x03\xe3\x04\xdd\x04\xea\x03\xee\x04\x4e\x00\x45\x05\x43\x04\x41\x00\xde\x04\xc1\x01\xed\x04\xc2\x01\xec\x04\xd7\x04\xc3\x01\xd2\x04\xc0\x04\x3a\x01\x44\x00\x45\x00\x42\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\xbf\x04\x8d\xfe\xfd\x03\x02\x04\x5b\x02\xb6\x04\x0d\x01\x1e\x05\x4b\x00\x4c\x00\x4d\x00\x1c\x05\xc6\x01\x17\x05\x10\x05\x16\x05\x11\x01\x13\x05\x12\x05\x3c\x01\x49\x01\x4e\x00\x11\x00\x0e\x05\x7c\x00\x7d\x00\x44\x00\x45\x00\xf6\x04\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\xf4\x04\xf1\x04\xf3\x04\x3c\x05\x4e\x03\x3d\x05\x2c\x05\x36\x00\x4b\x00\x4c\x00\x4d\x00\x36\x05\xe3\x02\x19\x03\x2a\x01\x3d\x00\x3e\x00\x52\x05\x3f\x00\x40\x00\x4d\x05\x4e\x00\x44\x00\x45\x00\x19\x03\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4a\x05\x45\x05\xc6\x02\x62\x05\x04\x04\x02\x04\x5d\x05\x36\x00\x4b\x00\x4c\x00\x4d\x00\x3d\x01\x3e\x01\x67\x05\x3c\x00\x3d\x00\x3e\x00\x68\x05\x3f\x00\x40\x00\x02\x04\x4e\x00\x63\x05\xfd\x00\x6a\x05\xfb\x00\x41\x00\xff\x01\xa3\x01\xaf\x02\x63\x01\x64\x01\x65\x01\x5e\x03\x66\x01\xf0\x01\xfe\x01\x75\x01\x0e\x01\x42\x00\x73\x00\x0f\x01\x89\x01\x86\x01\x80\x01\x46\x01\x2f\x01\xbb\x01\x25\x01\x0f\x03\x0b\x01\x0a\x01\x06\x01\x0e\x03\x36\x00\x0d\x03\x41\x00\x0b\x03\x3d\x01\x3e\x01\xee\x02\x3c\x00\x3d\x00\x3e\x00\x10\x01\x3f\x00\x40\x00\xe8\x02\x11\x01\x42\x00\x02\x03\xf0\x01\x25\x02\x7a\x00\x11\x00\x7b\x00\xfc\x02\x12\x01\xc5\x02\xb0\x02\xd2\x02\xb4\x02\xb9\x02\xbe\x01\x36\x00\xa8\x02\xd0\x01\x7c\x02\x5f\x03\x60\x03\x64\x02\x3c\x00\x3d\x00\x3e\x00\x6a\x02\x3f\x00\x40\x00\x59\x02\x04\x02\x01\x02\xc4\x03\x44\x00\x45\x00\x41\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x14\x03\x34\x05\xc3\x03\xc1\x03\xc2\x03\x09\x02\xc0\x03\x42\x00\x4b\x00\x4c\x00\x4d\x00\xbb\x03\x62\x02\x77\x01\x78\x01\x45\x00\x86\x03\xa6\x03\x47\x00\x48\x00\x82\x03\x4e\x00\x44\x00\x45\x00\x41\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x79\x01\x51\x03\x4d\x00\x36\x00\x65\x03\x7e\x03\x4c\x03\x42\x00\x4b\x00\x4c\x00\x4d\x00\xf7\x01\x3e\x00\x4e\x00\x3f\x00\x40\x00\x7d\x03\x49\x03\x47\x03\x3f\x03\x30\x03\x4e\x00\x36\x00\x28\x03\x26\x03\x25\x03\x5f\x03\x60\x03\x23\x03\x3c\x00\x3d\x00\x3e\x00\x1a\x03\x3f\x00\x40\x00\x1e\x03\x19\x03\x17\x03\x41\x04\x44\x00\x45\x00\x2e\x04\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x20\x04\x16\x04\x13\x04\x07\x04\x10\x04\x41\x00\x05\x04\xe8\x03\x4b\x00\x4c\x00\x4d\x00\x02\x04\xc9\x03\xe0\x03\xa8\x04\xa5\x04\x99\x04\x98\x04\x42\x00\x62\x02\x89\x04\x4e\x00\x44\x00\x45\x00\x41\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x8a\x01\x72\x00\x6d\x04\x52\x04\x73\x00\x74\x00\x81\x04\x42\x00\x4b\x00\x4c\x00\x4d\x00\x62\x04\x53\x04\x4e\x04\x44\x04\x36\x00\x37\x00\x3a\x02\x39\x00\x3a\x00\x3b\x00\x4e\x00\x3c\x00\x3d\x00\x3e\x00\x43\x04\x3f\x00\x40\x00\xe4\x04\x8b\x01\x4d\x04\x0f\x00\x10\x00\xd8\x04\xd9\x04\xd7\x04\xd5\x04\xd2\x04\x11\x00\xd0\x04\x7c\x00\x7d\x00\xc3\x04\xb3\x04\xb2\x04\xb1\x04\x1e\x05\x1c\x05\xb0\x04\x19\x05\x44\x00\x45\x00\x10\x05\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x18\x05\x02\x05\x09\x05\xf4\x04\x30\x05\x26\x05\x41\x00\xf9\x04\x4b\x00\x4c\x00\x4d\x00\x44\x00\x45\x00\xf1\x04\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x42\x00\x3d\x05\x4e\x00\x39\x05\x38\x05\x33\x05\x25\x05\x4b\x05\x4b\x00\x4c\x00\x4d\x00\x36\x00\x37\x00\xcd\x01\x39\x00\x3a\x00\x3b\x00\x5b\x05\x3c\x00\x3d\x00\x3e\x00\x4e\x00\x3f\x00\x40\x00\x57\x05\x55\x05\x5f\x05\xce\x01\xcf\x01\x64\x05\x65\x05\x68\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x03\x63\x01\x64\x01\x65\x01\x00\x00\x66\x01\x43\x00\x00\x00\x00\x00\x0e\x01\x00\x00\x73\x00\x0f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x8f\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\xc0\x01\x10\x01\x42\x00\x98\x00\x99\x00\x11\x01\x00\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x11\x00\x00\x00\x00\x00\x12\x01\x00\x00\x00\x00\x00\x00\x25\x02\x7a\x00\x4e\x00\x7b\x00\x00\x00\x00\x00\xbd\x01\x7f\x00\x00\x00\x00\x00\x00\x00\xbe\x01\x36\x00\x37\x00\xd2\x01\x39\x00\x3a\x00\x3b\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x43\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x00\x00\x7e\x01\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x42\x00\x4e\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x00\x00\xd0\x01\x36\x00\x37\x00\xd2\x01\x39\x00\x3a\x00\x3b\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x04\xd7\x02\x00\x00\x00\x00\x36\x00\x37\x00\x43\x00\xd8\x02\x3a\x00\x3b\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\xc1\x04\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\xd3\x01\x4a\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x04\xd7\x02\x00\x00\xd4\x01\x36\x00\x37\x00\x42\x00\xd8\x02\x3a\x00\x3b\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x81\x00\x3f\x00\x40\x00\x00\x00\x29\x05\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x84\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\xd3\x01\x4a\x00\x5d\x01\x00\x00\x00\x00\x43\x00\x00\x00\x00\x00\x5e\x01\x41\x00\x48\x05\x4c\x00\x4d\x00\x8b\x00\x8c\x00\x00\x00\x00\x00\x8e\x00\x8f\x00\x00\x00\x00\x00\x00\x00\x42\x00\x4e\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\xd4\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\xd6\x02\xd7\x02\x00\x00\x00\x00\x36\x00\x37\x00\x00\x00\xd8\x02\x3a\x00\x3b\x00\x4e\x00\x3c\x00\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x3b\x03\xd7\x02\x00\x00\x00\x00\x36\x00\x37\x00\x42\x00\xd8\x02\x3a\x00\x3b\x00\x4e\x00\x3c\x00\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\xc1\x01\x00\x00\xc2\x01\x00\x00\x00\x00\xc3\x01\x00\x00\x00\x00\xc4\x01\x00\x00\x00\x00\xa5\x02\x00\x00\x00\x00\x36\x00\x37\x00\x00\x00\x94\x02\x3a\x00\x3b\x00\xc5\x01\x3c\x00\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\xde\x02\x00\x00\xc6\x01\x00\x00\x00\x00\x43\x00\x11\x01\x00\x00\x00\x00\x41\x00\xc7\x01\x7a\x00\x11\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x81\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x83\x00\x00\x00\x41\x00\x00\x00\x84\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x85\x00\xa5\x02\x00\x00\x00\x00\x36\x00\x37\x00\x42\x00\x94\x02\x3a\x00\x3b\x00\x4e\x00\x3c\x00\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\xa6\x02\x00\x00\x46\x01\x00\x00\x00\x00\x43\x00\x8b\x00\x8c\x00\x00\x00\x00\x00\x8e\x00\x8f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x43\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x44\x00\x45\x00\x4e\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\xa5\x02\x00\x00\x00\x00\x36\x00\x37\x00\x00\x00\x94\x02\x3a\x00\x3b\x00\x4e\x00\x3c\x00\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x0f\x04\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\xf0\x03\x00\x00\xf3\x03\x36\x00\x37\x00\x42\x00\x94\x02\x3a\x00\x3b\x00\x4e\x00\x3c\x00\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0\x03\x00\x00\xf1\x03\x36\x00\x37\x00\x00\x00\x94\x02\x3a\x00\x3b\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\xf0\x03\x00\x00\xb9\x04\x36\x00\x37\x00\x42\x00\x94\x02\x3a\x00\x3b\x00\x4e\x00\x3c\x00\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x81\x00\x45\x01\x00\x00\x00\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x84\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x43\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x46\x01\x4b\x00\x4c\x00\x4d\x00\x8b\x00\x8c\x00\x00\x00\x00\x00\x8e\x00\x8f\x00\x42\x00\x00\x00\x44\x00\x45\x00\x4e\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x93\x02\x00\x00\x00\x00\x36\x00\x37\x00\x00\x00\xc7\x02\x3a\x00\x3b\x00\x4e\x00\x3c\x00\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x93\x02\x00\x00\x00\x00\x36\x00\x37\x00\x42\x00\x94\x02\x3a\x00\x3b\x00\x4e\x00\x3c\x00\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2f\x03\x00\x00\x00\x00\x36\x00\x37\x00\x00\x00\x94\x02\x3a\x00\x3b\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\xeb\x03\x00\x00\x00\x00\x36\x00\x37\x00\x42\x00\x94\x02\x3a\x00\x3b\x00\x4e\x00\x3c\x00\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x81\x00\x00\x00\x57\x04\x00\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x84\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x43\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x46\x01\x4b\x00\x4c\x00\x4d\x00\x8b\x00\x8c\x00\x00\x00\x00\x00\x8e\x00\x8f\x00\x42\x00\x00\x00\x44\x00\x45\x00\x4e\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x5d\x04\x00\x00\x00\x00\x36\x00\x37\x00\x00\x00\x94\x02\x3a\x00\x3b\x00\x4e\x00\x3c\x00\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\xde\x04\x00\x00\x00\x00\x36\x00\x37\x00\x42\x00\x94\x02\x3a\x00\x3b\x00\x4e\x00\x3c\x00\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x32\x05\x00\x00\x00\x00\x36\x00\x37\x00\x00\x00\x94\x02\x3a\x00\x3b\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x4a\x05\x00\x00\x00\x00\x36\x00\x37\x00\x42\x00\x94\x02\x3a\x00\x3b\x00\x4e\x00\x3c\x00\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x81\x00\x07\x05\x00\x00\x00\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x84\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x43\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x46\x01\x4b\x00\x4c\x00\x4d\x00\x8b\x00\x8c\x00\x00\x00\x00\x00\x8e\x00\x8f\x00\x42\x00\x00\x00\x44\x00\x45\x00\x4e\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x36\x00\x37\x00\x42\x02\x39\x00\x3a\x00\x3b\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x4e\x00\x3f\x00\x40\x00\x00\x00\x00\x00\xd5\x02\x44\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x00\x00\x42\x00\x00\x00\x36\x00\x37\x00\x42\x02\x39\x00\x3a\x00\x3b\x00\x4e\x00\x3c\x00\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x43\x02\x44\x02\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x42\x02\x39\x00\x3a\x00\x3b\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\xb2\x03\x00\x00\x00\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x01\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x42\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x41\x01\x41\x00\x42\x01\x43\x01\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x77\x00\x42\x00\x78\x00\x79\x00\x7a\x00\x00\x00\x7b\x00\x4e\x00\x00\x00\x7e\x00\x7f\x00\x00\x00\x00\x00\x36\x00\x37\x00\x42\x02\x39\x00\x3a\x00\x3b\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x43\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\xb1\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x43\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x41\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\xaf\x03\x39\x00\x3a\x00\x3b\x00\x4e\x00\x3c\x00\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x00\x00\x36\x00\x37\x00\x42\x02\x39\x00\x3a\x00\x3b\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x41\x00\xae\x03\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4e\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x36\x00\x37\x00\x42\x02\x39\x00\x3a\x00\x3b\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x42\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\xd1\x03\x00\x00\x00\x00\x43\x00\x00\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x43\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4e\x00\x00\x00\x00\x00\x41\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x18\x04\x39\x00\x3a\x00\x3b\x00\x4e\x00\x3c\x00\x3d\x00\x3e\x00\x43\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x43\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x41\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\xd7\x01\x39\x00\x3a\x00\x3b\x00\x4e\x00\x3c\x00\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x36\x00\x37\x00\x83\x01\x39\x00\x3a\x00\x3b\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2d\x05\x4c\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4e\x00\x00\x00\x41\x00\x00\x00\x00\x00\x36\x00\x37\x00\x40\x01\x15\x02\x3a\x00\x3b\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x42\x00\x3f\x00\x40\x00\x00\x00\x00\x00\xc2\x02\x00\x00\x42\x01\x43\x01\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x02\x00\x00\x00\x00\x77\x00\x00\x00\x78\x00\x79\x00\x7a\x00\x00\x00\x7b\x00\x40\x01\x00\x00\x7e\x00\x7f\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x41\x01\x41\x00\x42\x01\x43\x01\x00\x00\x43\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x77\x00\x42\x00\x78\x00\x79\x00\x7a\x00\x00\x00\x7b\x00\x4e\x00\x00\x00\x7e\x00\x7f\x00\x44\x00\x45\x00\x36\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x1d\x02\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x3c\x03\x39\x00\x3a\x00\x3b\x00\x4e\x00\x3c\x00\x3d\x00\x3e\x00\x43\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x41\x00\x00\x00\x00\x00\x36\x00\x37\x00\x18\x04\x39\x00\x3a\x00\x3b\x00\x4e\x00\x3c\x00\x3d\x00\x3e\x00\x42\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x00\x00\x15\x02\x3a\x00\x3b\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x04\x00\x00\x00\x00\x41\x00\x00\x00\x44\x00\x45\x00\x43\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x41\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4e\x00\x00\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x00\x00\x15\x02\x3a\x00\x3b\x00\x4e\x00\x3c\x00\x3d\x00\x3e\x00\x43\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0e\x04\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x43\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x41\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x00\x00\x15\x02\x3a\x00\x3b\x00\x4e\x00\x3c\x00\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0d\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x00\x00\x36\x00\x37\x00\x00\x00\x15\x02\x3a\x00\x3b\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x41\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\xfd\x03\x00\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4e\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x36\x00\x37\x00\x00\x00\x15\x02\x3a\x00\x3b\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x42\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xce\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x43\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x00\x00\x15\x02\x3a\x00\x3b\x00\x4e\x00\x3c\x00\x3d\x00\x3e\x00\x43\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcd\x03\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x41\x00\x00\x00\x00\x00\x36\x00\x37\x00\xfa\x04\x39\x00\x3a\x00\x3b\x00\x4e\x00\x3c\x00\x3d\x00\x3e\x00\x42\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x00\x00\x15\x02\x3a\x00\x3b\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2f\x05\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x00\x00\xf6\x01\x3a\x00\x3b\x00\x4e\x00\x3c\x00\x3d\x00\x3e\x00\x43\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x43\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x41\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x00\x00\x50\x02\x3a\x00\x3b\x00\x4e\x00\x3c\x00\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x43\x00\x1a\x02\x3a\x00\x3b\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x42\x00\x19\x02\x3a\x00\x3b\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x41\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x4e\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x36\x00\x37\x00\x00\x00\x17\x02\x3a\x00\x3b\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x4e\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x00\x00\xba\x03\x3a\x00\x3b\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x36\x00\x37\x00\x42\x00\xb4\x03\x3a\x00\x3b\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x4e\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x37\x00\x42\x00\xf6\x04\x3a\x00\x3b\x00\x00\x00\x3c\x00\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x43\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x44\x00\x45\x00\x4e\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x36\x00\x00\x00\x00\x00\x00\x00\x83\x04\x00\x00\x00\x00\x84\x04\x85\x04\x3e\x00\x4e\x00\x3f\x00\x40\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x86\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x44\x00\x45\x00\x4e\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x41\x00\x7d\x01\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x36\x00\x4b\x00\x4c\x00\x4d\x00\xba\x04\xbb\x04\x42\x00\x3c\x00\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe1\x02\x00\x00\x2a\x01\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\xa0\x00\x72\x00\x36\x00\x00\x00\x73\x00\x74\x00\x00\x00\xd4\x02\x00\x00\x2a\x01\x3d\x00\x3e\x00\x42\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x41\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x7e\x01\x00\x00\x0f\x00\x10\x00\x42\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x36\x00\x00\x00\x4e\x00\x00\x00\x00\x00\x1f\x02\x41\x00\x2a\x01\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x41\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x36\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x53\x03\x00\x00\x2a\x01\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x4e\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x8a\x04\x00\x00\x2a\x01\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x4e\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x42\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x5f\x04\x41\x00\x2a\x01\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x36\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07\x05\x00\x00\x2a\x01\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x36\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x05\x05\x41\x00\x2a\x01\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x4e\x00\x00\x00\x44\x00\x45\x00\x42\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x36\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x28\x05\x00\x00\x2a\x01\x3d\x00\x3e\x00\x00\x00\x3f\x00\x40\x00\x00\x00\x00\x00\x4e\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x42\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x41\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4e\x00\x00\x00\x44\x00\x45\x00\x00\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x4c\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\x00\x00\x00\x00\x4e\x00\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf3\xfc\xf3\xfc\x00\x00\x00\x00\xf3\xfc\xf3\xfc\xf3\xfc\x00\x00\xf3\xfc\xf3\xfc\x00\x00\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\x00\x00\xf3\xfc\xf3\xfc\xf3\xfc\x00\x00\x00\x00\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf3\xfc\xf3\xfc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\x00\x00\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\x00\x00\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\x00\x00\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xed\xfd\xed\xfd\xed\xfd\xed\xfd\x00\x00\x00\x00\x00\x00\xed\xfd\xed\xfd\xed\xfd\xed\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xed\xfd\xed\xfd\x00\x00\x00\x00\xed\xfd\xed\xfd\xed\xfd\x00\x00\xed\xfd\xed\xfd\x00\x00\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\x00\x00\xed\xfd\xed\xfd\xed\xfd\x00\x00\x00\x00\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xed\xfd\xed\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\x00\x00\xed\xfd\xed\xfd\xed\xfd\xed\xfd\x00\x00\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\x00\x00\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\x00\x00\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xdb\xfd\xdb\xfd\x13\x00\xdb\xfd\x00\x00\x00\x00\x00\x00\xdb\xfd\xdb\xfd\x14\x00\xdb\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdb\xfd\xdb\xfd\x00\x00\x00\x00\xdb\xfd\x15\x00\xdb\xfd\x00\x00\xdb\xfd\xdb\xfd\x00\x00\x17\x00\x18\x00\x19\x00\x52\x00\x53\x00\x54\x00\xdb\xfd\xdb\xfd\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xdb\xfd\x00\x00\x24\x00\xdb\xfd\xdb\xfd\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdb\xfd\xdb\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\x00\x00\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\x00\x00\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\x00\x00\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\x00\x00\xdb\xfd\x7b\x01\xdb\xfd\x7c\x01\xdb\xfd\x7d\x01\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\x63\x00\x64\x00\xdb\xfd\xdb\xfd\xdb\xfd\x67\x00\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\xdb\xfd\x8c\xfe\x50\x00\x13\x00\x8c\xfe\x00\x00\x00\x00\x00\x00\x8c\xfe\x8c\xfe\x14\x00\x8c\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\xfe\x8c\xfe\x00\x00\x00\x00\x8c\xfe\x15\x00\x8c\xfe\x00\x00\x8c\xfe\x8c\xfe\x00\x00\x17\x00\x18\x00\x19\x00\x52\x00\x53\x00\x54\x00\x8c\xfe\x8c\xfe\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x8c\xfe\x00\x00\x24\x00\x8c\xfe\x8c\xfe\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\xfe\x8c\xfe\x57\x00\x8c\xfe\x8c\xfe\x8c\xfe\x00\x00\x8c\xfe\x8c\xfe\x8c\xfe\x8c\xfe\x00\x00\x8c\xfe\x58\x00\x59\x00\x5a\x00\x8c\xfe\x5b\x00\x8c\xfe\x8c\xfe\x8c\xfe\x8c\xfe\x5c\x00\x00\x00\x00\x00\xf0\x01\x8c\xfe\x5d\x00\x8c\xfe\x00\x00\x8c\xfe\x5e\x00\x8c\xfe\x5f\x00\x8c\xfe\x60\x00\x8c\xfe\x8c\xfe\x8c\xfe\x8c\xfe\x8c\xfe\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x8c\xfe\x67\x00\x68\x00\x69\x00\x8c\xfe\x8c\xfe\x8c\xfe\x8c\xfe\x6b\x00\x6c\x00\x6d\x00\x8c\xfe\x8c\xfe\x8c\xfe\x8c\xfe\x8c\xfe\x8c\xfe\x8c\xfe\x8c\xfe\x8c\xfe\x8c\xfe\x8c\xfe\x8c\xfe\x8c\xfe\x8c\xfe\x6e\x00\x8c\xfe\x8c\xfe\x6f\x00\x70\x00\x8c\xfe\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x00\x00\x00\x00\x00\x00\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\xfd\x3d\xfd\x00\x00\x00\x00\x3d\xfd\x3d\xfd\x3d\xfd\x00\x00\x3d\xfd\x3d\xfd\x00\x00\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x00\x00\x3d\xfd\x3d\xfd\x3d\xfd\x00\x00\x00\x00\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\xfd\x3d\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x00\x00\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x00\x00\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x00\x00\x00\x00\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x00\x00\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x00\x00\x00\x00\x00\x00\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7e\xfe\x7e\xfe\x00\x00\x00\x00\x7e\xfe\x7e\xfe\x7e\xfe\x00\x00\x7e\xfe\x7e\xfe\x00\x00\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x00\x00\x7e\xfe\x7e\xfe\x7e\xfe\x00\x00\x00\x00\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7e\xfe\x7e\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x00\x00\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x00\x00\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x00\x00\x00\x00\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x00\x00\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x00\x00\x00\x00\x00\x00\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x92\xfe\x92\xfe\x00\x00\x00\x00\x92\xfe\x92\xfe\x92\xfe\x00\x00\x92\xfe\x92\xfe\x00\x00\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x00\x00\x92\xfe\x92\xfe\x92\xfe\x00\x00\x00\x00\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x00\x00\x92\xfe\x92\xfe\xf2\x01\xf3\x01\x00\x00\x93\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x00\x00\x00\x00\x92\xfe\xf4\x01\x00\x00\x92\xfe\x00\x00\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x00\x00\x00\x00\x00\x00\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x92\xfe\x92\xfe\x00\x00\x00\x00\x92\xfe\x92\xfe\x92\xfe\x00\x00\x92\xfe\x92\xfe\x00\x00\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x00\x00\x92\xfe\x92\xfe\x92\xfe\x00\x00\x00\x00\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x00\x00\x92\xfe\x92\xfe\xf2\x01\xf3\x01\x00\x00\x00\x00\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x00\x00\x00\x00\x92\xfe\xf4\x01\x00\x00\x92\xfe\x00\x00\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x92\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x10\xfe\x10\xfe\x10\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\xfe\x00\x00\x00\x00\x10\xfe\x10\xfe\x10\xfe\x00\x00\x10\xfe\x10\xfe\x00\x00\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x00\x00\x10\xfe\x10\xfe\x10\xfe\x00\x00\x00\x00\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\xfe\x10\xfe\x81\x00\xb5\x01\x10\xfe\x10\xfe\x00\x00\x10\xfe\x10\xfe\x10\xfe\x00\x00\x00\x00\x00\x00\x83\x00\x10\xfe\x10\xfe\x10\xfe\x84\x00\xb6\x01\xb7\x01\xb8\x01\xb9\x01\x85\x00\x00\x00\x00\x00\x10\xfe\x00\x00\x00\x00\x10\xfe\x00\x00\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x46\x01\x10\xfe\x10\xfe\x10\xfe\x8b\x00\x8c\x00\x10\xfe\x10\xfe\x8e\x00\x8f\x00\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x10\xfe\x09\xfe\xa5\x00\x13\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x09\xfe\x14\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x00\x00\x00\x00\x00\x09\xfe\x15\x00\x09\xfe\x00\x00\x09\xfe\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x09\xfe\x09\xfe\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x09\xfe\x09\xfe\x09\xfe\x09\xfe\x09\xfe\xad\x00\x00\x00\x09\xfe\x09\xfe\x09\xfe\x00\x00\x00\x00\x00\x00\x09\xfe\xaf\x00\xb0\x00\xb1\x00\x09\xfe\x09\xfe\x09\xfe\x09\xfe\x09\xfe\x09\xfe\x00\x00\x00\x00\xb3\x01\x00\x00\x00\x00\x09\xfe\x00\x00\x09\xfe\xb2\x00\x09\xfe\xb3\x00\x09\xfe\xb4\x00\x09\xfe\xb5\x00\x09\xfe\x09\xfe\x09\xfe\x09\xfe\xb6\x00\x2c\x00\x8a\x00\x09\xfe\x09\xfe\x2d\x00\x8d\x00\x09\xfe\x09\xfe\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x09\xfe\xc8\x00\x09\xfe\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\x09\xfe\x0a\xfe\xa5\x00\x13\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\xfe\x14\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x00\x00\x00\x00\x00\x0a\xfe\x15\x00\x0a\xfe\x00\x00\x0a\xfe\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x0a\xfe\x0a\xfe\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\xfe\x0a\xfe\x0a\xfe\x0a\xfe\x0a\xfe\xad\x00\x00\x00\x0a\xfe\x0a\xfe\x0a\xfe\x00\x00\x00\x00\x00\x00\x0a\xfe\xaf\x00\xb0\x00\xb1\x00\x0a\xfe\x0a\xfe\x0a\xfe\x0a\xfe\x0a\xfe\x0a\xfe\x00\x00\x00\x00\xb3\x01\x00\x00\x00\x00\x0a\xfe\x00\x00\x0a\xfe\xb2\x00\x0a\xfe\xb3\x00\x0a\xfe\xb4\x00\x0a\xfe\xb5\x00\x0a\xfe\x0a\xfe\x0a\xfe\x0a\xfe\xb6\x00\x2c\x00\x8a\x00\x0a\xfe\x0a\xfe\x2d\x00\x8d\x00\x0a\xfe\x0a\xfe\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x0a\xfe\xc8\x00\x0a\xfe\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\x0a\xfe\x0b\x02\xa5\x00\x13\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x02\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\x9e\x03\x00\x00\x00\x00\xb6\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x2d\x00\x8d\x00\x00\x00\x00\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\x7e\xfe\x7e\xfe\x7e\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7e\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7e\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x00\x00\x00\x00\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x00\x00\x00\x00\x7e\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7e\xfe\x7e\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7e\xfe\x7e\xfe\x00\x00\x00\x00\x00\x00\x59\xfe\x00\x00\x7e\xfe\x7e\xfe\x00\x00\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x00\x00\x7e\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x7e\xfe\x00\x00\x00\x00\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x00\x00\x7e\xfe\x7e\xfe\x00\x00\x7e\xfe\x00\x00\x7e\xfe\x00\x00\x00\x00\x00\x00\x7e\xfe\x00\x00\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x00\x00\x7e\xfe\x7e\xfe\x7e\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x7e\xfe\x7e\xfe\x7e\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x13\x00\xa6\x00\xed\x00\xee\x00\xef\x00\xf0\x00\x7e\xfe\x14\x00\xa7\x00\x7e\xfe\x7e\xfe\xd1\x00\xd2\x00\xd3\x00\xf1\x00\xd4\x00\x00\x00\xf2\x00\x00\x00\x15\x00\x00\x00\xf3\x00\x00\x00\x16\x00\xf4\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\xf5\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xd6\x00\xd7\x00\xd8\x00\x00\x00\xf6\x00\xd9\x00\xf7\x00\xf8\x00\x00\x00\x00\x00\xf9\x00\xda\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xdc\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x2d\x00\x8d\x00\x00\x00\x00\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\xf3\xfc\xf3\xfc\xf3\xfc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf3\xfc\xf3\xfc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf3\xfc\x00\x00\x00\x00\x00\x00\xf3\xfc\x00\x00\x00\x00\x00\x00\xf3\xfc\x00\x00\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\x00\x00\xf3\xfc\x94\x04\x95\x04\x00\x00\x00\x00\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf3\xfc\xf3\xfc\x00\x00\xf3\xfc\x00\x00\xf3\xfc\x00\x00\x00\x00\x00\x00\xf3\xfc\x00\x00\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\x00\x00\xf3\xfc\xf3\xfc\x00\x00\xf3\xfc\x00\x00\x00\x00\x00\x00\xf3\xfc\xf3\xfc\xf3\xfc\x00\x00\xf3\xfc\x00\x00\xf3\xfc\x00\x00\x00\x00\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\x00\x00\xf3\xfc\x00\x00\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xf3\xfc\xa5\x00\x13\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x00\x00\x00\x00\x00\xad\x00\x00\x00\x5a\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x01\xaf\x00\xb0\x00\xb1\x00\x84\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x00\x5c\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x5d\x01\xb4\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x5e\x01\x5f\x01\xb6\x00\x2c\x00\x8a\x00\x8b\x00\x8c\x00\x2d\x00\x8d\x00\x8e\x00\x8f\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\xe1\xfd\xe1\xfd\xe1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe1\xfd\xe1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe1\xfd\x00\x00\x00\x00\x00\x00\xe1\xfd\x00\x00\x00\x00\x00\x00\xe1\xfd\x00\x00\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\x00\x00\xe1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\x00\x00\xe1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xe1\xfd\x00\x00\xe1\xfd\xe1\xfd\x00\x00\xe1\xfd\x00\x00\x00\x00\x00\x00\xe1\xfd\x00\x00\xe1\xfd\x00\x00\xe1\xfd\x00\x00\xe1\xfd\x00\x00\x00\x00\x00\x00\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\x00\x00\xe1\xfd\x00\x00\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\xe1\xfd\xe0\xfd\xe0\xfd\xe0\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xfd\xe0\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xfd\x00\x00\x00\x00\x00\x00\xe0\xfd\x00\x00\x00\x00\x00\x00\xe0\xfd\x00\x00\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\x00\x00\xe0\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\x00\x00\xe0\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xfd\x00\x00\xe0\xfd\xe0\xfd\x00\x00\xe0\xfd\x00\x00\x00\x00\x00\x00\xe0\xfd\x00\x00\xe0\xfd\x00\x00\xe0\xfd\x00\x00\xe0\xfd\x00\x00\x00\x00\x00\x00\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\x00\x00\xe0\xfd\x00\x00\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\xe0\xfd\xed\xfd\xed\xfd\xed\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xed\xfd\xed\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xed\xfd\x00\x00\x00\x00\x00\x00\xed\xfd\x00\x00\x00\x00\x00\x00\xed\xfd\x00\x00\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\x00\x00\xed\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xed\xfd\xed\xfd\x7d\x03\xed\xfd\x00\x00\xed\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xed\xfd\x00\x00\xed\xfd\xed\xfd\x00\x00\xed\xfd\x00\x00\x00\x00\x00\x00\xed\xfd\x00\x00\xed\xfd\x00\x00\xed\xfd\x00\x00\xed\xfd\x00\x00\x00\x00\x00\x00\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\x00\x00\xed\xfd\x00\x00\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xed\xfd\xa5\x00\x13\x00\xa6\x00\x00\x00\x73\x04\x74\x04\x00\x00\x00\x00\x14\x00\xa7\x00\x00\x00\x00\x00\xd1\x00\xd2\x00\xd3\x00\x00\x00\xd4\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x75\x04\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\xf5\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xd6\x00\xd7\x00\xd8\x00\x00\x00\x00\x00\xd9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xda\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xdc\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x2d\x00\x8d\x00\x00\x00\x00\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\xa5\x00\x13\x00\xa6\x00\x00\x00\x6a\x04\x00\x00\x00\x00\x00\x00\x14\x00\xa7\x00\x00\x00\x00\x00\xd1\x00\xd2\x00\xd3\x00\x00\x00\xd4\x00\x00\x00\xf2\x00\x00\x00\x15\x00\x00\x00\x6b\x04\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\xf5\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xd6\x00\xd7\x00\xd8\x00\x00\x00\x00\x00\xd9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xda\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xdc\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x2d\x00\x8d\x00\x00\x00\x00\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\xa5\x00\x13\x00\xa6\x00\x00\x00\x73\x04\x74\x04\x00\x00\x00\x00\x14\x00\xa7\x00\x00\x00\x00\x00\xd1\x00\xd2\x00\xd3\x00\x00\x00\xd4\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x75\x04\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\xf5\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xd6\x00\xd7\x00\xd8\x00\x00\x00\x00\x00\xd9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xda\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xdc\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x2d\x00\x8d\x00\x00\x00\x00\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\xa5\x00\x13\x00\xa6\x00\x00\x00\x6a\x04\x00\x00\x00\x00\x00\x00\x14\x00\xa7\x00\x00\x00\x00\x00\xd1\x00\xd2\x00\xd3\x00\x00\x00\xd4\x00\x00\x00\xf2\x00\x00\x00\x15\x00\x00\x00\x6b\x04\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\xf5\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xd6\x00\xd7\x00\xd8\x00\x00\x00\x00\x00\xd9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xda\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xdc\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x2d\x00\x8d\x00\x00\x00\x00\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\xa5\x00\x13\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x00\x00\x00\x00\x00\xad\x00\x00\x00\x5a\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\x84\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x94\x01\xb5\x00\x00\x00\x00\x00\x5e\x01\x5f\x01\xb6\x00\x2c\x00\x8a\x00\x8b\x00\x8c\x00\x2d\x00\x8d\x00\x8e\x00\x8f\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\xa5\x00\x13\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x00\x00\x00\x00\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\x84\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\xbb\xfd\xb4\x00\xbb\xfd\xb5\x00\x00\x00\x00\x00\x2f\x02\x5f\x01\xb6\x00\x2c\x00\x8a\x00\x8b\x00\x8c\x00\x2d\x00\x8d\x00\x8e\x00\x8f\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\xa5\x00\x13\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x00\x00\x00\x00\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\x84\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x47\x02\xb4\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x2f\x02\x5f\x01\xb6\x00\x2c\x00\x8a\x00\x8b\x00\x8c\x00\x2d\x00\x8d\x00\x8e\x00\x8f\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\xa5\x00\x13\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x00\x00\x00\x00\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\x84\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x4a\x02\xb5\x00\x00\x00\x00\x00\x2f\x02\x5f\x01\xb6\x00\x2c\x00\x8a\x00\x8b\x00\x8c\x00\x2d\x00\x8d\x00\x8e\x00\x8f\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\xa5\x00\x13\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xa7\x00\x00\x00\x00\x00\xd1\x00\xd2\x00\xd3\x00\x00\x00\xd4\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\xd5\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xd6\x00\xd7\x00\xd8\x00\x00\x00\x00\x00\xd9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xda\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xdc\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x2d\x00\x8d\x00\x00\x00\x00\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\xa5\x00\x13\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x00\x00\x00\x00\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\x84\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x99\x01\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x5f\x01\xb6\x00\x2c\x00\x8a\x00\x8b\x00\x8c\x00\x2d\x00\x8d\x00\x8e\x00\x8f\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\xa5\x00\x13\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x00\x00\x00\x00\x00\xad\x00\x00\x00\xbc\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\x84\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x5f\x01\xb6\x00\x2c\x00\x8a\x00\x8b\x00\x8c\x00\x2d\x00\x8d\x00\x8e\x00\x8f\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\xa5\x00\x13\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xa7\x00\x00\x00\x00\x00\xd1\x00\xd2\x00\xd3\x00\x00\x00\xd4\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\xf5\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xd6\x00\xd7\x00\xd8\x00\x00\x00\x00\x00\xd9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xda\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xdc\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x2d\x00\x8d\x00\x00\x00\x00\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\xa5\x00\x13\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x00\x00\x00\x00\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\x84\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x5f\x01\xb6\x00\x2c\x00\x8a\x00\x8b\x00\x8c\x00\x2d\x00\x8d\x00\x8e\x00\x8f\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\xa5\x00\x13\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\x00\x00\xab\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x01\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x2d\x00\x8d\x00\x00\x00\x00\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\xa5\x00\x13\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x03\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\x9e\x03\x00\x00\x00\x00\xb6\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x2d\x00\x8d\x00\x00\x00\x00\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\xa5\x00\x13\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa8\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\xaa\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x2d\x00\x8d\x00\x00\x00\x00\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\xa5\x00\x13\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa8\x00\x00\x00\x00\x00\x00\x00\x15\x00\x94\x03\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x2d\x00\x8d\x00\x00\x00\x00\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\xa5\x00\x13\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa8\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\xaa\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x2d\x00\x8d\x00\x00\x00\x00\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\xa5\x00\x13\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\x9e\x03\x00\x00\x00\x00\xb6\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x2d\x00\x8d\x00\x00\x00\x00\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\xa5\x00\x13\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa8\x00\x00\x00\x00\x00\x00\x00\x15\x00\x94\x03\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x2d\x00\x8d\x00\x00\x00\x00\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\xa5\x00\x13\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x2d\x00\x8d\x00\x00\x00\x00\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\xa5\x00\x13\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa8\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x2d\x00\x8d\x00\x00\x00\x00\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\xa5\x00\x13\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x2d\x00\x8d\x00\x00\x00\x00\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\xa5\x00\x13\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa8\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x2d\x00\x8d\x00\x00\x00\x00\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\xa5\x00\x13\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x2d\x00\x8d\x00\x00\x00\x00\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\xa5\x00\x13\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\xe4\x03\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x2d\x00\x8d\x00\x00\x00\x00\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\xa5\x00\x13\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x2d\x00\x8d\x00\x00\x00\x00\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\xa5\x00\x13\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa8\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x2d\x00\x8d\x00\x00\x00\x00\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\xa5\x00\x13\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x2d\x00\x8d\x00\x00\x00\x00\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\xa5\x00\x13\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x2d\x00\x8d\x00\x00\x00\x00\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\xd5\xfe\xd5\xfe\xd5\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\xfe\xd5\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\xfe\x00\x00\x00\x00\x00\x00\xd5\xfe\x00\x00\x00\x00\x00\x00\xd5\xfe\x00\x00\xd5\xfe\xd5\xfe\xd5\xfe\xd5\xfe\xd5\xfe\xd5\xfe\xd5\xfe\xd5\xfe\xd5\xfe\xd5\xfe\xd5\xfe\xd5\xfe\xd5\xfe\xd5\xfe\x00\x00\xd5\xfe\x00\x00\x00\x00\x00\x00\xd5\xfe\xd5\xfe\xd5\xfe\xd5\xfe\xd5\xfe\xd5\xfe\xd5\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\xfe\xd5\xfe\xd5\xfe\xd5\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfa\x02\x00\x00\xd5\xfe\x00\x00\xd5\xfe\x00\x00\xd5\xfe\x00\x00\x00\x00\x00\x00\x00\x00\xd5\xfe\xd5\xfe\xd5\xfe\x00\x00\x00\x00\xd5\xfe\xd5\xfe\x00\x00\x00\x00\xd5\xfe\xd5\xfe\xd5\xfe\xd5\xfe\xd5\xfe\xd5\xfe\xd5\xfe\xd5\xfe\xd5\xfe\xd5\xfe\xd5\xfe\xd5\xfe\xd5\xfe\xd5\xfe\xd5\xfe\xd5\xfe\xd5\xfe\xd5\xfe\x00\x00\xd5\xfe\x00\x00\xd5\xfe\xd5\xfe\xd5\xfe\xd5\xfe\xd5\xfe\xa5\x00\x13\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x2d\x00\x8d\x00\x00\x00\x00\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\xcc\xfe\xcc\xfe\xcc\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcc\xfe\xcc\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcc\xfe\x00\x00\x00\x00\x00\x00\xcc\xfe\x00\x00\x00\x00\x00\x00\x2a\x03\x00\x00\xcc\xfe\xcc\xfe\xcc\xfe\xcc\xfe\xcc\xfe\xcc\xfe\xcc\xfe\xcc\xfe\xcc\xfe\xcc\xfe\xcc\xfe\xcc\xfe\xcc\xfe\xcc\xfe\x00\x00\xcc\xfe\x00\x00\x00\x00\x00\x00\xcc\xfe\xcc\xfe\xcc\xfe\xcc\xfe\xcc\xfe\xcc\xfe\xcc\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcc\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcc\xfe\xcc\xfe\xcc\xfe\xcc\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcc\xfe\x00\x00\xcc\xfe\x00\x00\xcc\xfe\x00\x00\xcc\xfe\x00\x00\x00\x00\x00\x00\x00\x00\xcc\xfe\xcc\xfe\xcc\xfe\x00\x00\x00\x00\xcc\xfe\xcc\xfe\x00\x00\x00\x00\xcc\xfe\xcc\xfe\xcc\xfe\xcc\xfe\xcc\xfe\xcc\xfe\xcc\xfe\xcc\xfe\xcc\xfe\xcc\xfe\xcc\xfe\xcc\xfe\xcc\xfe\xcc\xfe\xcc\xfe\xcc\xfe\xcc\xfe\xcc\xfe\x00\x00\xcc\xfe\x00\x00\xcc\xfe\xcc\xfe\xcc\xfe\xcc\xfe\xcc\xfe\xa5\x00\x13\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x2d\x00\x8d\x00\x00\x00\x00\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\xcd\xfe\xcd\xfe\xcd\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcd\xfe\xcd\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcd\xfe\x00\x00\x00\x00\x00\x00\xcd\xfe\x00\x00\x00\x00\x00\x00\xe2\x04\x00\x00\xcd\xfe\xcd\xfe\xcd\xfe\xcd\xfe\xcd\xfe\xcd\xfe\xcd\xfe\xcd\xfe\xcd\xfe\xcd\xfe\xcd\xfe\xcd\xfe\xcd\xfe\xcd\xfe\x00\x00\xcd\xfe\x00\x00\x00\x00\x00\x00\xcd\xfe\xcd\xfe\xcd\xfe\xcd\xfe\xcd\xfe\xcd\xfe\xcd\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcd\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcd\xfe\xcd\xfe\xcd\xfe\xcd\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcd\xfe\x00\x00\xcd\xfe\x00\x00\xcd\xfe\x00\x00\xcd\xfe\x00\x00\x00\x00\x00\x00\x00\x00\xcd\xfe\xcd\xfe\xcd\xfe\x00\x00\x00\x00\xcd\xfe\xcd\xfe\x00\x00\x00\x00\xcd\xfe\xcd\xfe\xcd\xfe\xcd\xfe\xcd\xfe\xcd\xfe\xcd\xfe\xcd\xfe\xcd\xfe\xcd\xfe\xcd\xfe\xcd\xfe\xcd\xfe\xcd\xfe\xcd\xfe\xcd\xfe\xcd\xfe\xcd\xfe\x00\x00\xcd\xfe\x00\x00\xcd\xfe\xcd\xfe\xcd\xfe\xcd\xfe\xcd\xfe\xa5\x00\x13\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x2d\x00\x8d\x00\x00\x00\x00\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\xa5\x00\x13\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\xa0\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x2d\x00\x8d\x00\x00\x00\x00\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\xa5\x00\x13\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\xab\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x2d\x00\x8d\x00\x00\x00\x00\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\xa5\x00\x13\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x8a\x03\x00\x00\x00\x00\x00\x00\xb6\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x2d\x00\x8d\x00\x00\x00\x00\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\xa5\x00\x13\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xa9\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x00\xb0\x00\xb1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x2d\x00\x8d\x00\x00\x00\x00\x00\xb7\x00\xb8\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\x3d\xfd\x3d\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x00\x00\x00\x00\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x00\x00\x00\x00\x3d\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\xfd\x3d\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\xfd\x3d\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\xfd\x3d\xfd\x00\x00\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x00\x00\x3d\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x3d\xfd\x00\x00\x00\x00\x3d\xfd\x3d\xfd\x3d\xfd\x00\x00\x00\x00\x00\x00\x3d\xfd\x00\x00\x3d\xfd\x30\x02\x3d\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x3d\xfd\x00\x00\x3d\xfd\x3d\xfd\x3d\xfd\x7e\xfe\x7e\xfe\x00\x00\x00\x00\x3d\xfd\x3d\xfd\x3d\xfd\x00\x00\x7e\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7e\xfe\x3d\xfd\x00\x00\x00\x00\x3d\xfd\x3d\xfd\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x00\x00\x00\x00\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x00\x00\x00\x00\x7e\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7e\xfe\x7e\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7e\xfe\xba\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7e\xfe\x7e\xfe\x00\x00\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x00\x00\x7e\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x7e\xfe\x00\x00\x00\x00\x7e\xfe\x7e\xfe\x7e\xfe\x00\x00\x00\x00\x00\x00\x7e\xfe\x00\x00\x7e\xfe\x7e\xfe\x7e\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x7e\xfe\x00\x00\x7e\xfe\x7e\xfe\x7e\xfe\x00\x00\x00\x00\xa5\x00\x13\x00\x7e\xfe\x7e\xfe\x7e\xfe\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7e\xfe\x15\x00\x00\x00\x7e\xfe\x7e\xfe\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x13\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb3\x00\x00\x00\xb4\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x2d\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6a\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\x00\x00\xc8\x00\x00\x00\x6e\x00\xc9\x00\xca\x00\x6f\x00\x70\x00\x50\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x12\x02\x13\x02\x5b\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x14\x02\x51\x00\x00\x00\x17\x00\x18\x00\x19\x00\x52\x00\x53\x00\x54\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd6\x01\x00\x00\x00\x00\x00\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\xd7\x01\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x01\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x50\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x00\x00\x6f\x00\x70\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x17\x00\x18\x00\x19\x00\x52\x00\x53\x00\x54\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\xd2\x01\x00\x00\x00\x00\x00\x00\x5e\x01\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x50\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x00\x00\x6f\x00\x70\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x17\x00\x18\x00\x19\x00\x52\x00\x53\x00\x54\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x02\x59\x00\x5a\x00\x00\x00\x3e\x02\x00\x00\x00\x00\x00\x00\x00\x00\x3f\x02\x00\x00\x00\x00\x00\x00\x00\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x5d\x01\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x01\x61\x00\x62\x00\x63\x00\x64\x00\x40\x02\x41\x02\x00\x00\x67\x00\x68\x00\x42\x02\x00\x00\x00\x00\x6a\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x50\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x00\x00\x6f\x00\x70\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x17\x00\x18\x00\x19\x00\x52\x00\x53\x00\x54\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\xd9\x01\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x50\x00\x13\x00\x6a\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2d\x01\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x6e\x00\x00\x00\x00\x00\x6f\x00\x70\x00\x17\x00\x18\x00\x19\x00\x52\x00\x53\x00\x54\x00\x2e\x01\x2f\x01\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x00\x00\x50\x00\x13\x00\x6b\x00\x6c\x00\x6d\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xce\x04\x00\x00\x00\x00\x00\x00\x6e\x00\x15\x00\x00\x00\x6f\x00\x70\x00\xe5\x02\x00\x00\x17\x00\x18\x00\x19\x00\x52\x00\x53\x00\x54\x00\xcf\x04\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x00\x00\x50\x00\x13\x00\x6b\x00\x6c\x00\x6d\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x15\x00\x00\x00\x6f\x00\x70\x00\x51\x00\x00\x00\x17\x00\x18\x00\x19\x00\x52\x00\x53\x00\x54\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\xc3\x04\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x50\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x00\x00\x6f\x00\x70\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x17\x00\x18\x00\x19\x00\x52\x00\x53\x00\x54\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x50\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x00\x00\x6f\x00\x70\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\xe5\x02\x00\x00\x17\x00\x18\x00\x19\x00\x52\x00\x53\x00\x54\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x05\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x00\x00\x50\x00\x13\x00\x6b\x00\x6c\x00\x6d\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x15\x00\x00\x00\x6f\x00\x70\x00\xe5\x02\x00\x00\x17\x00\x18\x00\x19\x00\x52\x00\x53\x00\x54\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x00\x00\x50\x00\x13\x00\x6b\x00\x6c\x00\x6d\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x15\x00\x00\x00\x6f\x00\x70\x00\x51\x00\x00\x00\x17\x00\x18\x00\x19\x00\x52\x00\x53\x00\x54\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x50\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x00\x00\x6f\x00\x70\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x17\x00\x18\x00\x19\x00\x52\x00\x53\x00\x54\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x2f\x05\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x50\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x00\x00\x6f\x00\x70\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x17\x00\x18\x00\x19\x00\x52\x00\x53\x00\x54\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x50\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x00\x00\x6f\x00\x70\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\xe5\x02\x00\x00\x17\x00\x18\x00\x19\x00\x52\x00\x53\x00\x54\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x00\x00\x50\x00\x13\x00\x6b\x00\x6c\x00\x6d\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x15\x00\x00\x00\x6f\x00\x70\x00\x62\x03\x00\x00\x17\x00\x18\x00\x19\x00\x52\x00\x53\x00\x54\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x00\x00\x50\x00\x13\x00\x6b\x00\x6c\x00\x6d\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x15\x00\x00\x00\x6f\x00\x70\x00\xe5\x02\x00\x00\x17\x00\x18\x00\x19\x00\x52\x00\x53\x00\x54\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x00\x00\x50\x00\x13\x00\x6b\x00\x6c\x00\x6d\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x15\x00\x00\x00\x6f\x00\x70\x00\x62\x03\x00\x00\x17\x00\x18\x00\x19\x00\x52\x00\x53\x00\x54\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x00\x00\x00\x00\x50\x00\x13\x00\x6b\x00\x6c\x00\x6d\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x15\x00\x00\x00\x6f\x00\x70\x00\xe5\x02\x00\x00\x17\x00\x18\x00\x19\x00\x52\x00\x53\x00\x54\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x50\x00\x13\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x6e\x00\x00\x00\x00\x00\x6f\x00\x70\x00\x17\x00\x18\x00\x19\x00\x52\x00\x53\x00\x54\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x59\x00\x5a\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x67\x00\x68\x00\x69\x00\x50\x00\x13\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x6e\x00\x00\x00\x00\x00\x6f\x00\x70\x00\x17\x00\x18\x00\x19\x00\x52\x00\x53\x00\x54\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x5a\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x5f\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe1\x01\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x6b\x00\x6c\x00\x6d\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x15\x00\x00\x00\x6f\x00\x70\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x13\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x36\x03\x37\x03\x38\x03\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdf\x01\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x39\x03\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\xdf\x01\x13\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x14\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x39\x03\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdf\x01\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x00\x00\x39\x03\x00\x00\x00\x00\x13\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x14\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\xb0\x04\x2a\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x12\x02\x13\x02\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x14\x02\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x12\x02\x13\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x14\x02\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x12\x02\x13\x02\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x84\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x00\x13\x00\x87\x00\x00\x00\x88\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x89\x00\x00\x00\x2c\x00\x8a\x00\x8b\x00\x8c\x00\x2d\x00\x8d\x00\x8e\x00\x8f\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x84\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb9\x02\x13\x00\xc9\x01\x00\x00\xca\x01\x00\x00\x88\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\xcb\x01\x00\x00\x2c\x00\x8a\x00\x8b\x00\x8c\x00\x00\x00\x8d\x00\x15\x00\x8f\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x13\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x04\x00\x00\x00\x00\x15\x00\x00\x00\x3b\x04\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x3c\x04\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x2d\x00\x8d\x00\x3a\x04\x00\x00\x00\x00\x15\x00\x00\x00\x3b\x04\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x3c\x04\x3d\x04\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x3e\x04\x00\x00\x00\x00\x2c\x00\x64\x00\x00\x00\x00\x00\x2d\x00\x67\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x3d\x04\x00\x00\x1b\xfe\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x1b\xfe\x2c\x00\x64\x00\x00\x00\x00\x00\x2d\x00\x67\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1b\xfe\x00\x00\x00\x00\x00\x00\x1b\xfe\x00\x00\x1b\xfe\x1b\xfe\x1b\xfe\x1b\xfe\x1b\xfe\x1b\xfe\x1b\xfe\x1b\xfe\x1b\xfe\x1b\xfe\x1b\xfe\x1b\xfe\x1b\xfe\x00\x00\x00\x00\x1b\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x1b\xfe\x1b\xfe\x1b\xfe\x1b\xfe\x1b\xfe\x1b\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x8d\x01\x00\x00\x88\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x2d\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x6c\x01\x00\x00\x1b\xfe\x14\x00\x1b\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1b\xfe\x1b\xfe\x00\x00\x15\x00\x1b\xfe\x1b\xfe\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x13\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x3b\x04\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x8d\x01\x13\x00\x88\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x2c\x00\x8a\x00\xeb\x04\x00\x00\x2d\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x3d\x04\x13\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x14\x00\x00\x00\x2c\x00\x64\x00\x00\x00\x00\x00\x2d\x00\x67\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\xc9\x01\x00\x00\xca\x01\x14\x00\x88\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x15\x00\x00\x00\x8d\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x13\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x15\x00\x2d\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x52\x00\x53\x00\x54\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x8f\x00\x00\x00\x00\x00\xc8\x02\xc9\x02\x00\x00\xca\x02\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x8f\x00\x00\x00\x00\x00\x59\x03\xc9\x02\x00\x00\xca\x02\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x67\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcb\x02\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x49\x01\x4a\x01\xcb\x02\x92\x00\x00\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x4b\x01\x00\x00\x98\x00\x99\x00\x10\xfe\x81\x00\xb5\x01\x00\x00\x4c\x01\x4d\x01\x10\xfe\x00\x00\x10\xfe\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x84\x00\xb6\x01\xb7\x01\xb8\x01\xb9\x01\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\xfe\x00\x00\x00\x00\x00\x00\x10\xfe\x00\x00\x10\xfe\x00\x00\x10\xfe\x00\x00\x00\x00\x00\x00\x10\xfe\x46\x01\x9e\x00\x9f\x00\x00\x00\x8b\x00\x8c\x00\x00\x00\x00\x00\x8e\x00\x8f\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x4e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x01\x50\x01\x00\x00\x51\x01\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x52\x01\x53\x01\x94\x01\x55\x01\x11\x00\x7b\x00\x7c\x00\x7d\x00\x56\x01\x7f\x00\xa2\x00\x00\x00\x00\x00\x57\x01\x00\x00\x58\x01\xa3\x00\x8f\x00\x49\x01\x4a\x01\x00\x00\x92\x00\x00\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x4b\x01\x00\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x01\x4d\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x8f\x00\x4e\x01\x84\x01\x00\x00\x92\x00\x00\x00\x00\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x4f\x01\x50\x01\x00\x00\x51\x01\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x52\x01\x53\x01\x54\x01\x55\x01\x11\x00\x7b\x00\x7c\x00\x7d\x00\x56\x01\x7f\x00\xa2\x00\x00\x00\x00\x00\x57\x01\x00\x00\x58\x01\xa3\x00\x8f\x00\x49\x01\x4a\x01\x00\x00\x92\x00\x00\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x9e\x00\x9f\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8e\x01\x8f\x01\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x4e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x01\x50\x01\x00\x00\x51\x01\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x52\x01\x90\x01\x00\x00\x91\x01\x11\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xa2\x00\x00\x00\x00\x00\x92\x01\x00\x00\x58\x01\xa3\x00\x8f\x00\x49\x01\x4a\x01\x00\x00\x92\x00\x00\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x13\x00\x00\x00\x00\x00\x00\x00\x95\x01\x00\x00\x00\x00\x14\x00\x96\x01\x97\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x4e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x01\x50\x01\x00\x00\x51\x01\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x52\x01\x90\x01\x00\x00\x91\x01\x11\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xa2\x00\x8f\x00\x49\x01\x4a\x01\x00\x00\x92\x00\xa3\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x75\x02\x00\x00\x00\x00\x76\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x4e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x01\x50\x01\x00\x00\x51\x01\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x52\x01\x90\x01\x00\x00\x91\x01\x11\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xa2\x00\x8f\x00\x49\x01\x4a\x01\x00\x00\x92\x00\xa3\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x75\x02\x00\x00\x00\x00\x8a\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x4e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x01\x50\x01\x00\x00\x51\x01\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x52\x01\x90\x01\x00\x00\x91\x01\x11\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xa2\x00\x8f\x00\x49\x01\x4a\x01\x00\x00\x92\x00\xa3\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x13\x00\x00\x00\x00\x00\x00\x00\xba\x02\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x4e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x01\x50\x01\x00\x00\x51\x01\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x52\x01\x90\x01\x00\x00\x91\x01\x11\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xa2\x00\x8f\x00\x49\x01\x4a\x01\x00\x00\x92\x00\xa3\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x13\x00\x12\x02\x13\x02\x00\x00\x95\x03\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x4e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x01\x50\x01\x00\x00\x51\x01\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x52\x01\x90\x01\x00\x00\x91\x01\x11\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xa2\x00\x8f\x00\x8c\x03\x4a\x01\x00\x00\x92\x00\xa3\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x13\x00\x2c\x00\x00\x00\x00\x00\x8d\x03\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x52\x00\x53\x00\x54\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x4e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x01\x50\x01\x00\x00\x51\x01\x00\x00\x00\x00\x0c\x04\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x52\x01\x90\x01\x00\x00\x91\x01\x11\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xa2\x00\x8f\x00\x49\x01\x4a\x01\x00\x00\x92\x00\xa3\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x13\x00\x63\x00\x00\x00\x00\x00\x64\x03\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x18\x00\x19\x00\x52\x00\x53\x00\x54\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x4e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x01\x50\x01\x00\x00\x51\x01\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x52\x01\x90\x01\x00\x00\x91\x01\x11\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xa2\x00\x8f\x00\x49\x01\x4a\x01\x00\x00\x92\x00\xa3\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x63\x00\x00\x00\x00\x00\xd3\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x4e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x01\x50\x01\x00\x00\x51\x01\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x52\x01\x90\x01\x00\x00\x91\x01\x11\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xa2\x00\x8f\x00\x49\x01\x4a\x01\x00\x00\x92\x00\xa3\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb4\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x4e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x01\x50\x01\x00\x00\x51\x01\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x52\x01\x90\x01\x00\x00\x91\x01\x11\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xa2\x00\x8f\x00\x90\x00\x91\x00\x00\x00\x92\x00\xa3\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8e\x03\x8f\x03\x90\x03\x91\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x92\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\xdc\x00\x91\x00\x00\x00\x92\x00\x00\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x98\x03\x99\x03\x9a\x03\x00\x00\x00\x00\xa3\x00\x00\x00\x00\x00\x9b\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x8f\x00\x90\x00\x91\x00\x00\x00\x92\x00\x00\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x92\x04\x90\x03\x91\x03\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x9c\x03\x00\x00\x00\x00\x9a\x00\x00\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x92\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\xde\x00\x91\x00\x00\x00\x92\x00\x00\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x1b\xfe\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x1b\xfe\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x6e\x01\x00\x00\xa2\x00\x00\x00\x00\x00\x1b\xfe\x00\x00\x00\x00\xa3\x00\x1b\xfe\x00\x00\x1b\xfe\x1b\xfe\x1b\xfe\x1b\xfe\x1b\xfe\x1b\xfe\x1b\xfe\x1b\xfe\x1b\xfe\x1b\xfe\x1b\xfe\x1b\xfe\x1b\xfe\x00\x00\x00\x00\x1b\xfe\x9e\x00\x9f\x00\x00\x00\x00\x00\x1b\xfe\x1b\xfe\x1b\xfe\x1b\xfe\x1b\xfe\x1b\xfe\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x8f\x00\x90\x00\x91\x00\x00\x00\x92\x00\x00\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x00\x00\x00\x00\x9a\x00\x00\x00\x6c\x01\xa3\x00\x1b\xfe\x00\x00\xf9\x00\xfa\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1b\xfe\x9e\x00\x9f\x00\x00\x00\x1b\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x8f\x00\x90\x00\x91\x00\x00\x00\x92\x00\x00\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x00\x00\x00\x00\x9a\x00\x00\x00\x00\x00\xa3\x00\x00\x00\x9b\x00\x00\x00\x9c\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x8f\x00\x90\x00\x91\x00\x00\x00\x92\x00\x00\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x00\x00\x00\x00\x9a\x00\x00\x00\x00\x00\xa3\x00\x7f\x02\x00\x00\x00\x00\x7e\x02\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x8f\x00\x90\x00\x91\x00\x00\x00\x92\x00\x00\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x00\x00\x00\x00\x9a\x00\x00\x00\x00\x00\xa3\x00\x7d\x02\x00\x00\x00\x00\x7e\x02\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x8f\x00\x90\x00\x91\x00\x00\x00\x92\x00\x00\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x5f\x02\x60\x02\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x00\x00\x00\x00\x9a\x00\x00\x00\x00\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\xdc\x00\x91\x00\x00\x00\x92\x00\x00\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x9e\x03\x99\x03\x9a\x03\x00\x00\x00\x00\xa3\x00\x00\x00\x00\x00\x9b\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x8f\x00\x90\x00\x91\x00\x00\x00\x92\x00\x00\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x54\x03\x60\x02\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x00\x00\x00\x00\x9a\x00\x00\x00\x00\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\xdc\x00\x91\x00\x00\x00\x92\x00\x00\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\xda\x03\x99\x03\x9a\x03\x00\x00\x00\x00\xa3\x00\x00\x00\x00\x00\x9b\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1b\xfe\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x1b\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x1b\xfe\x00\x00\x00\x00\x00\x00\x1b\xfe\xa3\x00\x1b\xfe\x1b\xfe\x1b\xfe\x1b\xfe\x1b\xfe\x1b\xfe\x1b\xfe\x1b\xfe\x1b\xfe\x1b\xfe\x1b\xfe\x1b\xfe\x1b\xfe\x00\x00\x00\x00\x1b\xfe\x00\x00\x00\x00\x00\x00\x13\x00\x1b\xfe\x1b\xfe\x1b\xfe\x1b\xfe\x1b\xfe\x1b\xfe\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x8f\x00\xa6\x01\x91\x00\x6c\x01\x92\x00\x1b\xfe\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x1b\xfe\x00\x00\x58\x02\x00\x00\x1b\xfe\x8f\x00\x90\x00\x91\x00\x00\x00\x92\x00\x00\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x00\x00\xa7\x01\xa8\x01\xa9\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x59\x02\x00\x00\x9a\x00\x00\x00\x2d\x00\x00\x00\x00\x00\xa0\x00\x72\x00\xe7\x03\x9d\x00\x73\x00\x74\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\xa3\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x8f\x00\x90\x00\x91\x00\x00\x00\x92\x00\xa3\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x90\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x91\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\xa3\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x8f\x00\x90\x00\x91\x00\x00\x00\x92\x00\x00\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\xdc\x00\x91\x00\x00\x00\x92\x00\x00\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x03\x00\x00\x2b\x00\x00\x00\x00\x00\x96\x04\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x9b\x03\x2c\x00\x00\x00\x00\x00\x00\x00\x2d\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\xa3\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x8f\x00\xdc\x00\x91\x00\x00\x00\x92\x00\xa3\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\xdc\x00\x91\x00\x00\x00\x92\x00\x00\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x2b\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\xa3\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x8f\x00\xdc\x00\x91\x00\x00\x00\x92\x00\xa3\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x8f\x00\xb3\x01\x91\x00\x00\x00\x92\x00\x00\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2a\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x8f\x00\xac\x01\x91\x00\x00\x00\x92\x00\xa3\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x8f\x00\x85\x01\x91\x00\x00\x00\x92\x00\x00\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x8f\x00\x7f\x01\x91\x00\x00\x00\x92\x00\xa3\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x8f\x00\x5b\x02\x91\x00\x00\x00\x92\x00\x00\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x8f\x00\x4f\x02\x91\x00\x00\x00\x92\x00\xa3\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x8f\x00\x4e\x02\x91\x00\x00\x00\x92\x00\x00\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x8f\x00\x4d\x02\x91\x00\x00\x00\x92\x00\xa3\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x8f\x00\x4c\x02\x91\x00\x00\x00\x92\x00\x00\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x8f\x00\xa1\x03\x91\x00\x00\x00\x92\x00\xa3\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x8f\x00\xa0\x03\x91\x00\x00\x00\x92\x00\x00\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x8f\x00\x94\x03\x91\x00\x00\x00\x92\x00\xa3\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x8f\x00\x55\x03\x91\x00\x00\x00\x92\x00\x00\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x8f\x00\xec\x03\x91\x00\x00\x00\x92\x00\xa3\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x8f\x00\xe2\x03\x91\x00\x00\x00\x92\x00\x00\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x8f\x00\xe1\x03\x91\x00\x00\x00\x92\x00\xa3\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x8f\x00\xd8\x03\x91\x00\x00\x00\x92\x00\x00\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x8f\x00\xd6\x03\x91\x00\x00\x00\x92\x00\xa3\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x8f\x00\x97\x04\x91\x00\x00\x00\x92\x00\x00\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x8f\x00\x8f\x04\x91\x00\x00\x00\x92\x00\xa3\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x8f\x00\x76\x04\x91\x00\x00\x00\x92\x00\x00\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x8f\x00\xe3\x04\x91\x00\x00\x00\x92\x00\xa3\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x8f\x00\xb8\x04\x91\x00\x00\x00\x92\x00\x00\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x8f\x00\xb7\x04\x91\x00\x00\x00\x92\x00\xa3\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x8f\x00\xb6\x04\x91\x00\x00\x00\x92\x00\x00\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x8f\x00\x17\x05\x91\x00\x00\x00\x92\x00\xa3\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x8f\x00\x27\x05\x91\x00\x00\x00\x92\x00\x00\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x13\x00\x00\x00\xa2\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x14\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\xa3\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x84\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x00\x13\x00\x68\x01\x5d\x01\x88\x00\x00\x00\x00\x00\x00\x00\x14\x00\x5e\x01\x00\x00\x00\x00\x2c\x00\x8a\x00\x8b\x00\x8c\x00\x00\x00\x14\x01\x00\x00\x00\x00\x15\x00\x00\x00\x15\x01\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x13\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x16\x01\x00\x00\x88\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x86\x00\x00\x00\x68\x01\x00\x00\x88\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x2c\x00\x8a\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x13\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x25\x01\x00\x00\x88\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x86\x00\x00\x00\x16\x01\x00\x00\x88\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x2c\x00\x8a\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x13\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x68\x01\x00\x00\x88\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x8a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x86\x00\x00\x00\x16\x01\x00\x00\x88\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x2c\x00\x8a\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x03\xff\x00\x00\x00\x00\x16\x00\x03\xff\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\xf5\x02\x13\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x02\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x13\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdf\x01\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x2c\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x13\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x04\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x16\x00\x2c\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x13\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdf\x01\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x17\x00\x18\x00\x19\x00\x52\x00\x53\x00\x54\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x13\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x04\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x17\x00\x18\x00\x19\x00\x52\x00\x53\x00\x54\x00\x00\x00\x00\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x00\x00\x00\x00\x24\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x00\x00\xe9\x01\x8f\x00\x00\x00\xbd\x02\x00\x00\x92\x00\xea\x01\x00\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x63\x00\x8f\x00\x00\x00\x26\x04\x00\x00\x92\x00\x00\x00\x00\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xea\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x8f\x00\xa2\x00\xcf\x04\x00\x00\x92\x00\x00\x00\x00\x00\x94\x00\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x8f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9d\x01\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x6d\x02\x6e\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x9d\x01\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x8f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9d\x01\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x02\x97\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x9e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x8f\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x00\x00\x9c\x01\x95\x00\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x8f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x03\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x88\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\xb1\x01\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x8f\x00\xa2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x01\x96\x00\x97\x00\x9e\x00\x9f\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\xa2\x01\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x8f\x00\xa2\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x9b\x01\x96\x00\x97\x00\x9e\x00\x9f\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x8f\x00\xa2\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x9a\x01\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x8f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x99\x01\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x8d\x01\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x8f\x00\xa2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x09\x03\x96\x00\x97\x00\x9e\x00\x9f\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x08\x03\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x8f\x00\xa2\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\xb1\x01\x96\x00\x97\x00\x9e\x00\x9f\x00\x98\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x8f\x00\xa2\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x5c\x02\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\x00\x00\x8f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x03\x96\x00\x97\x00\x00\x00\x00\x00\x98\x00\x99\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x9e\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x72\x00\x00\x00\x00\x00\x73\x00\x74\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\xa1\x00\x00\x00\x0f\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x7c\x00\x7d\x00\x00\x00\x00\x00\xa2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#--happyReduceArr = Happy_Data_Array.array (13, 815) [- (13 , happyReduce_13),- (14 , happyReduce_14),- (15 , happyReduce_15),- (16 , happyReduce_16),- (17 , happyReduce_17),- (18 , happyReduce_18),- (19 , happyReduce_19),- (20 , happyReduce_20),- (21 , happyReduce_21),- (22 , happyReduce_22),- (23 , happyReduce_23),- (24 , happyReduce_24),- (25 , happyReduce_25),- (26 , happyReduce_26),- (27 , happyReduce_27),- (28 , happyReduce_28),- (29 , happyReduce_29),- (30 , happyReduce_30),- (31 , happyReduce_31),- (32 , happyReduce_32),- (33 , happyReduce_33),- (34 , happyReduce_34),- (35 , happyReduce_35),- (36 , happyReduce_36),- (37 , happyReduce_37),- (38 , happyReduce_38),- (39 , happyReduce_39),- (40 , happyReduce_40),- (41 , happyReduce_41),- (42 , happyReduce_42),- (43 , happyReduce_43),- (44 , happyReduce_44),- (45 , happyReduce_45),- (46 , happyReduce_46),- (47 , happyReduce_47),- (48 , happyReduce_48),- (49 , happyReduce_49),- (50 , happyReduce_50),- (51 , happyReduce_51),- (52 , happyReduce_52),- (53 , happyReduce_53),- (54 , happyReduce_54),- (55 , happyReduce_55),- (56 , happyReduce_56),- (57 , happyReduce_57),- (58 , happyReduce_58),- (59 , happyReduce_59),- (60 , happyReduce_60),- (61 , happyReduce_61),- (62 , happyReduce_62),- (63 , happyReduce_63),- (64 , happyReduce_64),- (65 , happyReduce_65),- (66 , happyReduce_66),- (67 , happyReduce_67),- (68 , happyReduce_68),- (69 , happyReduce_69),- (70 , happyReduce_70),- (71 , happyReduce_71),- (72 , happyReduce_72),- (73 , happyReduce_73),- (74 , happyReduce_74),- (75 , happyReduce_75),- (76 , happyReduce_76),- (77 , happyReduce_77),- (78 , happyReduce_78),- (79 , happyReduce_79),- (80 , happyReduce_80),- (81 , happyReduce_81),- (82 , happyReduce_82),- (83 , happyReduce_83),- (84 , happyReduce_84),- (85 , happyReduce_85),- (86 , happyReduce_86),- (87 , happyReduce_87),- (88 , happyReduce_88),- (89 , happyReduce_89),- (90 , happyReduce_90),- (91 , happyReduce_91),- (92 , happyReduce_92),- (93 , happyReduce_93),- (94 , happyReduce_94),- (95 , happyReduce_95),- (96 , happyReduce_96),- (97 , happyReduce_97),- (98 , happyReduce_98),- (99 , happyReduce_99),- (100 , happyReduce_100),- (101 , happyReduce_101),- (102 , happyReduce_102),- (103 , happyReduce_103),- (104 , happyReduce_104),- (105 , happyReduce_105),- (106 , happyReduce_106),- (107 , happyReduce_107),- (108 , happyReduce_108),- (109 , happyReduce_109),- (110 , happyReduce_110),- (111 , happyReduce_111),- (112 , happyReduce_112),- (113 , happyReduce_113),- (114 , happyReduce_114),- (115 , happyReduce_115),- (116 , happyReduce_116),- (117 , happyReduce_117),- (118 , happyReduce_118),- (119 , happyReduce_119),- (120 , happyReduce_120),- (121 , happyReduce_121),- (122 , happyReduce_122),- (123 , happyReduce_123),- (124 , happyReduce_124),- (125 , happyReduce_125),- (126 , happyReduce_126),- (127 , happyReduce_127),- (128 , happyReduce_128),- (129 , happyReduce_129),- (130 , happyReduce_130),- (131 , happyReduce_131),- (132 , happyReduce_132),- (133 , happyReduce_133),- (134 , happyReduce_134),- (135 , happyReduce_135),- (136 , happyReduce_136),- (137 , happyReduce_137),- (138 , happyReduce_138),- (139 , happyReduce_139),- (140 , happyReduce_140),- (141 , happyReduce_141),- (142 , happyReduce_142),- (143 , happyReduce_143),- (144 , happyReduce_144),- (145 , happyReduce_145),- (146 , happyReduce_146),- (147 , happyReduce_147),- (148 , happyReduce_148),- (149 , happyReduce_149),- (150 , happyReduce_150),- (151 , happyReduce_151),- (152 , happyReduce_152),- (153 , happyReduce_153),- (154 , happyReduce_154),- (155 , happyReduce_155),- (156 , happyReduce_156),- (157 , happyReduce_157),- (158 , happyReduce_158),- (159 , happyReduce_159),- (160 , happyReduce_160),- (161 , happyReduce_161),- (162 , happyReduce_162),- (163 , happyReduce_163),- (164 , happyReduce_164),- (165 , happyReduce_165),- (166 , happyReduce_166),- (167 , happyReduce_167),- (168 , happyReduce_168),- (169 , happyReduce_169),- (170 , happyReduce_170),- (171 , happyReduce_171),- (172 , happyReduce_172),- (173 , happyReduce_173),- (174 , happyReduce_174),- (175 , happyReduce_175),- (176 , happyReduce_176),- (177 , happyReduce_177),- (178 , happyReduce_178),- (179 , happyReduce_179),- (180 , happyReduce_180),- (181 , happyReduce_181),- (182 , happyReduce_182),- (183 , happyReduce_183),- (184 , happyReduce_184),- (185 , happyReduce_185),- (186 , happyReduce_186),- (187 , happyReduce_187),- (188 , happyReduce_188),- (189 , happyReduce_189),- (190 , happyReduce_190),- (191 , happyReduce_191),- (192 , happyReduce_192),- (193 , happyReduce_193),- (194 , happyReduce_194),- (195 , happyReduce_195),- (196 , happyReduce_196),- (197 , happyReduce_197),- (198 , happyReduce_198),- (199 , happyReduce_199),- (200 , happyReduce_200),- (201 , happyReduce_201),- (202 , happyReduce_202),- (203 , happyReduce_203),- (204 , happyReduce_204),- (205 , happyReduce_205),- (206 , happyReduce_206),- (207 , happyReduce_207),- (208 , happyReduce_208),- (209 , happyReduce_209),- (210 , happyReduce_210),- (211 , happyReduce_211),- (212 , happyReduce_212),- (213 , happyReduce_213),- (214 , happyReduce_214),- (215 , happyReduce_215),- (216 , happyReduce_216),- (217 , happyReduce_217),- (218 , happyReduce_218),- (219 , happyReduce_219),- (220 , happyReduce_220),- (221 , happyReduce_221),- (222 , happyReduce_222),- (223 , happyReduce_223),- (224 , happyReduce_224),- (225 , happyReduce_225),- (226 , happyReduce_226),- (227 , happyReduce_227),- (228 , happyReduce_228),- (229 , happyReduce_229),- (230 , happyReduce_230),- (231 , happyReduce_231),- (232 , happyReduce_232),- (233 , happyReduce_233),- (234 , happyReduce_234),- (235 , happyReduce_235),- (236 , happyReduce_236),- (237 , happyReduce_237),- (238 , happyReduce_238),- (239 , happyReduce_239),- (240 , happyReduce_240),- (241 , happyReduce_241),- (242 , happyReduce_242),- (243 , happyReduce_243),- (244 , happyReduce_244),- (245 , happyReduce_245),- (246 , happyReduce_246),- (247 , happyReduce_247),- (248 , happyReduce_248),- (249 , happyReduce_249),- (250 , happyReduce_250),- (251 , happyReduce_251),- (252 , happyReduce_252),- (253 , happyReduce_253),- (254 , happyReduce_254),- (255 , happyReduce_255),- (256 , happyReduce_256),- (257 , happyReduce_257),- (258 , happyReduce_258),- (259 , happyReduce_259),- (260 , happyReduce_260),- (261 , happyReduce_261),- (262 , happyReduce_262),- (263 , happyReduce_263),- (264 , happyReduce_264),- (265 , happyReduce_265),- (266 , happyReduce_266),- (267 , happyReduce_267),- (268 , happyReduce_268),- (269 , happyReduce_269),- (270 , happyReduce_270),- (271 , happyReduce_271),- (272 , happyReduce_272),- (273 , happyReduce_273),- (274 , happyReduce_274),- (275 , happyReduce_275),- (276 , happyReduce_276),- (277 , happyReduce_277),- (278 , happyReduce_278),- (279 , happyReduce_279),- (280 , happyReduce_280),- (281 , happyReduce_281),- (282 , happyReduce_282),- (283 , happyReduce_283),- (284 , happyReduce_284),- (285 , happyReduce_285),- (286 , happyReduce_286),- (287 , happyReduce_287),- (288 , happyReduce_288),- (289 , happyReduce_289),- (290 , happyReduce_290),- (291 , happyReduce_291),- (292 , happyReduce_292),- (293 , happyReduce_293),- (294 , happyReduce_294),- (295 , happyReduce_295),- (296 , happyReduce_296),- (297 , happyReduce_297),- (298 , happyReduce_298),- (299 , happyReduce_299),- (300 , happyReduce_300),- (301 , happyReduce_301),- (302 , happyReduce_302),- (303 , happyReduce_303),- (304 , happyReduce_304),- (305 , happyReduce_305),- (306 , happyReduce_306),- (307 , happyReduce_307),- (308 , happyReduce_308),- (309 , happyReduce_309),- (310 , happyReduce_310),- (311 , happyReduce_311),- (312 , happyReduce_312),- (313 , happyReduce_313),- (314 , happyReduce_314),- (315 , happyReduce_315),- (316 , happyReduce_316),- (317 , happyReduce_317),- (318 , happyReduce_318),- (319 , happyReduce_319),- (320 , happyReduce_320),- (321 , happyReduce_321),- (322 , happyReduce_322),- (323 , happyReduce_323),- (324 , happyReduce_324),- (325 , happyReduce_325),- (326 , happyReduce_326),- (327 , happyReduce_327),- (328 , happyReduce_328),- (329 , happyReduce_329),- (330 , happyReduce_330),- (331 , happyReduce_331),- (332 , happyReduce_332),- (333 , happyReduce_333),- (334 , happyReduce_334),- (335 , happyReduce_335),- (336 , happyReduce_336),- (337 , happyReduce_337),- (338 , happyReduce_338),- (339 , happyReduce_339),- (340 , happyReduce_340),- (341 , happyReduce_341),- (342 , happyReduce_342),- (343 , happyReduce_343),- (344 , happyReduce_344),- (345 , happyReduce_345),- (346 , happyReduce_346),- (347 , happyReduce_347),- (348 , happyReduce_348),- (349 , happyReduce_349),- (350 , happyReduce_350),- (351 , happyReduce_351),- (352 , happyReduce_352),- (353 , happyReduce_353),- (354 , happyReduce_354),- (355 , happyReduce_355),- (356 , happyReduce_356),- (357 , happyReduce_357),- (358 , happyReduce_358),- (359 , happyReduce_359),- (360 , happyReduce_360),- (361 , happyReduce_361),- (362 , happyReduce_362),- (363 , happyReduce_363),- (364 , happyReduce_364),- (365 , happyReduce_365),- (366 , happyReduce_366),- (367 , happyReduce_367),- (368 , happyReduce_368),- (369 , happyReduce_369),- (370 , happyReduce_370),- (371 , happyReduce_371),- (372 , happyReduce_372),- (373 , happyReduce_373),- (374 , happyReduce_374),- (375 , happyReduce_375),- (376 , happyReduce_376),- (377 , happyReduce_377),- (378 , happyReduce_378),- (379 , happyReduce_379),- (380 , happyReduce_380),- (381 , happyReduce_381),- (382 , happyReduce_382),- (383 , happyReduce_383),- (384 , happyReduce_384),- (385 , happyReduce_385),- (386 , happyReduce_386),- (387 , happyReduce_387),- (388 , happyReduce_388),- (389 , happyReduce_389),- (390 , happyReduce_390),- (391 , happyReduce_391),- (392 , happyReduce_392),- (393 , happyReduce_393),- (394 , happyReduce_394),- (395 , happyReduce_395),- (396 , happyReduce_396),- (397 , happyReduce_397),- (398 , happyReduce_398),- (399 , happyReduce_399),- (400 , happyReduce_400),- (401 , happyReduce_401),- (402 , happyReduce_402),- (403 , happyReduce_403),- (404 , happyReduce_404),- (405 , happyReduce_405),- (406 , happyReduce_406),- (407 , happyReduce_407),- (408 , happyReduce_408),- (409 , happyReduce_409),- (410 , happyReduce_410),- (411 , happyReduce_411),- (412 , happyReduce_412),- (413 , happyReduce_413),- (414 , happyReduce_414),- (415 , happyReduce_415),- (416 , happyReduce_416),- (417 , happyReduce_417),- (418 , happyReduce_418),- (419 , happyReduce_419),- (420 , happyReduce_420),- (421 , happyReduce_421),- (422 , happyReduce_422),- (423 , happyReduce_423),- (424 , happyReduce_424),- (425 , happyReduce_425),- (426 , happyReduce_426),- (427 , happyReduce_427),- (428 , happyReduce_428),- (429 , happyReduce_429),- (430 , happyReduce_430),- (431 , happyReduce_431),- (432 , happyReduce_432),- (433 , happyReduce_433),- (434 , happyReduce_434),- (435 , happyReduce_435),- (436 , happyReduce_436),- (437 , happyReduce_437),- (438 , happyReduce_438),- (439 , happyReduce_439),- (440 , happyReduce_440),- (441 , happyReduce_441),- (442 , happyReduce_442),- (443 , happyReduce_443),- (444 , happyReduce_444),- (445 , happyReduce_445),- (446 , happyReduce_446),- (447 , happyReduce_447),- (448 , happyReduce_448),- (449 , happyReduce_449),- (450 , happyReduce_450),- (451 , happyReduce_451),- (452 , happyReduce_452),- (453 , happyReduce_453),- (454 , happyReduce_454),- (455 , happyReduce_455),- (456 , happyReduce_456),- (457 , happyReduce_457),- (458 , happyReduce_458),- (459 , happyReduce_459),- (460 , happyReduce_460),- (461 , happyReduce_461),- (462 , happyReduce_462),- (463 , happyReduce_463),- (464 , happyReduce_464),- (465 , happyReduce_465),- (466 , happyReduce_466),- (467 , happyReduce_467),- (468 , happyReduce_468),- (469 , happyReduce_469),- (470 , happyReduce_470),- (471 , happyReduce_471),- (472 , happyReduce_472),- (473 , happyReduce_473),- (474 , happyReduce_474),- (475 , happyReduce_475),- (476 , happyReduce_476),- (477 , happyReduce_477),- (478 , happyReduce_478),- (479 , happyReduce_479),- (480 , happyReduce_480),- (481 , happyReduce_481),- (482 , happyReduce_482),- (483 , happyReduce_483),- (484 , happyReduce_484),- (485 , happyReduce_485),- (486 , happyReduce_486),- (487 , happyReduce_487),- (488 , happyReduce_488),- (489 , happyReduce_489),- (490 , happyReduce_490),- (491 , happyReduce_491),- (492 , happyReduce_492),- (493 , happyReduce_493),- (494 , happyReduce_494),- (495 , happyReduce_495),- (496 , happyReduce_496),- (497 , happyReduce_497),- (498 , happyReduce_498),- (499 , happyReduce_499),- (500 , happyReduce_500),- (501 , happyReduce_501),- (502 , happyReduce_502),- (503 , happyReduce_503),- (504 , happyReduce_504),- (505 , happyReduce_505),- (506 , happyReduce_506),- (507 , happyReduce_507),- (508 , happyReduce_508),- (509 , happyReduce_509),- (510 , happyReduce_510),- (511 , happyReduce_511),- (512 , happyReduce_512),- (513 , happyReduce_513),- (514 , happyReduce_514),- (515 , happyReduce_515),- (516 , happyReduce_516),- (517 , happyReduce_517),- (518 , happyReduce_518),- (519 , happyReduce_519),- (520 , happyReduce_520),- (521 , happyReduce_521),- (522 , happyReduce_522),- (523 , happyReduce_523),- (524 , happyReduce_524),- (525 , happyReduce_525),- (526 , happyReduce_526),- (527 , happyReduce_527),- (528 , happyReduce_528),- (529 , happyReduce_529),- (530 , happyReduce_530),- (531 , happyReduce_531),- (532 , happyReduce_532),- (533 , happyReduce_533),- (534 , happyReduce_534),- (535 , happyReduce_535),- (536 , happyReduce_536),- (537 , happyReduce_537),- (538 , happyReduce_538),- (539 , happyReduce_539),- (540 , happyReduce_540),- (541 , happyReduce_541),- (542 , happyReduce_542),- (543 , happyReduce_543),- (544 , happyReduce_544),- (545 , happyReduce_545),- (546 , happyReduce_546),- (547 , happyReduce_547),- (548 , happyReduce_548),- (549 , happyReduce_549),- (550 , happyReduce_550),- (551 , happyReduce_551),- (552 , happyReduce_552),- (553 , happyReduce_553),- (554 , happyReduce_554),- (555 , happyReduce_555),- (556 , happyReduce_556),- (557 , happyReduce_557),- (558 , happyReduce_558),- (559 , happyReduce_559),- (560 , happyReduce_560),- (561 , happyReduce_561),- (562 , happyReduce_562),- (563 , happyReduce_563),- (564 , happyReduce_564),- (565 , happyReduce_565),- (566 , happyReduce_566),- (567 , happyReduce_567),- (568 , happyReduce_568),- (569 , happyReduce_569),- (570 , happyReduce_570),- (571 , happyReduce_571),- (572 , happyReduce_572),- (573 , happyReduce_573),- (574 , happyReduce_574),- (575 , happyReduce_575),- (576 , happyReduce_576),- (577 , happyReduce_577),- (578 , happyReduce_578),- (579 , happyReduce_579),- (580 , happyReduce_580),- (581 , happyReduce_581),- (582 , happyReduce_582),- (583 , happyReduce_583),- (584 , happyReduce_584),- (585 , happyReduce_585),- (586 , happyReduce_586),- (587 , happyReduce_587),- (588 , happyReduce_588),- (589 , happyReduce_589),- (590 , happyReduce_590),- (591 , happyReduce_591),- (592 , happyReduce_592),- (593 , happyReduce_593),- (594 , happyReduce_594),- (595 , happyReduce_595),- (596 , happyReduce_596),- (597 , happyReduce_597),- (598 , happyReduce_598),- (599 , happyReduce_599),- (600 , happyReduce_600),- (601 , happyReduce_601),- (602 , happyReduce_602),- (603 , happyReduce_603),- (604 , happyReduce_604),- (605 , happyReduce_605),- (606 , happyReduce_606),- (607 , happyReduce_607),- (608 , happyReduce_608),- (609 , happyReduce_609),- (610 , happyReduce_610),- (611 , happyReduce_611),- (612 , happyReduce_612),- (613 , happyReduce_613),- (614 , happyReduce_614),- (615 , happyReduce_615),- (616 , happyReduce_616),- (617 , happyReduce_617),- (618 , happyReduce_618),- (619 , happyReduce_619),- (620 , happyReduce_620),- (621 , happyReduce_621),- (622 , happyReduce_622),- (623 , happyReduce_623),- (624 , happyReduce_624),- (625 , happyReduce_625),- (626 , happyReduce_626),- (627 , happyReduce_627),- (628 , happyReduce_628),- (629 , happyReduce_629),- (630 , happyReduce_630),- (631 , happyReduce_631),- (632 , happyReduce_632),- (633 , happyReduce_633),- (634 , happyReduce_634),- (635 , happyReduce_635),- (636 , happyReduce_636),- (637 , happyReduce_637),- (638 , happyReduce_638),- (639 , happyReduce_639),- (640 , happyReduce_640),- (641 , happyReduce_641),- (642 , happyReduce_642),- (643 , happyReduce_643),- (644 , happyReduce_644),- (645 , happyReduce_645),- (646 , happyReduce_646),- (647 , happyReduce_647),- (648 , happyReduce_648),- (649 , happyReduce_649),- (650 , happyReduce_650),- (651 , happyReduce_651),- (652 , happyReduce_652),- (653 , happyReduce_653),- (654 , happyReduce_654),- (655 , happyReduce_655),- (656 , happyReduce_656),- (657 , happyReduce_657),- (658 , happyReduce_658),- (659 , happyReduce_659),- (660 , happyReduce_660),- (661 , happyReduce_661),- (662 , happyReduce_662),- (663 , happyReduce_663),- (664 , happyReduce_664),- (665 , happyReduce_665),- (666 , happyReduce_666),- (667 , happyReduce_667),- (668 , happyReduce_668),- (669 , happyReduce_669),- (670 , happyReduce_670),- (671 , happyReduce_671),- (672 , happyReduce_672),- (673 , happyReduce_673),- (674 , happyReduce_674),- (675 , happyReduce_675),- (676 , happyReduce_676),- (677 , happyReduce_677),- (678 , happyReduce_678),- (679 , happyReduce_679),- (680 , happyReduce_680),- (681 , happyReduce_681),- (682 , happyReduce_682),- (683 , happyReduce_683),- (684 , happyReduce_684),- (685 , happyReduce_685),- (686 , happyReduce_686),- (687 , happyReduce_687),- (688 , happyReduce_688),- (689 , happyReduce_689),- (690 , happyReduce_690),- (691 , happyReduce_691),- (692 , happyReduce_692),- (693 , happyReduce_693),- (694 , happyReduce_694),- (695 , happyReduce_695),- (696 , happyReduce_696),- (697 , happyReduce_697),- (698 , happyReduce_698),- (699 , happyReduce_699),- (700 , happyReduce_700),- (701 , happyReduce_701),- (702 , happyReduce_702),- (703 , happyReduce_703),- (704 , happyReduce_704),- (705 , happyReduce_705),- (706 , happyReduce_706),- (707 , happyReduce_707),- (708 , happyReduce_708),- (709 , happyReduce_709),- (710 , happyReduce_710),- (711 , happyReduce_711),- (712 , happyReduce_712),- (713 , happyReduce_713),- (714 , happyReduce_714),- (715 , happyReduce_715),- (716 , happyReduce_716),- (717 , happyReduce_717),- (718 , happyReduce_718),- (719 , happyReduce_719),- (720 , happyReduce_720),- (721 , happyReduce_721),- (722 , happyReduce_722),- (723 , happyReduce_723),- (724 , happyReduce_724),- (725 , happyReduce_725),- (726 , happyReduce_726),- (727 , happyReduce_727),- (728 , happyReduce_728),- (729 , happyReduce_729),- (730 , happyReduce_730),- (731 , happyReduce_731),- (732 , happyReduce_732),- (733 , happyReduce_733),- (734 , happyReduce_734),- (735 , happyReduce_735),- (736 , happyReduce_736),- (737 , happyReduce_737),- (738 , happyReduce_738),- (739 , happyReduce_739),- (740 , happyReduce_740),- (741 , happyReduce_741),- (742 , happyReduce_742),- (743 , happyReduce_743),- (744 , happyReduce_744),- (745 , happyReduce_745),- (746 , happyReduce_746),- (747 , happyReduce_747),- (748 , happyReduce_748),- (749 , happyReduce_749),- (750 , happyReduce_750),- (751 , happyReduce_751),- (752 , happyReduce_752),- (753 , happyReduce_753),- (754 , happyReduce_754),- (755 , happyReduce_755),- (756 , happyReduce_756),- (757 , happyReduce_757),- (758 , happyReduce_758),- (759 , happyReduce_759),- (760 , happyReduce_760),- (761 , happyReduce_761),- (762 , happyReduce_762),- (763 , happyReduce_763),- (764 , happyReduce_764),- (765 , happyReduce_765),- (766 , happyReduce_766),- (767 , happyReduce_767),- (768 , happyReduce_768),- (769 , happyReduce_769),- (770 , happyReduce_770),- (771 , happyReduce_771),- (772 , happyReduce_772),- (773 , happyReduce_773),- (774 , happyReduce_774),- (775 , happyReduce_775),- (776 , happyReduce_776),- (777 , happyReduce_777),- (778 , happyReduce_778),- (779 , happyReduce_779),- (780 , happyReduce_780),- (781 , happyReduce_781),- (782 , happyReduce_782),- (783 , happyReduce_783),- (784 , happyReduce_784),- (785 , happyReduce_785),- (786 , happyReduce_786),- (787 , happyReduce_787),- (788 , happyReduce_788),- (789 , happyReduce_789),- (790 , happyReduce_790),- (791 , happyReduce_791),- (792 , happyReduce_792),- (793 , happyReduce_793),- (794 , happyReduce_794),- (795 , happyReduce_795),- (796 , happyReduce_796),- (797 , happyReduce_797),- (798 , happyReduce_798),- (799 , happyReduce_799),- (800 , happyReduce_800),- (801 , happyReduce_801),- (802 , happyReduce_802),- (803 , happyReduce_803),- (804 , happyReduce_804),- (805 , happyReduce_805),- (806 , happyReduce_806),- (807 , happyReduce_807),- (808 , happyReduce_808),- (809 , happyReduce_809),- (810 , happyReduce_810),- (811 , happyReduce_811),- (812 , happyReduce_812),- (813 , happyReduce_813),- (814 , happyReduce_814),- (815 , happyReduce_815)- ]--happy_n_terms = 149 :: Prelude.Int-happy_n_nonterms = 307 :: Prelude.Int--happyReduce_13 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_13 = happySpecReduce_1 0# happyReduction_13-happyReduction_13 happy_x_1- = case happyOut300 happy_x_1 of { (HappyWrap300 happy_var_1) -> - happyIn16- (happy_var_1- )}--happyReduce_14 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_14 = happySpecReduce_1 0# happyReduction_14-happyReduction_14 happy_x_1- = case happyOut271 happy_x_1 of { (HappyWrap271 happy_var_1) -> - happyIn16- (happy_var_1- )}--happyReduce_15 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_15 = happySpecReduce_1 0# happyReduction_15-happyReduction_15 happy_x_1- = case happyOut294 happy_x_1 of { (HappyWrap294 happy_var_1) -> - happyIn16- (happy_var_1- )}--happyReduce_16 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_16 = happySpecReduce_1 0# happyReduction_16-happyReduction_16 happy_x_1- = case happyOut278 happy_x_1 of { (HappyWrap278 happy_var_1) -> - happyIn16- (happy_var_1- )}--happyReduce_17 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_17 = happyMonadReduce 3# 0# happyReduction_17-happyReduction_17 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( amsrn (sLL happy_var_1 happy_var_3 $ getRdrName unrestrictedFunTyCon)- (NameAnn NameParens (glAA happy_var_1) (glAA happy_var_2) (glAA happy_var_3) []))}}})- ) (\r -> happyReturn (happyIn16 r))--happyReduce_18 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_18 = happyMonadReduce 1# 0# happyReduction_18-happyReduction_18 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - ( amsrn (sLL happy_var_1 happy_var_1 $ getRdrName unrestrictedFunTyCon)- (NameAnnRArrow (glAA happy_var_1) []))})- ) (\r -> happyReturn (happyIn16 r))--happyReduce_19 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_19 = happySpecReduce_3 1# happyReduction_19-happyReduction_19 happy_x_3- happy_x_2- happy_x_1- = case happyOut18 happy_x_2 of { (HappyWrap18 happy_var_2) -> - happyIn17- (fromOL happy_var_2- )}--happyReduce_20 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_20 = happySpecReduce_3 1# happyReduction_20-happyReduction_20 happy_x_3- happy_x_2- happy_x_1- = case happyOut18 happy_x_2 of { (HappyWrap18 happy_var_2) -> - happyIn17- (fromOL happy_var_2- )}--happyReduce_21 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_21 = happySpecReduce_3 2# happyReduction_21-happyReduction_21 happy_x_3- happy_x_2- happy_x_1- = case happyOut18 happy_x_1 of { (HappyWrap18 happy_var_1) -> - case happyOut19 happy_x_3 of { (HappyWrap19 happy_var_3) -> - happyIn18- (happy_var_1 `appOL` unitOL happy_var_3- )}}--happyReduce_22 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_22 = happySpecReduce_2 2# happyReduction_22-happyReduction_22 happy_x_2- happy_x_1- = case happyOut18 happy_x_1 of { (HappyWrap18 happy_var_1) -> - happyIn18- (happy_var_1- )}--happyReduce_23 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_23 = happySpecReduce_1 2# happyReduction_23-happyReduction_23 happy_x_1- = case happyOut19 happy_x_1 of { (HappyWrap19 happy_var_1) -> - happyIn18- (unitOL happy_var_1- )}--happyReduce_24 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_24 = happyReduce 4# 3# happyReduction_24-happyReduction_24 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut24 happy_x_2 of { (HappyWrap24 happy_var_2) -> - case happyOut31 happy_x_4 of { (HappyWrap31 happy_var_4) -> - happyIn19- (sL1 happy_var_1 $ HsUnit { hsunitName = happy_var_2- , hsunitBody = fromOL happy_var_4 }- ) `HappyStk` happyRest}}}--happyReduce_25 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_25 = happySpecReduce_1 4# happyReduction_25-happyReduction_25 happy_x_1- = case happyOut24 happy_x_1 of { (HappyWrap24 happy_var_1) -> - happyIn20- (sL1 happy_var_1 $ HsUnitId happy_var_1 []- )}--happyReduce_26 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_26 = happyReduce 4# 4# happyReduction_26-happyReduction_26 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut24 happy_x_1 of { (HappyWrap24 happy_var_1) -> - case happyOut21 happy_x_3 of { (HappyWrap21 happy_var_3) -> - case happyOutTok happy_x_4 of { happy_var_4 -> - happyIn20- (sLL happy_var_1 happy_var_4 $ HsUnitId happy_var_1 (fromOL happy_var_3)- ) `HappyStk` happyRest}}}--happyReduce_27 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_27 = happySpecReduce_3 5# happyReduction_27-happyReduction_27 happy_x_3- happy_x_2- happy_x_1- = case happyOut21 happy_x_1 of { (HappyWrap21 happy_var_1) -> - case happyOut22 happy_x_3 of { (HappyWrap22 happy_var_3) -> - happyIn21- (happy_var_1 `appOL` unitOL happy_var_3- )}}--happyReduce_28 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_28 = happySpecReduce_2 5# happyReduction_28-happyReduction_28 happy_x_2- happy_x_1- = case happyOut21 happy_x_1 of { (HappyWrap21 happy_var_1) -> - happyIn21- (happy_var_1- )}--happyReduce_29 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_29 = happySpecReduce_1 5# happyReduction_29-happyReduction_29 happy_x_1- = case happyOut22 happy_x_1 of { (HappyWrap22 happy_var_1) -> - happyIn21- (unitOL happy_var_1- )}--happyReduce_30 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_30 = happySpecReduce_3 6# happyReduction_30-happyReduction_30 happy_x_3- happy_x_2- happy_x_1- = case happyOut317 happy_x_1 of { (HappyWrap317 happy_var_1) -> - case happyOut23 happy_x_3 of { (HappyWrap23 happy_var_3) -> - happyIn22- (sLL (reLoc happy_var_1) happy_var_3 $ (reLoc happy_var_1, happy_var_3)- )}}--happyReduce_31 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_31 = happyReduce 4# 6# happyReduction_31-happyReduction_31 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut317 happy_x_1 of { (HappyWrap317 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut317 happy_x_3 of { (HappyWrap317 happy_var_3) -> - case happyOutTok happy_x_4 of { happy_var_4 -> - happyIn22- (sLL (reLoc happy_var_1) happy_var_4 $ (reLoc happy_var_1, sLL happy_var_2 happy_var_4 $ HsModuleVar (reLoc happy_var_3))- ) `HappyStk` happyRest}}}}--happyReduce_32 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_32 = happySpecReduce_3 7# happyReduction_32-happyReduction_32 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut317 happy_x_2 of { (HappyWrap317 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn23- (sLL happy_var_1 happy_var_3 $ HsModuleVar (reLoc happy_var_2)- )}}}--happyReduce_33 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_33 = happySpecReduce_3 7# happyReduction_33-happyReduction_33 happy_x_3- happy_x_2- happy_x_1- = case happyOut20 happy_x_1 of { (HappyWrap20 happy_var_1) -> - case happyOut317 happy_x_3 of { (HappyWrap317 happy_var_3) -> - happyIn23- (sLL happy_var_1 (reLoc happy_var_3) $ HsModuleId happy_var_1 (reLoc happy_var_3)- )}}--happyReduce_34 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_34 = happySpecReduce_1 8# happyReduction_34-happyReduction_34 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn24- (sL1 happy_var_1 $ PackageName (getSTRING happy_var_1)- )}--happyReduce_35 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_35 = happySpecReduce_1 8# happyReduction_35-happyReduction_35 happy_x_1- = case happyOut27 happy_x_1 of { (HappyWrap27 happy_var_1) -> - happyIn24- (sL1 happy_var_1 $ PackageName (unLoc happy_var_1)- )}--happyReduce_36 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_36 = happySpecReduce_1 9# happyReduction_36-happyReduction_36 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn25- (sL1 happy_var_1 $ getVARID happy_var_1- )}--happyReduce_37 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_37 = happySpecReduce_1 9# happyReduction_37-happyReduction_37 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn25- (sL1 happy_var_1 $ getCONID happy_var_1- )}--happyReduce_38 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_38 = happySpecReduce_1 9# happyReduction_38-happyReduction_38 happy_x_1- = case happyOut309 happy_x_1 of { (HappyWrap309 happy_var_1) -> - happyIn25- (happy_var_1- )}--happyReduce_39 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_39 = happySpecReduce_1 10# happyReduction_39-happyReduction_39 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn26- ([mj AnnMinus happy_var_1 ]- )}--happyReduce_40 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_40 = happySpecReduce_1 10# happyReduction_40-happyReduction_40 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn26- ([mj AnnMinus happy_var_1 ]- )}--happyReduce_41 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_41 = happyMonadReduce 1# 10# happyReduction_41-happyReduction_41 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - ( if (getVARSYM happy_var_1 == fsLit "-")- then return [mj AnnMinus happy_var_1]- else do { addError $ PsError PsErrExpectedHyphen [] (getLoc happy_var_1)- ; return [] })})- ) (\r -> happyReturn (happyIn26 r))--happyReduce_42 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_42 = happySpecReduce_1 11# happyReduction_42-happyReduction_42 happy_x_1- = case happyOut25 happy_x_1 of { (HappyWrap25 happy_var_1) -> - happyIn27- (happy_var_1- )}--happyReduce_43 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_43 = happySpecReduce_3 11# happyReduction_43-happyReduction_43 happy_x_3- happy_x_2- happy_x_1- = case happyOut25 happy_x_1 of { (HappyWrap25 happy_var_1) -> - case happyOut27 happy_x_3 of { (HappyWrap27 happy_var_3) -> - happyIn27- (sLL happy_var_1 happy_var_3 $ appendFS (unLoc happy_var_1) (consFS '-' (unLoc happy_var_3))- )}}--happyReduce_44 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_44 = happySpecReduce_0 12# happyReduction_44-happyReduction_44 = happyIn28- (Nothing- )--happyReduce_45 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_45 = happySpecReduce_3 12# happyReduction_45-happyReduction_45 happy_x_3- happy_x_2- happy_x_1- = case happyOut29 happy_x_2 of { (HappyWrap29 happy_var_2) -> - happyIn28- (Just (fromOL happy_var_2)- )}--happyReduce_46 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_46 = happySpecReduce_3 13# happyReduction_46-happyReduction_46 happy_x_3- happy_x_2- happy_x_1- = case happyOut29 happy_x_1 of { (HappyWrap29 happy_var_1) -> - case happyOut30 happy_x_3 of { (HappyWrap30 happy_var_3) -> - happyIn29- (happy_var_1 `appOL` unitOL happy_var_3- )}}--happyReduce_47 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_47 = happySpecReduce_2 13# happyReduction_47-happyReduction_47 happy_x_2- happy_x_1- = case happyOut29 happy_x_1 of { (HappyWrap29 happy_var_1) -> - happyIn29- (happy_var_1- )}--happyReduce_48 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_48 = happySpecReduce_1 13# happyReduction_48-happyReduction_48 happy_x_1- = case happyOut30 happy_x_1 of { (HappyWrap30 happy_var_1) -> - happyIn29- (unitOL happy_var_1- )}--happyReduce_49 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_49 = happySpecReduce_3 14# happyReduction_49-happyReduction_49 happy_x_3- happy_x_2- happy_x_1- = case happyOut317 happy_x_1 of { (HappyWrap317 happy_var_1) -> - case happyOut317 happy_x_3 of { (HappyWrap317 happy_var_3) -> - happyIn30- (sLL (reLoc happy_var_1) (reLoc happy_var_3) $ Renaming (reLoc happy_var_1) (Just (reLoc happy_var_3))- )}}--happyReduce_50 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_50 = happySpecReduce_1 14# happyReduction_50-happyReduction_50 happy_x_1- = case happyOut317 happy_x_1 of { (HappyWrap317 happy_var_1) -> - happyIn30- (sL1 (reLoc happy_var_1) $ Renaming (reLoc happy_var_1) Nothing- )}--happyReduce_51 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_51 = happySpecReduce_3 15# happyReduction_51-happyReduction_51 happy_x_3- happy_x_2- happy_x_1- = case happyOut32 happy_x_2 of { (HappyWrap32 happy_var_2) -> - happyIn31- (happy_var_2- )}--happyReduce_52 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_52 = happySpecReduce_3 15# happyReduction_52-happyReduction_52 happy_x_3- happy_x_2- happy_x_1- = case happyOut32 happy_x_2 of { (HappyWrap32 happy_var_2) -> - happyIn31- (happy_var_2- )}--happyReduce_53 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_53 = happySpecReduce_3 16# happyReduction_53-happyReduction_53 happy_x_3- happy_x_2- happy_x_1- = case happyOut32 happy_x_1 of { (HappyWrap32 happy_var_1) -> - case happyOut33 happy_x_3 of { (HappyWrap33 happy_var_3) -> - happyIn32- (happy_var_1 `appOL` unitOL happy_var_3- )}}--happyReduce_54 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_54 = happySpecReduce_2 16# happyReduction_54-happyReduction_54 happy_x_2- happy_x_1- = case happyOut32 happy_x_1 of { (HappyWrap32 happy_var_1) -> - happyIn32- (happy_var_1- )}--happyReduce_55 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_55 = happySpecReduce_1 16# happyReduction_55-happyReduction_55 happy_x_1- = case happyOut33 happy_x_1 of { (HappyWrap33 happy_var_1) -> - happyIn32- (unitOL happy_var_1- )}--happyReduce_56 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_56 = happyReduce 7# 17# happyReduction_56-happyReduction_56 (happy_x_7 `HappyStk`- happy_x_6 `HappyStk`- happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut63 happy_x_2 of { (HappyWrap63 happy_var_2) -> - case happyOut317 happy_x_3 of { (HappyWrap317 happy_var_3) -> - case happyOut38 happy_x_4 of { (HappyWrap38 happy_var_4) -> - case happyOut48 happy_x_5 of { (HappyWrap48 happy_var_5) -> - case happyOut39 happy_x_7 of { (HappyWrap39 happy_var_7) -> - happyIn33- (sL1 happy_var_1 $ DeclD- (case snd happy_var_2 of- NotBoot -> HsSrcFile- IsBoot -> HsBootFile)- (reLoc happy_var_3)- (Just $ sL1 happy_var_1 (HsModule noAnn (thdOf3 happy_var_7) (Just happy_var_3) happy_var_5 (fst $ sndOf3 happy_var_7) (snd $ sndOf3 happy_var_7) happy_var_4 Nothing))- ) `HappyStk` happyRest}}}}}}--happyReduce_57 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_57 = happyReduce 6# 17# happyReduction_57-happyReduction_57 (happy_x_6 `HappyStk`- happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut317 happy_x_2 of { (HappyWrap317 happy_var_2) -> - case happyOut38 happy_x_3 of { (HappyWrap38 happy_var_3) -> - case happyOut48 happy_x_4 of { (HappyWrap48 happy_var_4) -> - case happyOut39 happy_x_6 of { (HappyWrap39 happy_var_6) -> - happyIn33- (sL1 happy_var_1 $ DeclD- HsigFile- (reLoc happy_var_2)- (Just $ sL1 happy_var_1 (HsModule noAnn (thdOf3 happy_var_6) (Just happy_var_2) happy_var_4 (fst $ sndOf3 happy_var_6) (snd $ sndOf3 happy_var_6) happy_var_3 Nothing))- ) `HappyStk` happyRest}}}}}--happyReduce_58 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_58 = happySpecReduce_3 17# happyReduction_58-happyReduction_58 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut63 happy_x_2 of { (HappyWrap63 happy_var_2) -> - case happyOut317 happy_x_3 of { (HappyWrap317 happy_var_3) -> - happyIn33- (sL1 happy_var_1 $ DeclD (case snd happy_var_2 of- NotBoot -> HsSrcFile- IsBoot -> HsBootFile) (reLoc happy_var_3) Nothing- )}}}--happyReduce_59 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_59 = happySpecReduce_2 17# happyReduction_59-happyReduction_59 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut317 happy_x_2 of { (HappyWrap317 happy_var_2) -> - happyIn33- (sL1 happy_var_1 $ DeclD HsigFile (reLoc happy_var_2) Nothing- )}}--happyReduce_60 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_60 = happySpecReduce_3 17# happyReduction_60-happyReduction_60 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut20 happy_x_2 of { (HappyWrap20 happy_var_2) -> - case happyOut28 happy_x_3 of { (HappyWrap28 happy_var_3) -> - happyIn33- (sL1 happy_var_1 $ IncludeD (IncludeDecl { idUnitId = happy_var_2- , idModRenaming = happy_var_3- , idSignatureInclude = False })- )}}}--happyReduce_61 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_61 = happySpecReduce_3 17# happyReduction_61-happyReduction_61 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut20 happy_x_3 of { (HappyWrap20 happy_var_3) -> - happyIn33- (sL1 happy_var_1 $ IncludeD (IncludeDecl { idUnitId = happy_var_3- , idModRenaming = Nothing- , idSignatureInclude = True })- )}}--happyReduce_62 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_62 = happyMonadReduce 6# 18# happyReduction_62-happyReduction_62 (happy_x_6 `HappyStk`- happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut317 happy_x_2 of { (HappyWrap317 happy_var_2) -> - case happyOut38 happy_x_3 of { (HappyWrap38 happy_var_3) -> - case happyOut48 happy_x_4 of { (HappyWrap48 happy_var_4) -> - case happyOutTok happy_x_5 of { happy_var_5 -> - case happyOut39 happy_x_6 of { (HappyWrap39 happy_var_6) -> - ( fileSrcSpan >>= \ loc ->- acs (\cs-> (L loc (HsModule (EpAnn (spanAsAnchor loc) (AnnsModule [mj AnnSignature happy_var_1, mj AnnWhere happy_var_5] (fstOf3 happy_var_6)) cs)- (thdOf3 happy_var_6) (Just happy_var_2) happy_var_4 (fst $ sndOf3 happy_var_6)- (snd $ sndOf3 happy_var_6) happy_var_3 Nothing))- ))}}}}}})- ) (\r -> happyReturn (happyIn34 r))--happyReduce_63 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_63 = happyMonadReduce 6# 19# happyReduction_63-happyReduction_63 (happy_x_6 `HappyStk`- happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut317 happy_x_2 of { (HappyWrap317 happy_var_2) -> - case happyOut38 happy_x_3 of { (HappyWrap38 happy_var_3) -> - case happyOut48 happy_x_4 of { (HappyWrap48 happy_var_4) -> - case happyOutTok happy_x_5 of { happy_var_5 -> - case happyOut39 happy_x_6 of { (HappyWrap39 happy_var_6) -> - ( fileSrcSpan >>= \ loc ->- acsFinal (\cs -> (L loc (HsModule (EpAnn (spanAsAnchor loc) (AnnsModule [mj AnnModule happy_var_1, mj AnnWhere happy_var_5] (fstOf3 happy_var_6)) cs)- (thdOf3 happy_var_6) (Just happy_var_2) happy_var_4 (fst $ sndOf3 happy_var_6)- (snd $ sndOf3 happy_var_6) happy_var_3 Nothing)- )))}}}}}})- ) (\r -> happyReturn (happyIn35 r))--happyReduce_64 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_64 = happyMonadReduce 1# 19# happyReduction_64-happyReduction_64 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut40 happy_x_1 of { (HappyWrap40 happy_var_1) -> - ( fileSrcSpan >>= \ loc ->- acsFinal (\cs -> (L loc (HsModule (EpAnn (spanAsAnchor loc) (AnnsModule [] (fstOf3 happy_var_1)) cs)- (thdOf3 happy_var_1) Nothing Nothing- (fst $ sndOf3 happy_var_1) (snd $ sndOf3 happy_var_1) Nothing Nothing))))})- ) (\r -> happyReturn (happyIn35 r))--happyReduce_65 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_65 = happyMonadReduce 0# 20# happyReduction_65-happyReduction_65 (happyRest) tk- = happyThen ((( pushModuleContext))- ) (\r -> happyReturn (happyIn36 r))--happyReduce_66 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_66 = happyMonadReduce 0# 21# happyReduction_66-happyReduction_66 (happyRest) tk- = happyThen ((( pushModuleContext))- ) (\r -> happyReturn (happyIn37 r))--happyReduce_67 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_67 = happyMonadReduce 3# 22# happyReduction_67-happyReduction_67 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut143 happy_x_2 of { (HappyWrap143 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( fmap Just $ amsrp (sLL happy_var_1 happy_var_3 $ DeprecatedTxt (sL1 happy_var_1 $ getDEPRECATED_PRAGs happy_var_1) (snd $ unLoc happy_var_2))- (AnnPragma (mo happy_var_1) (mc happy_var_3) (fst $ unLoc happy_var_2)))}}})- ) (\r -> happyReturn (happyIn38 r))--happyReduce_68 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_68 = happyMonadReduce 3# 22# happyReduction_68-happyReduction_68 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut143 happy_x_2 of { (HappyWrap143 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( fmap Just $ amsrp (sLL happy_var_1 happy_var_3 $ WarningTxt (sL1 happy_var_1 $ getWARNING_PRAGs happy_var_1) (snd $ unLoc happy_var_2))- (AnnPragma (mo happy_var_1) (mc happy_var_3) (fst $ unLoc happy_var_2)))}}})- ) (\r -> happyReturn (happyIn38 r))--happyReduce_69 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_69 = happySpecReduce_0 22# happyReduction_69-happyReduction_69 = happyIn38- (Nothing- )--happyReduce_70 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_70 = happySpecReduce_3 23# happyReduction_70-happyReduction_70 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut41 happy_x_2 of { (HappyWrap41 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn39- ((AnnList Nothing (Just $ moc happy_var_1) (Just $ mcc happy_var_3) [] (fst happy_var_2)- , snd happy_var_2, ExplicitBraces)- )}}}--happyReduce_71 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_71 = happySpecReduce_3 23# happyReduction_71-happyReduction_71 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut41 happy_x_2 of { (HappyWrap41 happy_var_2) -> - happyIn39- ((AnnList Nothing Nothing Nothing [] (fst happy_var_2)- , snd happy_var_2, VirtualBraces (getVOCURLY happy_var_1))- )}}--happyReduce_72 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_72 = happySpecReduce_3 24# happyReduction_72-happyReduction_72 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut41 happy_x_2 of { (HappyWrap41 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn40- ((AnnList Nothing (Just $ moc happy_var_1) (Just $ mcc happy_var_3) [] (fst happy_var_2)- , snd happy_var_2, ExplicitBraces)- )}}}--happyReduce_73 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_73 = happySpecReduce_3 24# happyReduction_73-happyReduction_73 happy_x_3- happy_x_2- happy_x_1- = case happyOut41 happy_x_2 of { (HappyWrap41 happy_var_2) -> - happyIn40- ((AnnList Nothing Nothing Nothing [] [], snd happy_var_2, VirtualBraces leftmostColumn)- )}--happyReduce_74 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_74 = happySpecReduce_2 25# happyReduction_74-happyReduction_74 happy_x_2- happy_x_1- = case happyOut59 happy_x_1 of { (HappyWrap59 happy_var_1) -> - case happyOut42 happy_x_2 of { (HappyWrap42 happy_var_2) -> - happyIn41- ((reverse happy_var_1, happy_var_2)- )}}--happyReduce_75 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_75 = happySpecReduce_2 26# happyReduction_75-happyReduction_75 happy_x_2- happy_x_1- = case happyOut61 happy_x_1 of { (HappyWrap61 happy_var_1) -> - case happyOut76 happy_x_2 of { (HappyWrap76 happy_var_2) -> - happyIn42- ((reverse happy_var_1, cvTopDecls happy_var_2)- )}}--happyReduce_76 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_76 = happySpecReduce_2 26# happyReduction_76-happyReduction_76 happy_x_2- happy_x_1- = case happyOut61 happy_x_1 of { (HappyWrap61 happy_var_1) -> - case happyOut75 happy_x_2 of { (HappyWrap75 happy_var_2) -> - happyIn42- ((reverse happy_var_1, cvTopDecls happy_var_2)- )}}--happyReduce_77 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_77 = happySpecReduce_1 26# happyReduction_77-happyReduction_77 happy_x_1- = case happyOut60 happy_x_1 of { (HappyWrap60 happy_var_1) -> - happyIn42- ((reverse happy_var_1, [])- )}--happyReduce_78 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_78 = happyMonadReduce 6# 27# happyReduction_78-happyReduction_78 (happy_x_6 `HappyStk`- happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut317 happy_x_2 of { (HappyWrap317 happy_var_2) -> - case happyOut38 happy_x_3 of { (HappyWrap38 happy_var_3) -> - case happyOut48 happy_x_4 of { (HappyWrap48 happy_var_4) -> - case happyOutTok happy_x_5 of { happy_var_5 -> - case happyOut44 happy_x_6 of { (HappyWrap44 happy_var_6) -> - ( fileSrcSpan >>= \ loc ->- acs (\cs -> (L loc (HsModule (EpAnn (spanAsAnchor loc) (AnnsModule [mj AnnModule happy_var_1,mj AnnWhere happy_var_5] (AnnList Nothing Nothing Nothing [] [])) cs)- NoLayoutInfo (Just happy_var_2) happy_var_4 happy_var_6 [] happy_var_3 Nothing- ))))}}}}}})- ) (\r -> happyReturn (happyIn43 r))--happyReduce_79 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_79 = happyMonadReduce 6# 27# happyReduction_79-happyReduction_79 (happy_x_6 `HappyStk`- happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut317 happy_x_2 of { (HappyWrap317 happy_var_2) -> - case happyOut38 happy_x_3 of { (HappyWrap38 happy_var_3) -> - case happyOut48 happy_x_4 of { (HappyWrap48 happy_var_4) -> - case happyOutTok happy_x_5 of { happy_var_5 -> - case happyOut44 happy_x_6 of { (HappyWrap44 happy_var_6) -> - ( fileSrcSpan >>= \ loc ->- acs (\cs -> (L loc (HsModule (EpAnn (spanAsAnchor loc) (AnnsModule [mj AnnModule happy_var_1,mj AnnWhere happy_var_5] (AnnList Nothing Nothing Nothing [] [])) cs)- NoLayoutInfo (Just happy_var_2) happy_var_4 happy_var_6 [] happy_var_3 Nothing- ))))}}}}}})- ) (\r -> happyReturn (happyIn43 r))--happyReduce_80 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_80 = happyMonadReduce 1# 27# happyReduction_80-happyReduction_80 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut45 happy_x_1 of { (HappyWrap45 happy_var_1) -> - ( fileSrcSpan >>= \ loc ->- return (L loc (HsModule noAnn NoLayoutInfo Nothing Nothing happy_var_1 [] Nothing- Nothing)))})- ) (\r -> happyReturn (happyIn43 r))--happyReduce_81 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_81 = happySpecReduce_2 28# happyReduction_81-happyReduction_81 happy_x_2- happy_x_1- = case happyOut46 happy_x_2 of { (HappyWrap46 happy_var_2) -> - happyIn44- (happy_var_2- )}--happyReduce_82 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_82 = happySpecReduce_2 28# happyReduction_82-happyReduction_82 happy_x_2- happy_x_1- = case happyOut46 happy_x_2 of { (HappyWrap46 happy_var_2) -> - happyIn44- (happy_var_2- )}--happyReduce_83 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_83 = happySpecReduce_2 29# happyReduction_83-happyReduction_83 happy_x_2- happy_x_1- = case happyOut46 happy_x_2 of { (HappyWrap46 happy_var_2) -> - happyIn45- (happy_var_2- )}--happyReduce_84 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_84 = happySpecReduce_2 29# happyReduction_84-happyReduction_84 happy_x_2- happy_x_1- = case happyOut46 happy_x_2 of { (HappyWrap46 happy_var_2) -> - happyIn45- (happy_var_2- )}--happyReduce_85 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_85 = happySpecReduce_2 30# happyReduction_85-happyReduction_85 happy_x_2- happy_x_1- = case happyOut47 happy_x_2 of { (HappyWrap47 happy_var_2) -> - happyIn46- (happy_var_2- )}--happyReduce_86 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_86 = happySpecReduce_1 31# happyReduction_86-happyReduction_86 happy_x_1- = case happyOut61 happy_x_1 of { (HappyWrap61 happy_var_1) -> - happyIn47- (happy_var_1- )}--happyReduce_87 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_87 = happySpecReduce_1 31# happyReduction_87-happyReduction_87 happy_x_1- = case happyOut60 happy_x_1 of { (HappyWrap60 happy_var_1) -> - happyIn47- (happy_var_1- )}--happyReduce_88 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_88 = happyMonadReduce 3# 32# happyReduction_88-happyReduction_88 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut49 happy_x_2 of { (HappyWrap49 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( fmap Just $ amsrl (sLL happy_var_1 happy_var_3 (fromOL $ snd happy_var_2))- (AnnList Nothing (Just $ mop happy_var_1) (Just $ mcp happy_var_3) (fst happy_var_2) []))}}})- ) (\r -> happyReturn (happyIn48 r))--happyReduce_89 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_89 = happySpecReduce_0 32# happyReduction_89-happyReduction_89 = happyIn48- (Nothing- )--happyReduce_90 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_90 = happySpecReduce_1 33# happyReduction_90-happyReduction_90 happy_x_1- = case happyOut50 happy_x_1 of { (HappyWrap50 happy_var_1) -> - happyIn49- (([], happy_var_1)- )}--happyReduce_91 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_91 = happySpecReduce_0 33# happyReduction_91-happyReduction_91 = happyIn49- (([], nilOL)- )--happyReduce_92 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_92 = happyMonadReduce 2# 33# happyReduction_92-happyReduction_92 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut50 happy_x_1 of { (HappyWrap50 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( case happy_var_1 of- SnocOL hs t -> do- t' <- addTrailingCommaA t (gl happy_var_2)- return ([], snocOL hs t'))}})- ) (\r -> happyReturn (happyIn49 r))--happyReduce_93 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_93 = happySpecReduce_1 33# happyReduction_93-happyReduction_93 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn49- (([mj AnnComma happy_var_1], nilOL)- )}--happyReduce_94 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_94 = happyMonadReduce 3# 34# happyReduction_94-happyReduction_94 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut50 happy_x_1 of { (HappyWrap50 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut51 happy_x_3 of { (HappyWrap51 happy_var_3) -> - ( let ls = happy_var_1- in if isNilOL ls- then return (ls `appOL` happy_var_3)- else case ls of- SnocOL hs t -> do- t' <- addTrailingCommaA t (gl happy_var_2)- return (snocOL hs t' `appOL` happy_var_3))}}})- ) (\r -> happyReturn (happyIn50 r))--happyReduce_95 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_95 = happySpecReduce_1 34# happyReduction_95-happyReduction_95 happy_x_1- = case happyOut51 happy_x_1 of { (HappyWrap51 happy_var_1) -> - happyIn50- (happy_var_1- )}--happyReduce_96 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_96 = happyMonadReduce 2# 35# happyReduction_96-happyReduction_96 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut56 happy_x_1 of { (HappyWrap56 happy_var_1) -> - case happyOut52 happy_x_2 of { (HappyWrap52 happy_var_2) -> - ( mkModuleImpExp (fst $ unLoc happy_var_2) happy_var_1 (snd $ unLoc happy_var_2)- >>= \ie -> fmap (unitOL . reLocA) (return (sLL (reLoc happy_var_1) happy_var_2 ie)))}})- ) (\r -> happyReturn (happyIn51 r))--happyReduce_97 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_97 = happyMonadReduce 2# 35# happyReduction_97-happyReduction_97 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut317 happy_x_2 of { (HappyWrap317 happy_var_2) -> - ( fmap (unitOL . reLocA) (acs (\cs -> sLL happy_var_1 (reLoc happy_var_2) (IEModuleContents (EpAnn (glR happy_var_1) [mj AnnModule happy_var_1] cs) happy_var_2))))}})- ) (\r -> happyReturn (happyIn51 r))--happyReduce_98 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_98 = happySpecReduce_2 35# happyReduction_98-happyReduction_98 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut271 happy_x_2 of { (HappyWrap271 happy_var_2) -> - happyIn51- (unitOL (reLocA (sLL happy_var_1 (reLocN happy_var_2)- (IEVar noExtField (sLLa happy_var_1 (reLocN happy_var_2) (IEPattern (glAA happy_var_1) happy_var_2)))))- )}}--happyReduce_99 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_99 = happySpecReduce_0 36# happyReduction_99-happyReduction_99 = happyIn52- (sL0 ([],ImpExpAbs)- )--happyReduce_100 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_100 = happyMonadReduce 3# 36# happyReduction_100-happyReduction_100 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut53 happy_x_2 of { (HappyWrap53 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( mkImpExpSubSpec (reverse (snd happy_var_2))- >>= \(as,ie) -> return $ sLL happy_var_1 happy_var_3- (as ++ [mop happy_var_1,mcp happy_var_3] ++ fst happy_var_2, ie))}}})- ) (\r -> happyReturn (happyIn52 r))--happyReduce_101 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_101 = happySpecReduce_0 37# happyReduction_101-happyReduction_101 = happyIn53- (([],[])- )--happyReduce_102 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_102 = happySpecReduce_1 37# happyReduction_102-happyReduction_102 happy_x_1- = case happyOut54 happy_x_1 of { (HappyWrap54 happy_var_1) -> - happyIn53- (happy_var_1- )}--happyReduce_103 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_103 = happyMonadReduce 3# 38# happyReduction_103-happyReduction_103 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut54 happy_x_1 of { (HappyWrap54 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut55 happy_x_3 of { (HappyWrap55 happy_var_3) -> - ( case (snd happy_var_1) of- (l@(L la ImpExpQcWildcard):t) ->- do { l' <- addTrailingCommaA l (gl happy_var_2)- ; return ([mj AnnDotdot (reLoc l),- mj AnnComma happy_var_2]- ,(snd (unLoc happy_var_3) : l' : t)) }- (l:t) ->- do { l' <- addTrailingCommaA l (gl happy_var_2)- ; return (fst happy_var_1 ++ fst (unLoc happy_var_3)- , snd (unLoc happy_var_3) : l' : t)})}}})- ) (\r -> happyReturn (happyIn54 r))--happyReduce_104 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_104 = happySpecReduce_1 38# happyReduction_104-happyReduction_104 happy_x_1- = case happyOut55 happy_x_1 of { (HappyWrap55 happy_var_1) -> - happyIn54- ((fst (unLoc happy_var_1),[snd (unLoc happy_var_1)])- )}--happyReduce_105 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_105 = happySpecReduce_1 39# happyReduction_105-happyReduction_105 happy_x_1- = case happyOut56 happy_x_1 of { (HappyWrap56 happy_var_1) -> - happyIn55- (sL1A happy_var_1 ([],happy_var_1)- )}--happyReduce_106 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_106 = happySpecReduce_1 39# happyReduction_106-happyReduction_106 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn55- (sL1 happy_var_1 ([mj AnnDotdot happy_var_1], sL1a happy_var_1 ImpExpQcWildcard)- )}--happyReduce_107 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_107 = happySpecReduce_1 40# happyReduction_107-happyReduction_107 happy_x_1- = case happyOut57 happy_x_1 of { (HappyWrap57 happy_var_1) -> - happyIn56- (reLocA $ sL1N happy_var_1 (ImpExpQcName happy_var_1)- )}--happyReduce_108 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_108 = happyMonadReduce 2# 40# happyReduction_108-happyReduction_108 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut281 happy_x_2 of { (HappyWrap281 happy_var_2) -> - ( do { n <- mkTypeImpExp happy_var_2- ; return $ sLLa happy_var_1 (reLocN happy_var_2) (ImpExpQcType (glAA happy_var_1) n) })}})- ) (\r -> happyReturn (happyIn56 r))--happyReduce_109 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_109 = happySpecReduce_1 41# happyReduction_109-happyReduction_109 happy_x_1- = case happyOut300 happy_x_1 of { (HappyWrap300 happy_var_1) -> - happyIn57- (happy_var_1- )}--happyReduce_110 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_110 = happySpecReduce_1 41# happyReduction_110-happyReduction_110 happy_x_1- = case happyOut282 happy_x_1 of { (HappyWrap282 happy_var_1) -> - happyIn57- (happy_var_1- )}--happyReduce_111 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_111 = happySpecReduce_2 42# happyReduction_111-happyReduction_111 happy_x_2- happy_x_1- = case happyOut58 happy_x_1 of { (HappyWrap58 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - happyIn58- (sLL happy_var_1 happy_var_2 $ if isZeroWidthSpan (gl happy_var_2) then (unLoc happy_var_1) else (AddSemiAnn (glAA happy_var_2) : (unLoc happy_var_1))- )}}--happyReduce_112 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_112 = happySpecReduce_1 42# happyReduction_112-happyReduction_112 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn58- (sL1 happy_var_1 $ msemi happy_var_1- )}--happyReduce_113 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_113 = happySpecReduce_2 43# happyReduction_113-happyReduction_113 happy_x_2- happy_x_1- = case happyOut59 happy_x_1 of { (HappyWrap59 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - happyIn59- (if isZeroWidthSpan (gl happy_var_2) then happy_var_1 else (AddSemiAnn (glAA happy_var_2) : happy_var_1)- )}}--happyReduce_114 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_114 = happySpecReduce_0 43# happyReduction_114-happyReduction_114 = happyIn59- ([]- )--happyReduce_115 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_115 = happySpecReduce_2 44# happyReduction_115-happyReduction_115 happy_x_2- happy_x_1- = case happyOut61 happy_x_1 of { (HappyWrap61 happy_var_1) -> - case happyOut62 happy_x_2 of { (HappyWrap62 happy_var_2) -> - happyIn60- (happy_var_2 : happy_var_1- )}}--happyReduce_116 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_116 = happyMonadReduce 3# 45# happyReduction_116-happyReduction_116 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut61 happy_x_1 of { (HappyWrap61 happy_var_1) -> - case happyOut62 happy_x_2 of { (HappyWrap62 happy_var_2) -> - case happyOut58 happy_x_3 of { (HappyWrap58 happy_var_3) -> - ( do { i <- amsAl happy_var_2 (comb2 (reLoc happy_var_2) happy_var_3) (reverse $ unLoc happy_var_3)- ; return (i : happy_var_1)})}}})- ) (\r -> happyReturn (happyIn61 r))--happyReduce_117 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_117 = happySpecReduce_0 45# happyReduction_117-happyReduction_117 = happyIn61- ([]- )--happyReduce_118 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_118 = happyMonadReduce 9# 46# happyReduction_118-happyReduction_118 (happy_x_9 `HappyStk`- happy_x_8 `HappyStk`- happy_x_7 `HappyStk`- happy_x_6 `HappyStk`- happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut63 happy_x_2 of { (HappyWrap63 happy_var_2) -> - case happyOut64 happy_x_3 of { (HappyWrap64 happy_var_3) -> - case happyOut66 happy_x_4 of { (HappyWrap66 happy_var_4) -> - case happyOut65 happy_x_5 of { (HappyWrap65 happy_var_5) -> - case happyOut317 happy_x_6 of { (HappyWrap317 happy_var_6) -> - case happyOut66 happy_x_7 of { (HappyWrap66 happy_var_7) -> - case happyOut67 happy_x_8 of { (HappyWrap67 happy_var_8) -> - case happyOut68 happy_x_9 of { (HappyWrap68 happy_var_9) -> - ( do {- ; let { ; mPreQual = unLoc happy_var_4- ; mPostQual = unLoc happy_var_7 }- ; checkImportDecl mPreQual mPostQual- ; let anns- = EpAnnImportDecl- { importDeclAnnImport = glAA happy_var_1- , importDeclAnnPragma = fst $ fst happy_var_2- , importDeclAnnSafe = fst happy_var_3- , importDeclAnnQualified = fst $ importDeclQualifiedStyle mPreQual mPostQual- , importDeclAnnPackage = fst happy_var_5- , importDeclAnnAs = fst happy_var_8- }- ; fmap reLocA $ acs (\cs -> L (comb5 happy_var_1 (reLoc happy_var_6) happy_var_7 (snd happy_var_8) happy_var_9) $- ImportDecl { ideclExt = EpAnn (glR happy_var_1) anns cs- , ideclSourceSrc = snd $ fst happy_var_2- , ideclName = happy_var_6, ideclPkgQual = snd happy_var_5- , ideclSource = snd happy_var_2, ideclSafe = snd happy_var_3- , ideclQualified = snd $ importDeclQualifiedStyle mPreQual mPostQual- , ideclImplicit = False- , ideclAs = unLoc (snd happy_var_8)- , ideclHiding = unLoc happy_var_9 })- })}}}}}}}}})- ) (\r -> happyReturn (happyIn62 r))--happyReduce_119 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_119 = happySpecReduce_2 47# happyReduction_119-happyReduction_119 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - happyIn63- (((Just (glAA happy_var_1,glAA happy_var_2),getSOURCE_PRAGs happy_var_1)- , IsBoot)- )}}--happyReduce_120 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_120 = happySpecReduce_0 47# happyReduction_120-happyReduction_120 = happyIn63- (((Nothing,NoSourceText),NotBoot)- )--happyReduce_121 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_121 = happySpecReduce_1 48# happyReduction_121-happyReduction_121 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn64- ((Just (glAA happy_var_1),True)- )}--happyReduce_122 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_122 = happySpecReduce_0 48# happyReduction_122-happyReduction_122 = happyIn64- ((Nothing, False)- )--happyReduce_123 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_123 = happyMonadReduce 1# 49# happyReduction_123-happyReduction_123 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - ( do { let { pkgFS = getSTRING happy_var_1 }- ; unless (looksLikePackageName (unpackFS pkgFS)) $- addError $ PsError (PsErrInvalidPackageName pkgFS) [] (getLoc happy_var_1)- ; return (Just (glAA happy_var_1), Just (StringLiteral (getSTRINGs happy_var_1) pkgFS Nothing)) })})- ) (\r -> happyReturn (happyIn65 r))--happyReduce_124 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_124 = happySpecReduce_0 49# happyReduction_124-happyReduction_124 = happyIn65- ((Nothing,Nothing)- )--happyReduce_125 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_125 = happySpecReduce_1 50# happyReduction_125-happyReduction_125 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn66- (sL1 happy_var_1 (Just (glAA happy_var_1))- )}--happyReduce_126 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_126 = happySpecReduce_0 50# happyReduction_126-happyReduction_126 = happyIn66- (noLoc Nothing- )--happyReduce_127 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_127 = happySpecReduce_2 51# happyReduction_127-happyReduction_127 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut317 happy_x_2 of { (HappyWrap317 happy_var_2) -> - happyIn67- ((Just (glAA happy_var_1)- ,sLL happy_var_1 (reLoc happy_var_2) (Just happy_var_2))- )}}--happyReduce_128 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_128 = happySpecReduce_0 51# happyReduction_128-happyReduction_128 = happyIn67- ((Nothing,noLoc Nothing)- )--happyReduce_129 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_129 = happyMonadReduce 1# 52# happyReduction_129-happyReduction_129 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut69 happy_x_1 of { (HappyWrap69 happy_var_1) -> - ( let (b, ie) = unLoc happy_var_1 in- checkImportSpec ie- >>= \checkedIe ->- return (L (gl happy_var_1) (Just (b, checkedIe))))})- ) (\r -> happyReturn (happyIn68 r))--happyReduce_130 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_130 = happySpecReduce_0 52# happyReduction_130-happyReduction_130 = happyIn68- (noLoc Nothing- )--happyReduce_131 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_131 = happyMonadReduce 3# 53# happyReduction_131-happyReduction_131 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut49 happy_x_2 of { (HappyWrap49 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( do { es <- amsrl (sLL happy_var_1 happy_var_3 $ fromOL $ snd happy_var_2)- (AnnList Nothing (Just $ mop happy_var_1) (Just $ mcp happy_var_3) (fst happy_var_2) [])- ; return $ sLL happy_var_1 happy_var_3 (False, es)})}}})- ) (\r -> happyReturn (happyIn69 r))--happyReduce_132 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_132 = happyMonadReduce 4# 53# happyReduction_132-happyReduction_132 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut49 happy_x_3 of { (HappyWrap49 happy_var_3) -> - case happyOutTok happy_x_4 of { happy_var_4 -> - ( do { es <- amsrl (sLL happy_var_1 happy_var_4 $ fromOL $ snd happy_var_3)- (AnnList Nothing (Just $ mop happy_var_2) (Just $ mcp happy_var_4) (mj AnnHiding happy_var_1:fst happy_var_3) [])- ; return $ sLL happy_var_1 happy_var_4 (True, es)})}}}})- ) (\r -> happyReturn (happyIn69 r))--happyReduce_133 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_133 = happySpecReduce_0 54# happyReduction_133-happyReduction_133 = happyIn70- (Nothing- )--happyReduce_134 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_134 = happySpecReduce_1 54# happyReduction_134-happyReduction_134 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn70- (Just (sL1 happy_var_1 (getINTEGERs happy_var_1,fromInteger (il_value (getINTEGER happy_var_1))))- )}--happyReduce_135 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_135 = happySpecReduce_1 55# happyReduction_135-happyReduction_135 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn71- (sL1 happy_var_1 InfixN- )}--happyReduce_136 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_136 = happySpecReduce_1 55# happyReduction_136-happyReduction_136 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn71- (sL1 happy_var_1 InfixL- )}--happyReduce_137 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_137 = happySpecReduce_1 55# happyReduction_137-happyReduction_137 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn71- (sL1 happy_var_1 InfixR- )}--happyReduce_138 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_138 = happyMonadReduce 3# 56# happyReduction_138-happyReduction_138 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut72 happy_x_1 of { (HappyWrap72 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut289 happy_x_3 of { (HappyWrap289 happy_var_3) -> - ( case (unLoc happy_var_1) of- SnocOL hs t -> do- t' <- addTrailingCommaN t (gl happy_var_2)- return (sLL happy_var_1 (reLocN happy_var_3) (snocOL hs t' `appOL` unitOL happy_var_3)))}}})- ) (\r -> happyReturn (happyIn72 r))--happyReduce_139 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_139 = happySpecReduce_1 56# happyReduction_139-happyReduction_139 happy_x_1- = case happyOut289 happy_x_1 of { (HappyWrap289 happy_var_1) -> - happyIn72- (sL1N happy_var_1 (unitOL happy_var_1)- )}--happyReduce_140 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_140 = happySpecReduce_2 57# happyReduction_140-happyReduction_140 happy_x_2- happy_x_1- = case happyOut74 happy_x_1 of { (HappyWrap74 happy_var_1) -> - case happyOut78 happy_x_2 of { (HappyWrap78 happy_var_2) -> - happyIn73- (happy_var_1 `snocOL` happy_var_2- )}}--happyReduce_141 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_141 = happyMonadReduce 3# 58# happyReduction_141-happyReduction_141 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut74 happy_x_1 of { (HappyWrap74 happy_var_1) -> - case happyOut78 happy_x_2 of { (HappyWrap78 happy_var_2) -> - case happyOut58 happy_x_3 of { (HappyWrap58 happy_var_3) -> - ( do { t <- amsAl happy_var_2 (comb2 (reLoc happy_var_2) happy_var_3) (reverse $ unLoc happy_var_3)- ; return (happy_var_1 `snocOL` t) })}}})- ) (\r -> happyReturn (happyIn74 r))--happyReduce_142 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_142 = happySpecReduce_0 58# happyReduction_142-happyReduction_142 = happyIn74- (nilOL- )--happyReduce_143 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_143 = happySpecReduce_2 59# happyReduction_143-happyReduction_143 happy_x_2- happy_x_1- = case happyOut76 happy_x_1 of { (HappyWrap76 happy_var_1) -> - case happyOut77 happy_x_2 of { (HappyWrap77 happy_var_2) -> - happyIn75- (happy_var_1 `snocOL` happy_var_2- )}}--happyReduce_144 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_144 = happyMonadReduce 3# 60# happyReduction_144-happyReduction_144 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut76 happy_x_1 of { (HappyWrap76 happy_var_1) -> - case happyOut77 happy_x_2 of { (HappyWrap77 happy_var_2) -> - case happyOut58 happy_x_3 of { (HappyWrap58 happy_var_3) -> - ( do { t <- amsAl happy_var_2 (comb2 (reLoc happy_var_2) happy_var_3) (reverse $ unLoc happy_var_3)- ; return (happy_var_1 `snocOL` t) })}}})- ) (\r -> happyReturn (happyIn76 r))--happyReduce_145 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_145 = happySpecReduce_0 60# happyReduction_145-happyReduction_145 = happyIn76- (nilOL- )--happyReduce_146 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_146 = happyMonadReduce 1# 61# happyReduction_146-happyReduction_146 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut78 happy_x_1 of { (HappyWrap78 happy_var_1) -> - ( commentsPA happy_var_1)})- ) (\r -> happyReturn (happyIn77 r))--happyReduce_147 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_147 = happySpecReduce_1 62# happyReduction_147-happyReduction_147 happy_x_1- = case happyOut79 happy_x_1 of { (HappyWrap79 happy_var_1) -> - happyIn78- (sL1 happy_var_1 (TyClD noExtField (unLoc happy_var_1))- )}--happyReduce_148 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_148 = happySpecReduce_1 62# happyReduction_148-happyReduction_148 happy_x_1- = case happyOut80 happy_x_1 of { (HappyWrap80 happy_var_1) -> - happyIn78- (sL1 happy_var_1 (TyClD noExtField (unLoc happy_var_1))- )}--happyReduce_149 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_149 = happySpecReduce_1 62# happyReduction_149-happyReduction_149 happy_x_1- = case happyOut81 happy_x_1 of { (HappyWrap81 happy_var_1) -> - happyIn78- (sL1 happy_var_1 (KindSigD noExtField (unLoc happy_var_1))- )}--happyReduce_150 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_150 = happySpecReduce_1 62# happyReduction_150-happyReduction_150 happy_x_1- = case happyOut83 happy_x_1 of { (HappyWrap83 happy_var_1) -> - happyIn78- (sL1 happy_var_1 (InstD noExtField (unLoc happy_var_1))- )}--happyReduce_151 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_151 = happySpecReduce_1 62# happyReduction_151-happyReduction_151 happy_x_1- = case happyOut107 happy_x_1 of { (HappyWrap107 happy_var_1) -> - happyIn78- (sL1 happy_var_1 (DerivD noExtField (unLoc happy_var_1))- )}--happyReduce_152 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_152 = happySpecReduce_1 62# happyReduction_152-happyReduction_152 happy_x_1- = case happyOut108 happy_x_1 of { (HappyWrap108 happy_var_1) -> - happyIn78- (sL1 happy_var_1 (RoleAnnotD noExtField (unLoc happy_var_1))- )}--happyReduce_153 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_153 = happyMonadReduce 4# 62# happyReduction_153-happyReduction_153 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut171 happy_x_3 of { (HappyWrap171 happy_var_3) -> - case happyOutTok happy_x_4 of { happy_var_4 -> - ( acsA (\cs -> sLL happy_var_1 happy_var_4- (DefD noExtField (DefaultDecl (EpAnn (glR happy_var_1) [mj AnnDefault happy_var_1,mop happy_var_2,mcp happy_var_4] cs) happy_var_3))))}}}})- ) (\r -> happyReturn (happyIn78 r))--happyReduce_154 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_154 = happyMonadReduce 2# 62# happyReduction_154-happyReduction_154 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut146 happy_x_2 of { (HappyWrap146 happy_var_2) -> - ( acsA (\cs -> sLL happy_var_1 happy_var_2 ((snd $ unLoc happy_var_2) (EpAnn (glR happy_var_1) (mj AnnForeign happy_var_1:(fst $ unLoc happy_var_2)) cs))))}})- ) (\r -> happyReturn (happyIn78 r))--happyReduce_155 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_155 = happyMonadReduce 3# 62# happyReduction_155-happyReduction_155 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut141 happy_x_2 of { (HappyWrap141 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( acsA (\cs -> sLL happy_var_1 happy_var_3 $ WarningD noExtField (Warnings (EpAnn (glR happy_var_1) [mo happy_var_1,mc happy_var_3] cs) (getDEPRECATED_PRAGs happy_var_1) (fromOL happy_var_2))))}}})- ) (\r -> happyReturn (happyIn78 r))--happyReduce_156 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_156 = happyMonadReduce 3# 62# happyReduction_156-happyReduction_156 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut139 happy_x_2 of { (HappyWrap139 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( acsA (\cs -> sLL happy_var_1 happy_var_3 $ WarningD noExtField (Warnings (EpAnn (glR happy_var_1) [mo happy_var_1,mc happy_var_3] cs) (getWARNING_PRAGs happy_var_1) (fromOL happy_var_2))))}}})- ) (\r -> happyReturn (happyIn78 r))--happyReduce_157 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_157 = happyMonadReduce 3# 62# happyReduction_157-happyReduction_157 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut131 happy_x_2 of { (HappyWrap131 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( acsA (\cs -> sLL happy_var_1 happy_var_3 $ RuleD noExtField (HsRules (EpAnn (glR happy_var_1) [mo happy_var_1,mc happy_var_3] cs) (getRULES_PRAGs happy_var_1) (reverse happy_var_2))))}}})- ) (\r -> happyReturn (happyIn78 r))--happyReduce_158 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_158 = happySpecReduce_1 62# happyReduction_158-happyReduction_158 happy_x_1- = case happyOut145 happy_x_1 of { (HappyWrap145 happy_var_1) -> - happyIn78- (happy_var_1- )}--happyReduce_159 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_159 = happySpecReduce_1 62# happyReduction_159-happyReduction_159 happy_x_1- = case happyOut197 happy_x_1 of { (HappyWrap197 happy_var_1) -> - happyIn78- (happy_var_1- )}--happyReduce_160 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_160 = happyMonadReduce 1# 62# happyReduction_160-happyReduction_160 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut207 happy_x_1 of { (HappyWrap207 happy_var_1) -> - ( runPV (unECP happy_var_1) >>= \ happy_var_1 ->- do { d <- mkSpliceDecl happy_var_1- ; commentsPA d })})- ) (\r -> happyReturn (happyIn78 r))--happyReduce_161 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_161 = happyMonadReduce 4# 63# happyReduction_161-happyReduction_161 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut104 happy_x_2 of { (HappyWrap104 happy_var_2) -> - case happyOut177 happy_x_3 of { (HappyWrap177 happy_var_3) -> - case happyOut122 happy_x_4 of { (HappyWrap122 happy_var_4) -> - ( (mkClassDecl (comb4 happy_var_1 happy_var_2 happy_var_3 happy_var_4) happy_var_2 happy_var_3 (sndOf3 $ unLoc happy_var_4) (thdOf3 $ unLoc happy_var_4))- (mj AnnClass happy_var_1:(fst $ unLoc happy_var_3)++(fstOf3 $ unLoc happy_var_4)))}}}})- ) (\r -> happyReturn (happyIn79 r))--happyReduce_162 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_162 = happyMonadReduce 4# 64# happyReduction_162-happyReduction_162 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut161 happy_x_2 of { (HappyWrap161 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut158 happy_x_4 of { (HappyWrap158 happy_var_4) -> - ( mkTySynonym (comb2A happy_var_1 happy_var_4) happy_var_2 happy_var_4 [mj AnnType happy_var_1,mj AnnEqual happy_var_3])}}}})- ) (\r -> happyReturn (happyIn80 r))--happyReduce_163 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_163 = happyMonadReduce 6# 64# happyReduction_163-happyReduction_163 (happy_x_6 `HappyStk`- happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut161 happy_x_3 of { (HappyWrap161 happy_var_3) -> - case happyOut102 happy_x_4 of { (HappyWrap102 happy_var_4) -> - case happyOut88 happy_x_5 of { (HappyWrap88 happy_var_5) -> - case happyOut91 happy_x_6 of { (HappyWrap91 happy_var_6) -> - ( mkFamDecl (comb5 happy_var_1 (reLoc happy_var_3) happy_var_4 happy_var_5 happy_var_6) (snd $ unLoc happy_var_6) TopLevel happy_var_3- (snd $ unLoc happy_var_4) (snd $ unLoc happy_var_5)- (mj AnnType happy_var_1:mj AnnFamily happy_var_2:(fst $ unLoc happy_var_4)- ++ (fst $ unLoc happy_var_5) ++ (fst $ unLoc happy_var_6)))}}}}}})- ) (\r -> happyReturn (happyIn80 r))--happyReduce_164 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_164 = happyMonadReduce 5# 64# happyReduction_164-happyReduction_164 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut99 happy_x_1 of { (HappyWrap99 happy_var_1) -> - case happyOut106 happy_x_2 of { (HappyWrap106 happy_var_2) -> - case happyOut104 happy_x_3 of { (HappyWrap104 happy_var_3) -> - case happyOut185 happy_x_4 of { (HappyWrap185 happy_var_4) -> - case happyOut193 happy_x_5 of { (HappyWrap193 happy_var_5) -> - ( mkTyData (comb4 happy_var_1 happy_var_3 happy_var_4 happy_var_5) (snd $ unLoc happy_var_1) happy_var_2 happy_var_3- Nothing (reverse (snd $ unLoc happy_var_4))- (fmap reverse happy_var_5)- ((fst $ unLoc happy_var_1):(fst $ unLoc happy_var_4)))}}}}})- ) (\r -> happyReturn (happyIn80 r))--happyReduce_165 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_165 = happyMonadReduce 6# 64# happyReduction_165-happyReduction_165 (happy_x_6 `HappyStk`- happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut99 happy_x_1 of { (HappyWrap99 happy_var_1) -> - case happyOut106 happy_x_2 of { (HappyWrap106 happy_var_2) -> - case happyOut104 happy_x_3 of { (HappyWrap104 happy_var_3) -> - case happyOut100 happy_x_4 of { (HappyWrap100 happy_var_4) -> - case happyOut182 happy_x_5 of { (HappyWrap182 happy_var_5) -> - case happyOut193 happy_x_6 of { (HappyWrap193 happy_var_6) -> - ( mkTyData (comb4 happy_var_1 happy_var_3 happy_var_5 happy_var_6) (snd $ unLoc happy_var_1) happy_var_2 happy_var_3- (snd $ unLoc happy_var_4) (snd $ unLoc happy_var_5)- (fmap reverse happy_var_6)- ((fst $ unLoc happy_var_1):(fst $ unLoc happy_var_4)++(fst $ unLoc happy_var_5)))}}}}}})- ) (\r -> happyReturn (happyIn80 r))--happyReduce_166 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_166 = happyMonadReduce 4# 64# happyReduction_166-happyReduction_166 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut161 happy_x_3 of { (HappyWrap161 happy_var_3) -> - case happyOut101 happy_x_4 of { (HappyWrap101 happy_var_4) -> - ( mkFamDecl (comb3 happy_var_1 happy_var_2 happy_var_4) DataFamily TopLevel happy_var_3- (snd $ unLoc happy_var_4) Nothing- (mj AnnData happy_var_1:mj AnnFamily happy_var_2:(fst $ unLoc happy_var_4)))}}}})- ) (\r -> happyReturn (happyIn80 r))--happyReduce_167 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_167 = happyMonadReduce 4# 65# happyReduction_167-happyReduction_167 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut82 happy_x_2 of { (HappyWrap82 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut152 happy_x_4 of { (HappyWrap152 happy_var_4) -> - ( mkStandaloneKindSig (comb2A happy_var_1 happy_var_4) (L (gl happy_var_2) $ unLoc happy_var_2) happy_var_4- [mj AnnType happy_var_1,mu AnnDcolon happy_var_3])}}}})- ) (\r -> happyReturn (happyIn81 r))--happyReduce_168 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_168 = happyMonadReduce 3# 66# happyReduction_168-happyReduction_168 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut82 happy_x_1 of { (HappyWrap82 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut281 happy_x_3 of { (HappyWrap281 happy_var_3) -> - ( case unLoc happy_var_1 of- (h:t) -> do- h' <- addTrailingCommaN h (gl happy_var_2)- return (sLL happy_var_1 (reLocN happy_var_3) (happy_var_3 : h' : t)))}}})- ) (\r -> happyReturn (happyIn82 r))--happyReduce_169 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_169 = happySpecReduce_1 66# happyReduction_169-happyReduction_169 happy_x_1- = case happyOut281 happy_x_1 of { (HappyWrap281 happy_var_1) -> - happyIn82- (sL1N happy_var_1 [happy_var_1]- )}--happyReduce_170 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_170 = happyMonadReduce 4# 67# happyReduction_170-happyReduction_170 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut84 happy_x_2 of { (HappyWrap84 happy_var_2) -> - case happyOut169 happy_x_3 of { (HappyWrap169 happy_var_3) -> - case happyOut126 happy_x_4 of { (HappyWrap126 happy_var_4) -> - ( do { (binds, sigs, _, ats, adts, _) <- cvBindsAndSigs (snd $ unLoc happy_var_4)- ; let anns = (mj AnnInstance happy_var_1 : (fst $ unLoc happy_var_4))- ; let cid cs = ClsInstDecl- { cid_ext = (EpAnn (glR happy_var_1) anns cs, NoAnnSortKey)- , cid_poly_ty = happy_var_3, cid_binds = binds- , cid_sigs = mkClassOpSigs sigs- , cid_tyfam_insts = ats- , cid_overlap_mode = happy_var_2- , cid_datafam_insts = adts }- ; acsA (\cs -> L (comb3 happy_var_1 (reLoc happy_var_3) happy_var_4)- (ClsInstD { cid_d_ext = noExtField, cid_inst = cid cs }))- })}}}})- ) (\r -> happyReturn (happyIn83 r))--happyReduce_171 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_171 = happyMonadReduce 3# 67# happyReduction_171-happyReduction_171 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut94 happy_x_3 of { (HappyWrap94 happy_var_3) -> - ( mkTyFamInst (comb2A happy_var_1 happy_var_3) (unLoc happy_var_3)- (mj AnnType happy_var_1:mj AnnInstance happy_var_2:[]))}}})- ) (\r -> happyReturn (happyIn83 r))--happyReduce_172 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_172 = happyMonadReduce 6# 67# happyReduction_172-happyReduction_172 (happy_x_6 `HappyStk`- happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut99 happy_x_1 of { (HappyWrap99 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut106 happy_x_3 of { (HappyWrap106 happy_var_3) -> - case happyOut105 happy_x_4 of { (HappyWrap105 happy_var_4) -> - case happyOut185 happy_x_5 of { (HappyWrap185 happy_var_5) -> - case happyOut193 happy_x_6 of { (HappyWrap193 happy_var_6) -> - ( mkDataFamInst (comb4 happy_var_1 happy_var_4 happy_var_5 happy_var_6) (snd $ unLoc happy_var_1) happy_var_3 (unLoc happy_var_4)- Nothing (reverse (snd $ unLoc happy_var_5))- (fmap reverse happy_var_6)- ((fst $ unLoc happy_var_1):mj AnnInstance happy_var_2:(fst $ unLoc happy_var_5)))}}}}}})- ) (\r -> happyReturn (happyIn83 r))--happyReduce_173 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_173 = happyMonadReduce 7# 67# happyReduction_173-happyReduction_173 (happy_x_7 `HappyStk`- happy_x_6 `HappyStk`- happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut99 happy_x_1 of { (HappyWrap99 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut106 happy_x_3 of { (HappyWrap106 happy_var_3) -> - case happyOut105 happy_x_4 of { (HappyWrap105 happy_var_4) -> - case happyOut100 happy_x_5 of { (HappyWrap100 happy_var_5) -> - case happyOut182 happy_x_6 of { (HappyWrap182 happy_var_6) -> - case happyOut193 happy_x_7 of { (HappyWrap193 happy_var_7) -> - ( mkDataFamInst (comb4 happy_var_1 happy_var_4 happy_var_6 happy_var_7) (snd $ unLoc happy_var_1) happy_var_3 (unLoc happy_var_4)- (snd $ unLoc happy_var_5) (snd $ unLoc happy_var_6)- (fmap reverse happy_var_7)- ((fst $ unLoc happy_var_1):mj AnnInstance happy_var_2- :(fst $ unLoc happy_var_5)++(fst $ unLoc happy_var_6)))}}}}}}})- ) (\r -> happyReturn (happyIn83 r))--happyReduce_174 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_174 = happyMonadReduce 2# 68# happyReduction_174-happyReduction_174 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( fmap Just $ amsrp (sLL happy_var_1 happy_var_2 (Overlappable (getOVERLAPPABLE_PRAGs happy_var_1)))- (AnnPragma (mo happy_var_1) (mc happy_var_2) []))}})- ) (\r -> happyReturn (happyIn84 r))--happyReduce_175 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_175 = happyMonadReduce 2# 68# happyReduction_175-happyReduction_175 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( fmap Just $ amsrp (sLL happy_var_1 happy_var_2 (Overlapping (getOVERLAPPING_PRAGs happy_var_1)))- (AnnPragma (mo happy_var_1) (mc happy_var_2) []))}})- ) (\r -> happyReturn (happyIn84 r))--happyReduce_176 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_176 = happyMonadReduce 2# 68# happyReduction_176-happyReduction_176 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( fmap Just $ amsrp (sLL happy_var_1 happy_var_2 (Overlaps (getOVERLAPS_PRAGs happy_var_1)))- (AnnPragma (mo happy_var_1) (mc happy_var_2) []))}})- ) (\r -> happyReturn (happyIn84 r))--happyReduce_177 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_177 = happyMonadReduce 2# 68# happyReduction_177-happyReduction_177 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( fmap Just $ amsrp (sLL happy_var_1 happy_var_2 (Incoherent (getINCOHERENT_PRAGs happy_var_1)))- (AnnPragma (mo happy_var_1) (mc happy_var_2) []))}})- ) (\r -> happyReturn (happyIn84 r))--happyReduce_178 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_178 = happySpecReduce_0 68# happyReduction_178-happyReduction_178 = happyIn84- (Nothing- )--happyReduce_179 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_179 = happyMonadReduce 1# 69# happyReduction_179-happyReduction_179 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - ( acs (\cs -> sL1 happy_var_1 (StockStrategy (EpAnn (glR happy_var_1) [mj AnnStock happy_var_1] cs))))})- ) (\r -> happyReturn (happyIn85 r))--happyReduce_180 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_180 = happyMonadReduce 1# 69# happyReduction_180-happyReduction_180 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - ( acs (\cs -> sL1 happy_var_1 (AnyclassStrategy (EpAnn (glR happy_var_1) [mj AnnAnyclass happy_var_1] cs))))})- ) (\r -> happyReturn (happyIn85 r))--happyReduce_181 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_181 = happyMonadReduce 1# 69# happyReduction_181-happyReduction_181 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - ( acs (\cs -> sL1 happy_var_1 (NewtypeStrategy (EpAnn (glR happy_var_1) [mj AnnNewtype happy_var_1] cs))))})- ) (\r -> happyReturn (happyIn85 r))--happyReduce_182 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_182 = happyMonadReduce 2# 70# happyReduction_182-happyReduction_182 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut152 happy_x_2 of { (HappyWrap152 happy_var_2) -> - ( acs (\cs -> sLLlA happy_var_1 happy_var_2 (ViaStrategy (XViaStrategyPs (EpAnn (glR happy_var_1) [mj AnnVia happy_var_1] cs)- happy_var_2))))}})- ) (\r -> happyReturn (happyIn86 r))--happyReduce_183 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_183 = happyMonadReduce 1# 71# happyReduction_183-happyReduction_183 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - ( fmap Just $ acs (\cs -> sL1 happy_var_1 (StockStrategy (EpAnn (glR happy_var_1) [mj AnnStock happy_var_1] cs))))})- ) (\r -> happyReturn (happyIn87 r))--happyReduce_184 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_184 = happyMonadReduce 1# 71# happyReduction_184-happyReduction_184 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - ( fmap Just $ acs (\cs -> sL1 happy_var_1 (AnyclassStrategy (EpAnn (glR happy_var_1) [mj AnnAnyclass happy_var_1] cs))))})- ) (\r -> happyReturn (happyIn87 r))--happyReduce_185 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_185 = happyMonadReduce 1# 71# happyReduction_185-happyReduction_185 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - ( fmap Just $ acs (\cs -> sL1 happy_var_1 (NewtypeStrategy (EpAnn (glR happy_var_1) [mj AnnNewtype happy_var_1] cs))))})- ) (\r -> happyReturn (happyIn87 r))--happyReduce_186 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_186 = happySpecReduce_1 71# happyReduction_186-happyReduction_186 happy_x_1- = case happyOut86 happy_x_1 of { (HappyWrap86 happy_var_1) -> - happyIn87- (Just happy_var_1- )}--happyReduce_187 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_187 = happySpecReduce_0 71# happyReduction_187-happyReduction_187 = happyIn87- (Nothing- )--happyReduce_188 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_188 = happySpecReduce_0 72# happyReduction_188-happyReduction_188 = happyIn88- (noLoc ([], Nothing)- )--happyReduce_189 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_189 = happySpecReduce_2 72# happyReduction_189-happyReduction_189 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut89 happy_x_2 of { (HappyWrap89 happy_var_2) -> - happyIn88- (sLL happy_var_1 happy_var_2 ([mj AnnVbar happy_var_1]- , Just (happy_var_2))- )}}--happyReduce_190 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_190 = happyMonadReduce 3# 73# happyReduction_190-happyReduction_190 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut298 happy_x_1 of { (HappyWrap298 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut90 happy_x_3 of { (HappyWrap90 happy_var_3) -> - ( acs (\cs -> sLL (reLocN happy_var_1) happy_var_3 (InjectivityAnn (EpAnn (glNR happy_var_1) [mu AnnRarrow happy_var_2] cs) happy_var_1 (reverse (unLoc happy_var_3)))))}}})- ) (\r -> happyReturn (happyIn89 r))--happyReduce_191 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_191 = happySpecReduce_2 74# happyReduction_191-happyReduction_191 happy_x_2- happy_x_1- = case happyOut90 happy_x_1 of { (HappyWrap90 happy_var_1) -> - case happyOut298 happy_x_2 of { (HappyWrap298 happy_var_2) -> - happyIn90- (sLL happy_var_1 (reLocN happy_var_2) (happy_var_2 : unLoc happy_var_1)- )}}--happyReduce_192 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_192 = happySpecReduce_1 74# happyReduction_192-happyReduction_192 happy_x_1- = case happyOut298 happy_x_1 of { (HappyWrap298 happy_var_1) -> - happyIn90- (sL1N happy_var_1 [happy_var_1]- )}--happyReduce_193 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_193 = happySpecReduce_0 75# happyReduction_193-happyReduction_193 = happyIn91- (noLoc ([],OpenTypeFamily)- )--happyReduce_194 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_194 = happySpecReduce_2 75# happyReduction_194-happyReduction_194 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut92 happy_x_2 of { (HappyWrap92 happy_var_2) -> - happyIn91- (sLL happy_var_1 happy_var_2 (mj AnnWhere happy_var_1:(fst $ unLoc happy_var_2)- ,ClosedTypeFamily (fmap reverse $ snd $ unLoc happy_var_2))- )}}--happyReduce_195 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_195 = happySpecReduce_3 76# happyReduction_195-happyReduction_195 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut93 happy_x_2 of { (HappyWrap93 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn92- (sLL happy_var_1 happy_var_3 ([moc happy_var_1,mcc happy_var_3]- ,Just (unLoc happy_var_2))- )}}}--happyReduce_196 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_196 = happySpecReduce_3 76# happyReduction_196-happyReduction_196 happy_x_3- happy_x_2- happy_x_1- = case happyOut93 happy_x_2 of { (HappyWrap93 happy_var_2) -> - happyIn92- (let (L loc _) = happy_var_2 in- L loc ([],Just (unLoc happy_var_2))- )}--happyReduce_197 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_197 = happySpecReduce_3 76# happyReduction_197-happyReduction_197 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn92- (sLL happy_var_1 happy_var_3 ([moc happy_var_1,mj AnnDotdot happy_var_2- ,mcc happy_var_3],Nothing)- )}}}--happyReduce_198 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_198 = happySpecReduce_3 76# happyReduction_198-happyReduction_198 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_2 of { happy_var_2 -> - happyIn92- (let (L loc _) = happy_var_2 in- L loc ([mj AnnDotdot happy_var_2],Nothing)- )}--happyReduce_199 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_199 = happyMonadReduce 3# 77# happyReduction_199-happyReduction_199 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut93 happy_x_1 of { (HappyWrap93 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut94 happy_x_3 of { (HappyWrap94 happy_var_3) -> - ( let (L loc eqn) = happy_var_3 in- case unLoc happy_var_1 of- [] -> return (sLLlA happy_var_1 happy_var_3 (L loc eqn : unLoc happy_var_1))- (h:t) -> do- h' <- addTrailingSemiA h (gl happy_var_2)- return (sLLlA happy_var_1 happy_var_3 (happy_var_3 : h' : t)))}}})- ) (\r -> happyReturn (happyIn93 r))--happyReduce_200 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_200 = happyMonadReduce 2# 77# happyReduction_200-happyReduction_200 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut93 happy_x_1 of { (HappyWrap93 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( case unLoc happy_var_1 of- [] -> return (sLL happy_var_1 happy_var_2 (unLoc happy_var_1))- (h:t) -> do- h' <- addTrailingSemiA h (gl happy_var_2)- return (sLL happy_var_1 happy_var_2 (h':t)))}})- ) (\r -> happyReturn (happyIn93 r))--happyReduce_201 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_201 = happySpecReduce_1 77# happyReduction_201-happyReduction_201 happy_x_1- = case happyOut94 happy_x_1 of { (HappyWrap94 happy_var_1) -> - happyIn93- (sLLAA happy_var_1 happy_var_1 [happy_var_1]- )}--happyReduce_202 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_202 = happySpecReduce_0 77# happyReduction_202-happyReduction_202 = happyIn93- (noLoc []- )--happyReduce_203 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_203 = happyMonadReduce 6# 78# happyReduction_203-happyReduction_203 (happy_x_6 `HappyStk`- happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut174 happy_x_2 of { (HappyWrap174 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut161 happy_x_4 of { (HappyWrap161 happy_var_4) -> - case happyOutTok happy_x_5 of { happy_var_5 -> - case happyOut158 happy_x_6 of { (HappyWrap158 happy_var_6) -> - ( do { hintExplicitForall happy_var_1- ; tvbs <- fromSpecTyVarBndrs happy_var_2- ; let loc = comb2A happy_var_1 happy_var_6- ; cs <- getCommentsFor loc- ; mkTyFamInstEqn loc (mkHsOuterExplicit (EpAnn (glR happy_var_1) (mu AnnForall happy_var_1, mj AnnDot happy_var_3) cs) tvbs) happy_var_4 happy_var_6 [mj AnnEqual happy_var_5] })}}}}}})- ) (\r -> happyReturn (happyIn94 r))--happyReduce_204 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_204 = happyMonadReduce 3# 78# happyReduction_204-happyReduction_204 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut161 happy_x_1 of { (HappyWrap161 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut158 happy_x_3 of { (HappyWrap158 happy_var_3) -> - ( mkTyFamInstEqn (comb2A (reLoc happy_var_1) happy_var_3) mkHsOuterImplicit happy_var_1 happy_var_3 (mj AnnEqual happy_var_2:[]))}}})- ) (\r -> happyReturn (happyIn94 r))--happyReduce_205 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_205 = happyMonadReduce 4# 79# happyReduction_205-happyReduction_205 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut96 happy_x_2 of { (HappyWrap96 happy_var_2) -> - case happyOut161 happy_x_3 of { (HappyWrap161 happy_var_3) -> - case happyOut101 happy_x_4 of { (HappyWrap101 happy_var_4) -> - ( liftM mkTyClD (mkFamDecl (comb3 happy_var_1 (reLoc happy_var_3) happy_var_4) DataFamily NotTopLevel happy_var_3- (snd $ unLoc happy_var_4) Nothing- (mj AnnData happy_var_1:happy_var_2++(fst $ unLoc happy_var_4))))}}}})- ) (\r -> happyReturn (happyIn95 r))--happyReduce_206 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_206 = happyMonadReduce 3# 79# happyReduction_206-happyReduction_206 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut161 happy_x_2 of { (HappyWrap161 happy_var_2) -> - case happyOut103 happy_x_3 of { (HappyWrap103 happy_var_3) -> - ( liftM mkTyClD- (mkFamDecl (comb3 happy_var_1 (reLoc happy_var_2) happy_var_3) OpenTypeFamily NotTopLevel happy_var_2- (fst . snd $ unLoc happy_var_3)- (snd . snd $ unLoc happy_var_3)- (mj AnnType happy_var_1:(fst $ unLoc happy_var_3)) ))}}})- ) (\r -> happyReturn (happyIn95 r))--happyReduce_207 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_207 = happyMonadReduce 4# 79# happyReduction_207-happyReduction_207 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut161 happy_x_3 of { (HappyWrap161 happy_var_3) -> - case happyOut103 happy_x_4 of { (HappyWrap103 happy_var_4) -> - ( liftM mkTyClD- (mkFamDecl (comb3 happy_var_1 (reLoc happy_var_3) happy_var_4) OpenTypeFamily NotTopLevel happy_var_3- (fst . snd $ unLoc happy_var_4)- (snd . snd $ unLoc happy_var_4)- (mj AnnType happy_var_1:mj AnnFamily happy_var_2:(fst $ unLoc happy_var_4))))}}}})- ) (\r -> happyReturn (happyIn95 r))--happyReduce_208 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_208 = happyMonadReduce 2# 79# happyReduction_208-happyReduction_208 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut94 happy_x_2 of { (HappyWrap94 happy_var_2) -> - ( liftM mkInstD (mkTyFamInst (comb2A happy_var_1 happy_var_2) (unLoc happy_var_2)- [mj AnnType happy_var_1]))}})- ) (\r -> happyReturn (happyIn95 r))--happyReduce_209 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_209 = happyMonadReduce 3# 79# happyReduction_209-happyReduction_209 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut94 happy_x_3 of { (HappyWrap94 happy_var_3) -> - ( liftM mkInstD (mkTyFamInst (comb2A happy_var_1 happy_var_3) (unLoc happy_var_3)- (mj AnnType happy_var_1:mj AnnInstance happy_var_2:[]) ))}}})- ) (\r -> happyReturn (happyIn95 r))--happyReduce_210 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_210 = happySpecReduce_0 80# happyReduction_210-happyReduction_210 = happyIn96- ([]- )--happyReduce_211 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_211 = happySpecReduce_1 80# happyReduction_211-happyReduction_211 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn96- ([mj AnnFamily happy_var_1]- )}--happyReduce_212 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_212 = happySpecReduce_0 81# happyReduction_212-happyReduction_212 = happyIn97- ([]- )--happyReduce_213 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_213 = happySpecReduce_1 81# happyReduction_213-happyReduction_213 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn97- ([mj AnnInstance happy_var_1]- )}--happyReduce_214 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_214 = happyMonadReduce 3# 82# happyReduction_214-happyReduction_214 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut97 happy_x_2 of { (HappyWrap97 happy_var_2) -> - case happyOut94 happy_x_3 of { (HappyWrap94 happy_var_3) -> - ( mkTyFamInst (comb2A happy_var_1 happy_var_3) (unLoc happy_var_3)- (mj AnnType happy_var_1:happy_var_2))}}})- ) (\r -> happyReturn (happyIn98 r))--happyReduce_215 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_215 = happyMonadReduce 6# 82# happyReduction_215-happyReduction_215 (happy_x_6 `HappyStk`- happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut99 happy_x_1 of { (HappyWrap99 happy_var_1) -> - case happyOut97 happy_x_2 of { (HappyWrap97 happy_var_2) -> - case happyOut106 happy_x_3 of { (HappyWrap106 happy_var_3) -> - case happyOut105 happy_x_4 of { (HappyWrap105 happy_var_4) -> - case happyOut185 happy_x_5 of { (HappyWrap185 happy_var_5) -> - case happyOut193 happy_x_6 of { (HappyWrap193 happy_var_6) -> - ( mkDataFamInst (comb4 happy_var_1 happy_var_4 happy_var_5 happy_var_6) (snd $ unLoc happy_var_1) happy_var_3 (unLoc happy_var_4)- Nothing (reverse (snd $ unLoc happy_var_5))- (fmap reverse happy_var_6)- ((fst $ unLoc happy_var_1):happy_var_2++(fst $ unLoc happy_var_5)))}}}}}})- ) (\r -> happyReturn (happyIn98 r))--happyReduce_216 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_216 = happyMonadReduce 7# 82# happyReduction_216-happyReduction_216 (happy_x_7 `HappyStk`- happy_x_6 `HappyStk`- happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut99 happy_x_1 of { (HappyWrap99 happy_var_1) -> - case happyOut97 happy_x_2 of { (HappyWrap97 happy_var_2) -> - case happyOut106 happy_x_3 of { (HappyWrap106 happy_var_3) -> - case happyOut105 happy_x_4 of { (HappyWrap105 happy_var_4) -> - case happyOut100 happy_x_5 of { (HappyWrap100 happy_var_5) -> - case happyOut182 happy_x_6 of { (HappyWrap182 happy_var_6) -> - case happyOut193 happy_x_7 of { (HappyWrap193 happy_var_7) -> - ( mkDataFamInst (comb4 happy_var_1 happy_var_4 happy_var_6 happy_var_7) (snd $ unLoc happy_var_1) happy_var_3- (unLoc happy_var_4) (snd $ unLoc happy_var_5) (snd $ unLoc happy_var_6)- (fmap reverse happy_var_7)- ((fst $ unLoc happy_var_1):happy_var_2++(fst $ unLoc happy_var_5)++(fst $ unLoc happy_var_6)))}}}}}}})- ) (\r -> happyReturn (happyIn98 r))--happyReduce_217 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_217 = happySpecReduce_1 83# happyReduction_217-happyReduction_217 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn99- (sL1 happy_var_1 (mj AnnData happy_var_1,DataType)- )}--happyReduce_218 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_218 = happySpecReduce_1 83# happyReduction_218-happyReduction_218 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn99- (sL1 happy_var_1 (mj AnnNewtype happy_var_1,NewType)- )}--happyReduce_219 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_219 = happySpecReduce_0 84# happyReduction_219-happyReduction_219 = happyIn100- (noLoc ([] , Nothing)- )--happyReduce_220 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_220 = happySpecReduce_2 84# happyReduction_220-happyReduction_220 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut181 happy_x_2 of { (HappyWrap181 happy_var_2) -> - happyIn100- (sLL happy_var_1 (reLoc happy_var_2) ([mu AnnDcolon happy_var_1], Just happy_var_2)- )}}--happyReduce_221 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_221 = happySpecReduce_0 85# happyReduction_221-happyReduction_221 = happyIn101- (noLoc ([] , noLoc (NoSig noExtField) )- )--happyReduce_222 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_222 = happySpecReduce_2 85# happyReduction_222-happyReduction_222 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut181 happy_x_2 of { (HappyWrap181 happy_var_2) -> - happyIn101- (sLL happy_var_1 (reLoc happy_var_2) ([mu AnnDcolon happy_var_1], sLL happy_var_1 (reLoc happy_var_2) (KindSig noExtField happy_var_2))- )}}--happyReduce_223 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_223 = happySpecReduce_0 86# happyReduction_223-happyReduction_223 = happyIn102- (noLoc ([] , noLoc (NoSig noExtField) )- )--happyReduce_224 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_224 = happySpecReduce_2 86# happyReduction_224-happyReduction_224 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut181 happy_x_2 of { (HappyWrap181 happy_var_2) -> - happyIn102- (sLL happy_var_1 (reLoc happy_var_2) ([mu AnnDcolon happy_var_1], sLL happy_var_1 (reLoc happy_var_2) (KindSig noExtField happy_var_2))- )}}--happyReduce_225 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_225 = happyMonadReduce 2# 86# happyReduction_225-happyReduction_225 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut175 happy_x_2 of { (HappyWrap175 happy_var_2) -> - ( do { tvb <- fromSpecTyVarBndr happy_var_2- ; return $ sLL happy_var_1 (reLoc happy_var_2) ([mj AnnEqual happy_var_1], sLL happy_var_1 (reLoc happy_var_2) (TyVarSig noExtField tvb))})}})- ) (\r -> happyReturn (happyIn102 r))--happyReduce_226 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_226 = happySpecReduce_0 87# happyReduction_226-happyReduction_226 = happyIn103- (noLoc ([], (noLoc (NoSig noExtField), Nothing))- )--happyReduce_227 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_227 = happySpecReduce_2 87# happyReduction_227-happyReduction_227 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut181 happy_x_2 of { (HappyWrap181 happy_var_2) -> - happyIn103- (sLL happy_var_1 (reLoc happy_var_2) ( [mu AnnDcolon happy_var_1]- , (sL1A happy_var_2 (KindSig noExtField happy_var_2), Nothing))- )}}--happyReduce_228 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_228 = happyMonadReduce 4# 87# happyReduction_228-happyReduction_228 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut176 happy_x_2 of { (HappyWrap176 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut89 happy_x_4 of { (HappyWrap89 happy_var_4) -> - ( do { tvb <- fromSpecTyVarBndr happy_var_2- ; return $ sLL happy_var_1 happy_var_4 ([mj AnnEqual happy_var_1, mj AnnVbar happy_var_3]- , (sLL happy_var_1 (reLoc happy_var_2) (TyVarSig noExtField tvb), Just happy_var_4))})}}}})- ) (\r -> happyReturn (happyIn103 r))--happyReduce_229 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_229 = happyMonadReduce 3# 88# happyReduction_229-happyReduction_229 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut160 happy_x_1 of { (HappyWrap160 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut161 happy_x_3 of { (HappyWrap161 happy_var_3) -> - ( acs (\cs -> (sLLAA happy_var_1 happy_var_3 (Just (addTrailingDarrowC happy_var_1 happy_var_2 cs), happy_var_3))))}}})- ) (\r -> happyReturn (happyIn104 r))--happyReduce_230 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_230 = happySpecReduce_1 88# happyReduction_230-happyReduction_230 happy_x_1- = case happyOut161 happy_x_1 of { (HappyWrap161 happy_var_1) -> - happyIn104- (sL1A happy_var_1 (Nothing, happy_var_1)- )}--happyReduce_231 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_231 = happyMonadReduce 6# 89# happyReduction_231-happyReduction_231 (happy_x_6 `HappyStk`- happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut174 happy_x_2 of { (HappyWrap174 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut160 happy_x_4 of { (HappyWrap160 happy_var_4) -> - case happyOutTok happy_x_5 of { happy_var_5 -> - case happyOut161 happy_x_6 of { (HappyWrap161 happy_var_6) -> - ( hintExplicitForall happy_var_1- >> fromSpecTyVarBndrs happy_var_2- >>= \tvbs ->- (acs (\cs -> (sLL happy_var_1 (reLoc happy_var_6)- (Just ( addTrailingDarrowC happy_var_4 happy_var_5 cs)- , mkHsOuterExplicit (EpAnn (glR happy_var_1) (mu AnnForall happy_var_1, mj AnnDot happy_var_3) emptyComments) tvbs, happy_var_6)))))}}}}}})- ) (\r -> happyReturn (happyIn105 r))--happyReduce_232 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_232 = happyMonadReduce 4# 89# happyReduction_232-happyReduction_232 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut174 happy_x_2 of { (HappyWrap174 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut161 happy_x_4 of { (HappyWrap161 happy_var_4) -> - ( do { hintExplicitForall happy_var_1- ; tvbs <- fromSpecTyVarBndrs happy_var_2- ; let loc = comb2 happy_var_1 (reLoc happy_var_4)- ; cs <- getCommentsFor loc- ; return (sL loc (Nothing, mkHsOuterExplicit (EpAnn (glR happy_var_1) (mu AnnForall happy_var_1, mj AnnDot happy_var_3) cs) tvbs, happy_var_4))- })}}}})- ) (\r -> happyReturn (happyIn105 r))--happyReduce_233 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_233 = happyMonadReduce 3# 89# happyReduction_233-happyReduction_233 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut160 happy_x_1 of { (HappyWrap160 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut161 happy_x_3 of { (HappyWrap161 happy_var_3) -> - ( acs (\cs -> (sLLAA happy_var_1 happy_var_3(Just (addTrailingDarrowC happy_var_1 happy_var_2 cs), mkHsOuterImplicit, happy_var_3))))}}})- ) (\r -> happyReturn (happyIn105 r))--happyReduce_234 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_234 = happySpecReduce_1 89# happyReduction_234-happyReduction_234 happy_x_1- = case happyOut161 happy_x_1 of { (HappyWrap161 happy_var_1) -> - happyIn105- (sL1A happy_var_1 (Nothing, mkHsOuterImplicit, happy_var_1)- )}--happyReduce_235 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_235 = happyMonadReduce 4# 90# happyReduction_235-happyReduction_235 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - ( fmap Just $ amsrp (sLL happy_var_1 happy_var_4 (CType (getCTYPEs happy_var_1) (Just (Header (getSTRINGs happy_var_2) (getSTRING happy_var_2)))- (getSTRINGs happy_var_3,getSTRING happy_var_3)))- (AnnPragma (mo happy_var_1) (mc happy_var_4) [mj AnnHeader happy_var_2,mj AnnVal happy_var_3]))}}}})- ) (\r -> happyReturn (happyIn106 r))--happyReduce_236 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_236 = happyMonadReduce 3# 90# happyReduction_236-happyReduction_236 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( fmap Just $ amsrp (sLL happy_var_1 happy_var_3 (CType (getCTYPEs happy_var_1) Nothing (getSTRINGs happy_var_2, getSTRING happy_var_2)))- (AnnPragma (mo happy_var_1) (mc happy_var_3) [mj AnnVal happy_var_2]))}}})- ) (\r -> happyReturn (happyIn106 r))--happyReduce_237 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_237 = happySpecReduce_0 90# happyReduction_237-happyReduction_237 = happyIn106- (Nothing- )--happyReduce_238 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_238 = happyMonadReduce 5# 91# happyReduction_238-happyReduction_238 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut87 happy_x_2 of { (HappyWrap87 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut84 happy_x_4 of { (HappyWrap84 happy_var_4) -> - case happyOut169 happy_x_5 of { (HappyWrap169 happy_var_5) -> - ( do { let { err = text "in the stand-alone deriving instance"- <> colon <+> quotes (ppr happy_var_5) }- ; acsA (\cs -> sLL happy_var_1 (reLoc happy_var_5)- (DerivDecl (EpAnn (glR happy_var_1) [mj AnnDeriving happy_var_1, mj AnnInstance happy_var_3] cs) (mkHsWildCardBndrs happy_var_5) happy_var_2 happy_var_4)) })}}}}})- ) (\r -> happyReturn (happyIn107 r))--happyReduce_239 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_239 = happyMonadReduce 4# 92# happyReduction_239-happyReduction_239 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut281 happy_x_3 of { (HappyWrap281 happy_var_3) -> - case happyOut109 happy_x_4 of { (HappyWrap109 happy_var_4) -> - ( mkRoleAnnotDecl (comb3N happy_var_1 happy_var_4 happy_var_3) happy_var_3 (reverse (unLoc happy_var_4))- [mj AnnType happy_var_1,mj AnnRole happy_var_2])}}}})- ) (\r -> happyReturn (happyIn108 r))--happyReduce_240 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_240 = happySpecReduce_0 93# happyReduction_240-happyReduction_240 = happyIn109- (noLoc []- )--happyReduce_241 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_241 = happySpecReduce_1 93# happyReduction_241-happyReduction_241 happy_x_1- = case happyOut110 happy_x_1 of { (HappyWrap110 happy_var_1) -> - happyIn109- (happy_var_1- )}--happyReduce_242 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_242 = happySpecReduce_1 94# happyReduction_242-happyReduction_242 happy_x_1- = case happyOut111 happy_x_1 of { (HappyWrap111 happy_var_1) -> - happyIn110- (sLL happy_var_1 happy_var_1 [happy_var_1]- )}--happyReduce_243 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_243 = happySpecReduce_2 94# happyReduction_243-happyReduction_243 happy_x_2- happy_x_1- = case happyOut110 happy_x_1 of { (HappyWrap110 happy_var_1) -> - case happyOut111 happy_x_2 of { (HappyWrap111 happy_var_2) -> - happyIn110- (sLL happy_var_1 happy_var_2 $ happy_var_2 : unLoc happy_var_1- )}}--happyReduce_244 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_244 = happySpecReduce_1 95# happyReduction_244-happyReduction_244 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn111- (sL1 happy_var_1 $ Just $ getVARID happy_var_1- )}--happyReduce_245 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_245 = happySpecReduce_1 95# happyReduction_245-happyReduction_245 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn111- (sL1 happy_var_1 Nothing- )}--happyReduce_246 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_246 = happyMonadReduce 4# 96# happyReduction_246-happyReduction_246 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut113 happy_x_2 of { (HappyWrap113 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut245 happy_x_4 of { (HappyWrap245 happy_var_4) -> - ( let (name, args, as ) = happy_var_2 in- acsA (\cs -> sLL happy_var_1 (reLoc happy_var_4) . ValD noExtField $ mkPatSynBind name args happy_var_4- ImplicitBidirectional- (EpAnn (glR happy_var_1) (as ++ [mj AnnPattern happy_var_1, mj AnnEqual happy_var_3]) cs)))}}}})- ) (\r -> happyReturn (happyIn112 r))--happyReduce_247 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_247 = happyMonadReduce 4# 96# happyReduction_247-happyReduction_247 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut113 happy_x_2 of { (HappyWrap113 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut245 happy_x_4 of { (HappyWrap245 happy_var_4) -> - ( let (name, args, as) = happy_var_2 in- acsA (\cs -> sLL happy_var_1 (reLoc happy_var_4) . ValD noExtField $ mkPatSynBind name args happy_var_4 Unidirectional- (EpAnn (glR happy_var_1) (as ++ [mj AnnPattern happy_var_1,mu AnnLarrow happy_var_3]) cs)))}}}})- ) (\r -> happyReturn (happyIn112 r))--happyReduce_248 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_248 = happyMonadReduce 5# 96# happyReduction_248-happyReduction_248 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut113 happy_x_2 of { (HappyWrap113 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut245 happy_x_4 of { (HappyWrap245 happy_var_4) -> - case happyOut116 happy_x_5 of { (HappyWrap116 happy_var_5) -> - ( do { let (name, args, as) = happy_var_2- ; mg <- mkPatSynMatchGroup name happy_var_5- ; acsA (\cs -> sLL happy_var_1 (reLoc happy_var_5) . ValD noExtField $- mkPatSynBind name args happy_var_4 (ExplicitBidirectional mg)- (EpAnn (glR happy_var_1) (as ++ [mj AnnPattern happy_var_1,mu AnnLarrow happy_var_3]) cs))- })}}}}})- ) (\r -> happyReturn (happyIn112 r))--happyReduce_249 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_249 = happySpecReduce_2 97# happyReduction_249-happyReduction_249 happy_x_2- happy_x_1- = case happyOut273 happy_x_1 of { (HappyWrap273 happy_var_1) -> - case happyOut114 happy_x_2 of { (HappyWrap114 happy_var_2) -> - happyIn113- ((happy_var_1, PrefixCon noTypeArgs happy_var_2, [])- )}}--happyReduce_250 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_250 = happySpecReduce_3 97# happyReduction_250-happyReduction_250 happy_x_3- happy_x_2- happy_x_1- = case happyOut303 happy_x_1 of { (HappyWrap303 happy_var_1) -> - case happyOut277 happy_x_2 of { (HappyWrap277 happy_var_2) -> - case happyOut303 happy_x_3 of { (HappyWrap303 happy_var_3) -> - happyIn113- ((happy_var_2, InfixCon happy_var_1 happy_var_3, [])- )}}}--happyReduce_251 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_251 = happyReduce 4# 97# happyReduction_251-happyReduction_251 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut273 happy_x_1 of { (HappyWrap273 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut115 happy_x_3 of { (HappyWrap115 happy_var_3) -> - case happyOutTok happy_x_4 of { happy_var_4 -> - happyIn113- ((happy_var_1, RecCon happy_var_3, [moc happy_var_2, mcc happy_var_4] )- ) `HappyStk` happyRest}}}}--happyReduce_252 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_252 = happySpecReduce_0 98# happyReduction_252-happyReduction_252 = happyIn114- ([]- )--happyReduce_253 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_253 = happySpecReduce_2 98# happyReduction_253-happyReduction_253 happy_x_2- happy_x_1- = case happyOut303 happy_x_1 of { (HappyWrap303 happy_var_1) -> - case happyOut114 happy_x_2 of { (HappyWrap114 happy_var_2) -> - happyIn114- (happy_var_1 : happy_var_2- )}}--happyReduce_254 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_254 = happySpecReduce_1 99# happyReduction_254-happyReduction_254 happy_x_1- = case happyOut299 happy_x_1 of { (HappyWrap299 happy_var_1) -> - happyIn115- ([RecordPatSynField (mkFieldOcc happy_var_1) happy_var_1]- )}--happyReduce_255 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_255 = happyMonadReduce 3# 99# happyReduction_255-happyReduction_255 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut299 happy_x_1 of { (HappyWrap299 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut115 happy_x_3 of { (HappyWrap115 happy_var_3) -> - ( do { h <- addTrailingCommaN happy_var_1 (gl happy_var_2)- ; return ((RecordPatSynField (mkFieldOcc h) h) : happy_var_3 )})}}})- ) (\r -> happyReturn (happyIn115 r))--happyReduce_256 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_256 = happyMonadReduce 4# 100# happyReduction_256-happyReduction_256 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut127 happy_x_3 of { (HappyWrap127 happy_var_3) -> - case happyOutTok happy_x_4 of { happy_var_4 -> - ( amsrl (sLL happy_var_1 happy_var_4 (snd $ unLoc happy_var_3))- (AnnList (Just $ glR happy_var_3) (Just $ moc happy_var_2) (Just $ mcc happy_var_4) [mj AnnWhere happy_var_1] (fst $ unLoc happy_var_3)))}}}})- ) (\r -> happyReturn (happyIn116 r))--happyReduce_257 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_257 = happyMonadReduce 4# 100# happyReduction_257-happyReduction_257 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut127 happy_x_3 of { (HappyWrap127 happy_var_3) -> - ( amsrl (sLL happy_var_1 happy_var_3 (snd $ unLoc happy_var_3))- (AnnList (Just $ glR happy_var_3) Nothing Nothing [mj AnnWhere happy_var_1] (fst $ unLoc happy_var_3)))}})- ) (\r -> happyReturn (happyIn116 r))--happyReduce_258 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_258 = happyMonadReduce 4# 101# happyReduction_258-happyReduction_258 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut274 happy_x_2 of { (HappyWrap274 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut153 happy_x_4 of { (HappyWrap153 happy_var_4) -> - ( acsA (\cs -> sLL happy_var_1 (reLoc happy_var_4)- $ PatSynSig (EpAnn (glR happy_var_1) (AnnSig (mu AnnDcolon happy_var_3) [mj AnnPattern happy_var_1]) cs)- (unLoc happy_var_2) happy_var_4))}}}})- ) (\r -> happyReturn (happyIn117 r))--happyReduce_259 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_259 = happySpecReduce_1 102# happyReduction_259-happyReduction_259 happy_x_1- = case happyOut300 happy_x_1 of { (HappyWrap300 happy_var_1) -> - happyIn118- (happy_var_1- )}--happyReduce_260 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_260 = happySpecReduce_1 102# happyReduction_260-happyReduction_260 happy_x_1- = case happyOut271 happy_x_1 of { (HappyWrap271 happy_var_1) -> - happyIn118- (happy_var_1- )}--happyReduce_261 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_261 = happySpecReduce_1 103# happyReduction_261-happyReduction_261 happy_x_1- = case happyOut95 happy_x_1 of { (HappyWrap95 happy_var_1) -> - happyIn119- (happy_var_1- )}--happyReduce_262 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_262 = happySpecReduce_1 103# happyReduction_262-happyReduction_262 happy_x_1- = case happyOut198 happy_x_1 of { (HappyWrap198 happy_var_1) -> - happyIn119- (happy_var_1- )}--happyReduce_263 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_263 = happyMonadReduce 4# 103# happyReduction_263-happyReduction_263 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut207 happy_x_2 of { (HappyWrap207 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut153 happy_x_4 of { (HappyWrap153 happy_var_4) -> - ( runPV (unECP happy_var_2) >>= \ happy_var_2 ->- do { v <- checkValSigLhs happy_var_2- ; let err = text "in default signature" <> colon <+>- quotes (ppr happy_var_2)- ; acsA (\cs -> sLL happy_var_1 (reLoc happy_var_4) $ SigD noExtField $ ClassOpSig (EpAnn (glR happy_var_1) (AnnSig (mu AnnDcolon happy_var_3) [mj AnnDefault happy_var_1]) cs) True [v] happy_var_4) })}}}})- ) (\r -> happyReturn (happyIn119 r))--happyReduce_264 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_264 = happyMonadReduce 3# 104# happyReduction_264-happyReduction_264 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut120 happy_x_1 of { (HappyWrap120 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut119 happy_x_3 of { (HappyWrap119 happy_var_3) -> - ( if isNilOL (snd $ unLoc happy_var_1)- then return (sLLlA happy_var_1 happy_var_3 ((fst $ unLoc happy_var_1) ++ (mz AnnSemi happy_var_2)- , unitOL happy_var_3))- else case (snd $ unLoc happy_var_1) of- SnocOL hs t -> do- t' <- addTrailingSemiA t (gl happy_var_2)- return (sLLlA happy_var_1 happy_var_3 (fst $ unLoc happy_var_1- , snocOL hs t' `appOL` unitOL happy_var_3)))}}})- ) (\r -> happyReturn (happyIn120 r))--happyReduce_265 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_265 = happyMonadReduce 2# 104# happyReduction_265-happyReduction_265 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut120 happy_x_1 of { (HappyWrap120 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( if isNilOL (snd $ unLoc happy_var_1)- then return (sLL happy_var_1 happy_var_2 ( (fst $ unLoc happy_var_1) ++ (mz AnnSemi happy_var_2)- ,snd $ unLoc happy_var_1))- else case (snd $ unLoc happy_var_1) of- SnocOL hs t -> do- t' <- addTrailingSemiA t (gl happy_var_2)- return (sLL happy_var_1 happy_var_2 (fst $ unLoc happy_var_1- , snocOL hs t')))}})- ) (\r -> happyReturn (happyIn120 r))--happyReduce_266 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_266 = happySpecReduce_1 104# happyReduction_266-happyReduction_266 happy_x_1- = case happyOut119 happy_x_1 of { (HappyWrap119 happy_var_1) -> - happyIn120- (sL1A happy_var_1 ([], unitOL happy_var_1)- )}--happyReduce_267 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_267 = happySpecReduce_0 104# happyReduction_267-happyReduction_267 = happyIn120- (noLoc ([],nilOL)- )--happyReduce_268 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_268 = happySpecReduce_3 105# happyReduction_268-happyReduction_268 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut120 happy_x_2 of { (HappyWrap120 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn121- (sLL happy_var_1 happy_var_3 (moc happy_var_1:mcc happy_var_3:(fst $ unLoc happy_var_2)- ,snd $ unLoc happy_var_2, ExplicitBraces)- )}}}--happyReduce_269 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_269 = happySpecReduce_3 105# happyReduction_269-happyReduction_269 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut120 happy_x_2 of { (HappyWrap120 happy_var_2) -> - happyIn121- (let { L l (anns, decls) = happy_var_2 }- in L l (anns, decls, VirtualBraces (getVOCURLY happy_var_1))- )}}--happyReduce_270 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_270 = happySpecReduce_2 106# happyReduction_270-happyReduction_270 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut121 happy_x_2 of { (HappyWrap121 happy_var_2) -> - happyIn122- (sLL happy_var_1 happy_var_2 (mj AnnWhere happy_var_1:(fstOf3 $ unLoc happy_var_2)- ,sndOf3 $ unLoc happy_var_2,thdOf3 $ unLoc happy_var_2)- )}}--happyReduce_271 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_271 = happySpecReduce_0 106# happyReduction_271-happyReduction_271 = happyIn122- (noLoc ([],nilOL,NoLayoutInfo)- )--happyReduce_272 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_272 = happySpecReduce_1 107# happyReduction_272-happyReduction_272 happy_x_1- = case happyOut98 happy_x_1 of { (HappyWrap98 happy_var_1) -> - happyIn123- (sL1A happy_var_1 (unitOL (sL1 happy_var_1 (InstD noExtField (unLoc happy_var_1))))- )}--happyReduce_273 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_273 = happySpecReduce_1 107# happyReduction_273-happyReduction_273 happy_x_1- = case happyOut198 happy_x_1 of { (HappyWrap198 happy_var_1) -> - happyIn123- (sL1A happy_var_1 (unitOL happy_var_1)- )}--happyReduce_274 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_274 = happyMonadReduce 3# 108# happyReduction_274-happyReduction_274 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut124 happy_x_1 of { (HappyWrap124 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut123 happy_x_3 of { (HappyWrap123 happy_var_3) -> - ( if isNilOL (snd $ unLoc happy_var_1)- then return (sLL happy_var_1 happy_var_3 ((fst $ unLoc happy_var_1) ++ (mz AnnSemi happy_var_2)- , unLoc happy_var_3))- else case (snd $ unLoc happy_var_1) of- SnocOL hs t -> do- t' <- addTrailingSemiA t (gl happy_var_2)- return (sLL happy_var_1 happy_var_3 (fst $ unLoc happy_var_1- , snocOL hs t' `appOL` unLoc happy_var_3)))}}})- ) (\r -> happyReturn (happyIn124 r))--happyReduce_275 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_275 = happyMonadReduce 2# 108# happyReduction_275-happyReduction_275 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut124 happy_x_1 of { (HappyWrap124 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( if isNilOL (snd $ unLoc happy_var_1)- then return (sLL happy_var_1 happy_var_2 ((fst $ unLoc happy_var_1) ++ (mz AnnSemi happy_var_2)- ,snd $ unLoc happy_var_1))- else case (snd $ unLoc happy_var_1) of- SnocOL hs t -> do- t' <- addTrailingSemiA t (gl happy_var_2)- return (sLL happy_var_1 happy_var_2 (fst $ unLoc happy_var_1- , snocOL hs t')))}})- ) (\r -> happyReturn (happyIn124 r))--happyReduce_276 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_276 = happySpecReduce_1 108# happyReduction_276-happyReduction_276 happy_x_1- = case happyOut123 happy_x_1 of { (HappyWrap123 happy_var_1) -> - happyIn124- (sL1 happy_var_1 ([],unLoc happy_var_1)- )}--happyReduce_277 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_277 = happySpecReduce_0 108# happyReduction_277-happyReduction_277 = happyIn124- (noLoc ([],nilOL)- )--happyReduce_278 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_278 = happySpecReduce_3 109# happyReduction_278-happyReduction_278 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut124 happy_x_2 of { (HappyWrap124 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn125- (sLL happy_var_1 happy_var_3 (moc happy_var_1:mcc happy_var_3:(fst $ unLoc happy_var_2),snd $ unLoc happy_var_2)- )}}}--happyReduce_279 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_279 = happySpecReduce_3 109# happyReduction_279-happyReduction_279 happy_x_3- happy_x_2- happy_x_1- = case happyOut124 happy_x_2 of { (HappyWrap124 happy_var_2) -> - happyIn125- (L (gl happy_var_2) (unLoc happy_var_2)- )}--happyReduce_280 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_280 = happySpecReduce_2 110# happyReduction_280-happyReduction_280 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut125 happy_x_2 of { (HappyWrap125 happy_var_2) -> - happyIn126- (sLL happy_var_1 happy_var_2 (mj AnnWhere happy_var_1:(fst $ unLoc happy_var_2)- ,(snd $ unLoc happy_var_2))- )}}--happyReduce_281 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_281 = happySpecReduce_0 110# happyReduction_281-happyReduction_281 = happyIn126- (noLoc ([],nilOL)- )--happyReduce_282 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_282 = happyMonadReduce 3# 111# happyReduction_282-happyReduction_282 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut127 happy_x_1 of { (HappyWrap127 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut198 happy_x_3 of { (HappyWrap198 happy_var_3) -> - ( if isNilOL (snd $ unLoc happy_var_1)- then return (sLLlA happy_var_1 happy_var_3 ((fst $ unLoc happy_var_1) ++ (msemi happy_var_2)- , unitOL happy_var_3))- else case (snd $ unLoc happy_var_1) of- SnocOL hs t -> do- t' <- addTrailingSemiA t (gl happy_var_2)- let { this = unitOL happy_var_3;- rest = snocOL hs t';- these = rest `appOL` this }- return (rest `seq` this `seq` these `seq`- (sLLlA happy_var_1 happy_var_3 (fst $ unLoc happy_var_1, these))))}}})- ) (\r -> happyReturn (happyIn127 r))--happyReduce_283 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_283 = happyMonadReduce 2# 111# happyReduction_283-happyReduction_283 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut127 happy_x_1 of { (HappyWrap127 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( if isNilOL (snd $ unLoc happy_var_1)- then return (sLL happy_var_1 happy_var_2 (((fst $ unLoc happy_var_1) ++ (msemi happy_var_2)- ,snd $ unLoc happy_var_1)))- else case (snd $ unLoc happy_var_1) of- SnocOL hs t -> do- t' <- addTrailingSemiA t (gl happy_var_2)- return (sLL happy_var_1 happy_var_2 (fst $ unLoc happy_var_1- , snocOL hs t')))}})- ) (\r -> happyReturn (happyIn127 r))--happyReduce_284 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_284 = happySpecReduce_1 111# happyReduction_284-happyReduction_284 happy_x_1- = case happyOut198 happy_x_1 of { (HappyWrap198 happy_var_1) -> - happyIn127- (sL1A happy_var_1 ([], unitOL happy_var_1)- )}--happyReduce_285 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_285 = happySpecReduce_0 111# happyReduction_285-happyReduction_285 = happyIn127- (noLoc ([],nilOL)- )--happyReduce_286 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_286 = happySpecReduce_3 112# happyReduction_286-happyReduction_286 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut127 happy_x_2 of { (HappyWrap127 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn128- (sLL happy_var_1 happy_var_3 (AnnList (Just $ glR happy_var_2) (Just $ moc happy_var_1) (Just $ mcc happy_var_3) [] (fst $ unLoc happy_var_2)- ,sL1 happy_var_2 $ snd $ unLoc happy_var_2)- )}}}--happyReduce_287 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_287 = happySpecReduce_3 112# happyReduction_287-happyReduction_287 happy_x_3- happy_x_2- happy_x_1- = case happyOut127 happy_x_2 of { (HappyWrap127 happy_var_2) -> - happyIn128- (L (gl happy_var_2) (AnnList (Just $ glR happy_var_2) Nothing Nothing [] (fst $ unLoc happy_var_2)- ,sL1 happy_var_2 $ snd $ unLoc happy_var_2)- )}--happyReduce_288 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_288 = happyMonadReduce 1# 113# happyReduction_288-happyReduction_288 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut128 happy_x_1 of { (HappyWrap128 happy_var_1) -> - ( do { val_binds <- cvBindGroup (unLoc $ snd $ unLoc happy_var_1)- ; cs <- getCommentsFor (gl happy_var_1)- ; return (sL1 happy_var_1 $ HsValBinds (EpAnn (glR happy_var_1) (fst $ unLoc happy_var_1) cs) val_binds)})})- ) (\r -> happyReturn (happyIn129 r))--happyReduce_289 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_289 = happyMonadReduce 3# 113# happyReduction_289-happyReduction_289 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut259 happy_x_2 of { (HappyWrap259 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( acs (\cs -> (L (comb3 happy_var_1 happy_var_2 happy_var_3)- $ HsIPBinds (EpAnn (glR happy_var_1) (AnnList (Just$ glR happy_var_2) (Just $ moc happy_var_1) (Just $ mcc happy_var_3) [] []) cs) (IPBinds noExtField (reverse $ unLoc happy_var_2)))))}}})- ) (\r -> happyReturn (happyIn129 r))--happyReduce_290 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_290 = happyMonadReduce 3# 113# happyReduction_290-happyReduction_290 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut259 happy_x_2 of { (HappyWrap259 happy_var_2) -> - ( acs (\cs -> (L (gl happy_var_2)- $ HsIPBinds (EpAnn (glR happy_var_1) (AnnList (Just $ glR happy_var_2) Nothing Nothing [] []) cs) (IPBinds noExtField (reverse $ unLoc happy_var_2)))))}})- ) (\r -> happyReturn (happyIn129 r))--happyReduce_291 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_291 = happyMonadReduce 2# 114# happyReduction_291-happyReduction_291 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut129 happy_x_2 of { (HappyWrap129 happy_var_2) -> - ( do { r <- acs (\cs ->- (sLL happy_var_1 happy_var_2 (annBinds (mj AnnWhere happy_var_1) cs (unLoc happy_var_2))))- ; return $ Just r})}})- ) (\r -> happyReturn (happyIn130 r))--happyReduce_292 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_292 = happySpecReduce_0 114# happyReduction_292-happyReduction_292 = happyIn130- (Nothing- )--happyReduce_293 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_293 = happyMonadReduce 3# 115# happyReduction_293-happyReduction_293 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut131 happy_x_1 of { (HappyWrap131 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut132 happy_x_3 of { (HappyWrap132 happy_var_3) -> - ( case happy_var_1 of- [] -> return (happy_var_3:happy_var_1)- (h:t) -> do- h' <- addTrailingSemiA h (gl happy_var_2)- return (happy_var_3:h':t))}}})- ) (\r -> happyReturn (happyIn131 r))--happyReduce_294 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_294 = happyMonadReduce 2# 115# happyReduction_294-happyReduction_294 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut131 happy_x_1 of { (HappyWrap131 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( case happy_var_1 of- [] -> return happy_var_1- (h:t) -> do- h' <- addTrailingSemiA h (gl happy_var_2)- return (h':t))}})- ) (\r -> happyReturn (happyIn131 r))--happyReduce_295 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_295 = happySpecReduce_1 115# happyReduction_295-happyReduction_295 happy_x_1- = case happyOut132 happy_x_1 of { (HappyWrap132 happy_var_1) -> - happyIn131- ([happy_var_1]- )}--happyReduce_296 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_296 = happySpecReduce_0 115# happyReduction_296-happyReduction_296 = happyIn131- ([]- )--happyReduce_297 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_297 = happyMonadReduce 6# 116# happyReduction_297-happyReduction_297 (happy_x_6 `HappyStk`- happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut133 happy_x_2 of { (HappyWrap133 happy_var_2) -> - case happyOut136 happy_x_3 of { (HappyWrap136 happy_var_3) -> - case happyOut207 happy_x_4 of { (HappyWrap207 happy_var_4) -> - case happyOutTok happy_x_5 of { happy_var_5 -> - case happyOut206 happy_x_6 of { (HappyWrap206 happy_var_6) -> - (runPV (unECP happy_var_4) >>= \ happy_var_4 ->- runPV (unECP happy_var_6) >>= \ happy_var_6 ->- acsA (\cs -> (sLLlA happy_var_1 happy_var_6 $ HsRule- { rd_ext = EpAnn (glR happy_var_1) ((fstOf3 happy_var_3) (mj AnnEqual happy_var_5 : (fst happy_var_2))) cs- , rd_name = L (gl happy_var_1) (getSTRINGs happy_var_1, getSTRING happy_var_1)- , rd_act = (snd happy_var_2) `orElse` AlwaysActive- , rd_tyvs = sndOf3 happy_var_3, rd_tmvs = thdOf3 happy_var_3- , rd_lhs = happy_var_4, rd_rhs = happy_var_6 })))}}}}}})- ) (\r -> happyReturn (happyIn132 r))--happyReduce_298 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_298 = happySpecReduce_0 117# happyReduction_298-happyReduction_298 = happyIn133- (([],Nothing)- )--happyReduce_299 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_299 = happySpecReduce_1 117# happyReduction_299-happyReduction_299 happy_x_1- = case happyOut135 happy_x_1 of { (HappyWrap135 happy_var_1) -> - happyIn133- ((fst happy_var_1,Just (snd happy_var_1))- )}--happyReduce_300 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_300 = happySpecReduce_1 118# happyReduction_300-happyReduction_300 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn134- ([mj AnnTilde happy_var_1]- )}--happyReduce_301 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_301 = happyMonadReduce 1# 118# happyReduction_301-happyReduction_301 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - ( if (getVARSYM happy_var_1 == fsLit "~")- then return [mj AnnTilde happy_var_1]- else do { addError $ PsError PsErrInvalidRuleActivationMarker [] (getLoc happy_var_1)- ; return [] })})- ) (\r -> happyReturn (happyIn134 r))--happyReduce_302 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_302 = happySpecReduce_3 119# happyReduction_302-happyReduction_302 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn135- (([mos happy_var_1,mj AnnVal happy_var_2,mcs happy_var_3]- ,ActiveAfter (getINTEGERs happy_var_2) (fromInteger (il_value (getINTEGER happy_var_2))))- )}}}--happyReduce_303 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_303 = happyReduce 4# 119# happyReduction_303-happyReduction_303 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut134 happy_x_2 of { (HappyWrap134 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - happyIn135- ((happy_var_2++[mos happy_var_1,mj AnnVal happy_var_3,mcs happy_var_4]- ,ActiveBefore (getINTEGERs happy_var_3) (fromInteger (il_value (getINTEGER happy_var_3))))- ) `HappyStk` happyRest}}}}--happyReduce_304 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_304 = happySpecReduce_3 119# happyReduction_304-happyReduction_304 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut134 happy_x_2 of { (HappyWrap134 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn135- ((happy_var_2++[mos happy_var_1,mcs happy_var_3]- ,NeverActive)- )}}}--happyReduce_305 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_305 = happyMonadReduce 6# 120# happyReduction_305-happyReduction_305 (happy_x_6 `HappyStk`- happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut137 happy_x_2 of { (HappyWrap137 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - case happyOut137 happy_x_5 of { (HappyWrap137 happy_var_5) -> - case happyOutTok happy_x_6 of { happy_var_6 -> - ( let tyvs = mkRuleTyVarBndrs happy_var_2- in hintExplicitForall happy_var_1- >> checkRuleTyVarBndrNames (mkRuleTyVarBndrs happy_var_2)- >> return (\anns -> HsRuleAnn- (Just (mu AnnForall happy_var_1,mj AnnDot happy_var_3))- (Just (mu AnnForall happy_var_4,mj AnnDot happy_var_6))- anns,- Just (mkRuleTyVarBndrs happy_var_2), mkRuleBndrs happy_var_5))}}}}}})- ) (\r -> happyReturn (happyIn136 r))--happyReduce_306 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_306 = happySpecReduce_3 120# happyReduction_306-happyReduction_306 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut137 happy_x_2 of { (HappyWrap137 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn136- ((\anns -> HsRuleAnn Nothing (Just (mu AnnForall happy_var_1,mj AnnDot happy_var_3)) anns,- Nothing, mkRuleBndrs happy_var_2)- )}}}--happyReduce_307 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_307 = happySpecReduce_0 120# happyReduction_307-happyReduction_307 = happyIn136- ((\anns -> HsRuleAnn Nothing Nothing anns, Nothing, [])- )--happyReduce_308 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_308 = happySpecReduce_2 121# happyReduction_308-happyReduction_308 happy_x_2- happy_x_1- = case happyOut138 happy_x_1 of { (HappyWrap138 happy_var_1) -> - case happyOut137 happy_x_2 of { (HappyWrap137 happy_var_2) -> - happyIn137- (happy_var_1 : happy_var_2- )}}--happyReduce_309 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_309 = happySpecReduce_0 121# happyReduction_309-happyReduction_309 = happyIn137- ([]- )--happyReduce_310 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_310 = happySpecReduce_1 122# happyReduction_310-happyReduction_310 happy_x_1- = case happyOut303 happy_x_1 of { (HappyWrap303 happy_var_1) -> - happyIn138- (sL1N happy_var_1 (RuleTyTmVar noAnn happy_var_1 Nothing)- )}--happyReduce_311 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_311 = happyMonadReduce 5# 122# happyReduction_311-happyReduction_311 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut303 happy_x_2 of { (HappyWrap303 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut159 happy_x_4 of { (HappyWrap159 happy_var_4) -> - case happyOutTok happy_x_5 of { happy_var_5 -> - ( acs (\cs -> sLL happy_var_1 happy_var_5 (RuleTyTmVar (EpAnn (glR happy_var_1) [mop happy_var_1,mu AnnDcolon happy_var_3,mcp happy_var_5] cs) happy_var_2 (Just happy_var_4))))}}}}})- ) (\r -> happyReturn (happyIn138 r))--happyReduce_312 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_312 = happyMonadReduce 3# 123# happyReduction_312-happyReduction_312 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut139 happy_x_1 of { (HappyWrap139 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut140 happy_x_3 of { (HappyWrap140 happy_var_3) -> - ( if isNilOL happy_var_1- then return (happy_var_1 `appOL` happy_var_3)- else case happy_var_1 of- SnocOL hs t -> do- t' <- addTrailingSemiA t (gl happy_var_2)- return (snocOL hs t' `appOL` happy_var_3))}}})- ) (\r -> happyReturn (happyIn139 r))--happyReduce_313 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_313 = happyMonadReduce 2# 123# happyReduction_313-happyReduction_313 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut139 happy_x_1 of { (HappyWrap139 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( if isNilOL happy_var_1- then return happy_var_1- else case happy_var_1 of- SnocOL hs t -> do- t' <- addTrailingSemiA t (gl happy_var_2)- return (snocOL hs t'))}})- ) (\r -> happyReturn (happyIn139 r))--happyReduce_314 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_314 = happySpecReduce_1 123# happyReduction_314-happyReduction_314 happy_x_1- = case happyOut140 happy_x_1 of { (HappyWrap140 happy_var_1) -> - happyIn139- (happy_var_1- )}--happyReduce_315 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_315 = happySpecReduce_0 123# happyReduction_315-happyReduction_315 = happyIn139- (nilOL- )--happyReduce_316 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_316 = happyMonadReduce 2# 124# happyReduction_316-happyReduction_316 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut268 happy_x_1 of { (HappyWrap268 happy_var_1) -> - case happyOut143 happy_x_2 of { (HappyWrap143 happy_var_2) -> - ( fmap unitOL $ acsA (\cs -> sLL happy_var_1 happy_var_2- (Warning (EpAnn (glR happy_var_1) (fst $ unLoc happy_var_2) cs) (unLoc happy_var_1)- (WarningTxt (noLoc NoSourceText) $ snd $ unLoc happy_var_2))))}})- ) (\r -> happyReturn (happyIn140 r))--happyReduce_317 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_317 = happyMonadReduce 3# 125# happyReduction_317-happyReduction_317 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut141 happy_x_1 of { (HappyWrap141 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut142 happy_x_3 of { (HappyWrap142 happy_var_3) -> - ( if isNilOL happy_var_1- then return (happy_var_1 `appOL` happy_var_3)- else case happy_var_1 of- SnocOL hs t -> do- t' <- addTrailingSemiA t (gl happy_var_2)- return (snocOL hs t' `appOL` happy_var_3))}}})- ) (\r -> happyReturn (happyIn141 r))--happyReduce_318 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_318 = happyMonadReduce 2# 125# happyReduction_318-happyReduction_318 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut141 happy_x_1 of { (HappyWrap141 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( if isNilOL happy_var_1- then return happy_var_1- else case happy_var_1 of- SnocOL hs t -> do- t' <- addTrailingSemiA t (gl happy_var_2)- return (snocOL hs t'))}})- ) (\r -> happyReturn (happyIn141 r))--happyReduce_319 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_319 = happySpecReduce_1 125# happyReduction_319-happyReduction_319 happy_x_1- = case happyOut142 happy_x_1 of { (HappyWrap142 happy_var_1) -> - happyIn141- (happy_var_1- )}--happyReduce_320 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_320 = happySpecReduce_0 125# happyReduction_320-happyReduction_320 = happyIn141- (nilOL- )--happyReduce_321 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_321 = happyMonadReduce 2# 126# happyReduction_321-happyReduction_321 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut268 happy_x_1 of { (HappyWrap268 happy_var_1) -> - case happyOut143 happy_x_2 of { (HappyWrap143 happy_var_2) -> - ( fmap unitOL $ acsA (\cs -> sLL happy_var_1 happy_var_2 $ (Warning (EpAnn (glR happy_var_1) (fst $ unLoc happy_var_2) cs) (unLoc happy_var_1)- (DeprecatedTxt (noLoc NoSourceText) $ snd $ unLoc happy_var_2))))}})- ) (\r -> happyReturn (happyIn142 r))--happyReduce_322 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_322 = happySpecReduce_1 127# happyReduction_322-happyReduction_322 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn143- (sL1 happy_var_1 ([],[L (gl happy_var_1) (getStringLiteral happy_var_1)])- )}--happyReduce_323 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_323 = happySpecReduce_3 127# happyReduction_323-happyReduction_323 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut144 happy_x_2 of { (HappyWrap144 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn143- (sLL happy_var_1 happy_var_3 $ ([mos happy_var_1,mcs happy_var_3],fromOL (unLoc happy_var_2))- )}}}--happyReduce_324 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_324 = happyMonadReduce 3# 128# happyReduction_324-happyReduction_324 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut144 happy_x_1 of { (HappyWrap144 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( if isNilOL (unLoc happy_var_1)- then return (sLL happy_var_1 happy_var_3 (unLoc happy_var_1 `snocOL`- (L (gl happy_var_3) (getStringLiteral happy_var_3))))- else case (unLoc happy_var_1) of- SnocOL hs t -> do- let { t' = addTrailingCommaS t (glAA happy_var_2) }- return (sLL happy_var_1 happy_var_3 (snocOL hs t' `snocOL`- (L (gl happy_var_3) (getStringLiteral happy_var_3)))))}}})- ) (\r -> happyReturn (happyIn144 r))--happyReduce_325 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_325 = happySpecReduce_1 128# happyReduction_325-happyReduction_325 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn144- (sLL happy_var_1 happy_var_1 (unitOL (L (gl happy_var_1) (getStringLiteral happy_var_1)))- )}--happyReduce_326 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_326 = happySpecReduce_0 128# happyReduction_326-happyReduction_326 = happyIn144- (noLoc nilOL- )--happyReduce_327 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_327 = happyMonadReduce 4# 129# happyReduction_327-happyReduction_327 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut269 happy_x_2 of { (HappyWrap269 happy_var_2) -> - case happyOut213 happy_x_3 of { (HappyWrap213 happy_var_3) -> - case happyOutTok happy_x_4 of { happy_var_4 -> - ( runPV (unECP happy_var_3) >>= \ happy_var_3 ->- acsA (\cs -> sLL happy_var_1 happy_var_4 (AnnD noExtField $ HsAnnotation- (EpAnn (glR happy_var_1) (AnnPragma (mo happy_var_1) (mc happy_var_4) []) cs)- (getANN_PRAGs happy_var_1)- (ValueAnnProvenance happy_var_2) happy_var_3)))}}}})- ) (\r -> happyReturn (happyIn145 r))--happyReduce_328 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_328 = happyMonadReduce 5# 129# happyReduction_328-happyReduction_328 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut288 happy_x_3 of { (HappyWrap288 happy_var_3) -> - case happyOut213 happy_x_4 of { (HappyWrap213 happy_var_4) -> - case happyOutTok happy_x_5 of { happy_var_5 -> - ( runPV (unECP happy_var_4) >>= \ happy_var_4 ->- acsA (\cs -> sLL happy_var_1 happy_var_5 (AnnD noExtField $ HsAnnotation- (EpAnn (glR happy_var_1) (AnnPragma (mo happy_var_1) (mc happy_var_5) [mj AnnType happy_var_2]) cs)- (getANN_PRAGs happy_var_1)- (TypeAnnProvenance happy_var_3) happy_var_4)))}}}}})- ) (\r -> happyReturn (happyIn145 r))--happyReduce_329 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_329 = happyMonadReduce 4# 129# happyReduction_329-happyReduction_329 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut213 happy_x_3 of { (HappyWrap213 happy_var_3) -> - case happyOutTok happy_x_4 of { happy_var_4 -> - ( runPV (unECP happy_var_3) >>= \ happy_var_3 ->- acsA (\cs -> sLL happy_var_1 happy_var_4 (AnnD noExtField $ HsAnnotation- (EpAnn (glR happy_var_1) (AnnPragma (mo happy_var_1) (mc happy_var_4) [mj AnnModule happy_var_2]) cs)- (getANN_PRAGs happy_var_1)- ModuleAnnProvenance happy_var_3)))}}}})- ) (\r -> happyReturn (happyIn145 r))--happyReduce_330 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_330 = happyMonadReduce 4# 130# happyReduction_330-happyReduction_330 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut147 happy_x_2 of { (HappyWrap147 happy_var_2) -> - case happyOut148 happy_x_3 of { (HappyWrap148 happy_var_3) -> - case happyOut149 happy_x_4 of { (HappyWrap149 happy_var_4) -> - ( mkImport happy_var_2 happy_var_3 (snd $ unLoc happy_var_4) >>= \i ->- return (sLL happy_var_1 happy_var_4 (mj AnnImport happy_var_1 : (fst $ unLoc happy_var_4),i)))}}}})- ) (\r -> happyReturn (happyIn146 r))--happyReduce_331 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_331 = happyMonadReduce 3# 130# happyReduction_331-happyReduction_331 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut147 happy_x_2 of { (HappyWrap147 happy_var_2) -> - case happyOut149 happy_x_3 of { (HappyWrap149 happy_var_3) -> - ( do { d <- mkImport happy_var_2 (noLoc PlaySafe) (snd $ unLoc happy_var_3);- return (sLL happy_var_1 happy_var_3 (mj AnnImport happy_var_1 : (fst $ unLoc happy_var_3),d)) })}}})- ) (\r -> happyReturn (happyIn146 r))--happyReduce_332 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_332 = happyMonadReduce 3# 130# happyReduction_332-happyReduction_332 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut147 happy_x_2 of { (HappyWrap147 happy_var_2) -> - case happyOut149 happy_x_3 of { (HappyWrap149 happy_var_3) -> - ( mkExport happy_var_2 (snd $ unLoc happy_var_3) >>= \i ->- return (sLL happy_var_1 happy_var_3 (mj AnnExport happy_var_1 : (fst $ unLoc happy_var_3),i) ))}}})- ) (\r -> happyReturn (happyIn146 r))--happyReduce_333 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_333 = happySpecReduce_1 131# happyReduction_333-happyReduction_333 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn147- (sLL happy_var_1 happy_var_1 StdCallConv- )}--happyReduce_334 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_334 = happySpecReduce_1 131# happyReduction_334-happyReduction_334 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn147- (sLL happy_var_1 happy_var_1 CCallConv- )}--happyReduce_335 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_335 = happySpecReduce_1 131# happyReduction_335-happyReduction_335 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn147- (sLL happy_var_1 happy_var_1 CApiConv- )}--happyReduce_336 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_336 = happySpecReduce_1 131# happyReduction_336-happyReduction_336 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn147- (sLL happy_var_1 happy_var_1 PrimCallConv- )}--happyReduce_337 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_337 = happySpecReduce_1 131# happyReduction_337-happyReduction_337 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn147- (sLL happy_var_1 happy_var_1 JavaScriptCallConv- )}--happyReduce_338 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_338 = happySpecReduce_1 132# happyReduction_338-happyReduction_338 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn148- (sLL happy_var_1 happy_var_1 PlayRisky- )}--happyReduce_339 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_339 = happySpecReduce_1 132# happyReduction_339-happyReduction_339 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn148- (sLL happy_var_1 happy_var_1 PlaySafe- )}--happyReduce_340 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_340 = happySpecReduce_1 132# happyReduction_340-happyReduction_340 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn148- (sLL happy_var_1 happy_var_1 PlayInterruptible- )}--happyReduce_341 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_341 = happyReduce 4# 133# happyReduction_341-happyReduction_341 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut299 happy_x_2 of { (HappyWrap299 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut153 happy_x_4 of { (HappyWrap153 happy_var_4) -> - happyIn149- (sLL happy_var_1 (reLoc happy_var_4) ([mu AnnDcolon happy_var_3]- ,(L (getLoc happy_var_1)- (getStringLiteral happy_var_1), happy_var_2, happy_var_4))- ) `HappyStk` happyRest}}}}--happyReduce_342 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_342 = happySpecReduce_3 133# happyReduction_342-happyReduction_342 happy_x_3- happy_x_2- happy_x_1- = case happyOut299 happy_x_1 of { (HappyWrap299 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut153 happy_x_3 of { (HappyWrap153 happy_var_3) -> - happyIn149- (sLL (reLocN happy_var_1) (reLoc happy_var_3) ([mu AnnDcolon happy_var_2]- ,(noLoc (StringLiteral NoSourceText nilFS Nothing), happy_var_1, happy_var_3))- )}}}--happyReduce_343 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_343 = happySpecReduce_0 134# happyReduction_343-happyReduction_343 = happyIn150- (Nothing- )--happyReduce_344 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_344 = happySpecReduce_2 134# happyReduction_344-happyReduction_344 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut159 happy_x_2 of { (HappyWrap159 happy_var_2) -> - happyIn150- (Just (mu AnnDcolon happy_var_1, happy_var_2)- )}}--happyReduce_345 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_345 = happySpecReduce_0 135# happyReduction_345-happyReduction_345 = happyIn151- (([], Nothing)- )--happyReduce_346 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_346 = happySpecReduce_2 135# happyReduction_346-happyReduction_346 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut279 happy_x_2 of { (HappyWrap279 happy_var_2) -> - happyIn151- (([mu AnnDcolon happy_var_1], Just happy_var_2)- )}}--happyReduce_347 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_347 = happySpecReduce_1 136# happyReduction_347-happyReduction_347 happy_x_1- = case happyOut153 happy_x_1 of { (HappyWrap153 happy_var_1) -> - happyIn152- (happy_var_1- )}--happyReduce_348 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_348 = happyMonadReduce 3# 136# happyReduction_348-happyReduction_348 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut159 happy_x_1 of { (HappyWrap159 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut181 happy_x_3 of { (HappyWrap181 happy_var_3) -> - ( acsA (\cs -> sLLAA happy_var_1 happy_var_3 $ mkHsImplicitSigType $- sLLa (reLoc happy_var_1) (reLoc happy_var_3) $ HsKindSig (EpAnn (glAR happy_var_1) [mu AnnDcolon happy_var_2] cs) happy_var_1 happy_var_3))}}})- ) (\r -> happyReturn (happyIn152 r))--happyReduce_349 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_349 = happySpecReduce_1 137# happyReduction_349-happyReduction_349 happy_x_1- = case happyOut159 happy_x_1 of { (HappyWrap159 happy_var_1) -> - happyIn153- (hsTypeToHsSigType happy_var_1- )}--happyReduce_350 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_350 = happyMonadReduce 3# 138# happyReduction_350-happyReduction_350 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut154 happy_x_1 of { (HappyWrap154 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut299 happy_x_3 of { (HappyWrap299 happy_var_3) -> - ( case unLoc happy_var_1 of- [] -> return (sLL happy_var_1 (reLocN happy_var_3) (happy_var_3 : unLoc happy_var_1))- (h:t) -> do- h' <- addTrailingCommaN h (gl happy_var_2)- return (sLL happy_var_1 (reLocN happy_var_3) (happy_var_3 : h' : t)))}}})- ) (\r -> happyReturn (happyIn154 r))--happyReduce_351 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_351 = happySpecReduce_1 138# happyReduction_351-happyReduction_351 happy_x_1- = case happyOut299 happy_x_1 of { (HappyWrap299 happy_var_1) -> - happyIn154- (sL1N happy_var_1 [happy_var_1]- )}--happyReduce_352 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_352 = happySpecReduce_1 139# happyReduction_352-happyReduction_352 happy_x_1- = case happyOut153 happy_x_1 of { (HappyWrap153 happy_var_1) -> - happyIn155- (unitOL happy_var_1- )}--happyReduce_353 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_353 = happyMonadReduce 3# 139# happyReduction_353-happyReduction_353 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut153 happy_x_1 of { (HappyWrap153 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut155 happy_x_3 of { (HappyWrap155 happy_var_3) -> - ( do { st <- addTrailingCommaA happy_var_1 (gl happy_var_2)- ; return $ unitOL st `appOL` happy_var_3 })}}})- ) (\r -> happyReturn (happyIn155 r))--happyReduce_354 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_354 = happySpecReduce_2 140# happyReduction_354-happyReduction_354 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - happyIn156- (sLL happy_var_1 happy_var_2 (UnpackednessPragma [mo happy_var_1, mc happy_var_2] (getUNPACK_PRAGs happy_var_1) SrcUnpack)- )}}--happyReduce_355 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_355 = happySpecReduce_2 140# happyReduction_355-happyReduction_355 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - happyIn156- (sLL happy_var_1 happy_var_2 (UnpackednessPragma [mo happy_var_1, mc happy_var_2] (getNOUNPACK_PRAGs happy_var_1) SrcNoUnpack)- )}}--happyReduce_356 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_356 = happyMonadReduce 3# 141# happyReduction_356-happyReduction_356 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut174 happy_x_2 of { (HappyWrap174 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( do { hintExplicitForall happy_var_1- ; acs (\cs -> (sLL happy_var_1 happy_var_3 $- mkHsForAllInvisTele (EpAnn (glR happy_var_1) (mu AnnForall happy_var_1,mu AnnDot happy_var_3) cs) happy_var_2 )) })}}})- ) (\r -> happyReturn (happyIn157 r))--happyReduce_357 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_357 = happyMonadReduce 3# 141# happyReduction_357-happyReduction_357 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut174 happy_x_2 of { (HappyWrap174 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( do { hintExplicitForall happy_var_1- ; req_tvbs <- fromSpecTyVarBndrs happy_var_2- ; acs (\cs -> (sLL happy_var_1 happy_var_3 $- mkHsForAllVisTele (EpAnn (glR happy_var_1) (mu AnnForall happy_var_1,mu AnnRarrow happy_var_3) cs) req_tvbs )) })}}})- ) (\r -> happyReturn (happyIn157 r))--happyReduce_358 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_358 = happySpecReduce_1 142# happyReduction_358-happyReduction_358 happy_x_1- = case happyOut159 happy_x_1 of { (HappyWrap159 happy_var_1) -> - happyIn158- (happy_var_1- )}--happyReduce_359 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_359 = happyMonadReduce 3# 142# happyReduction_359-happyReduction_359 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut159 happy_x_1 of { (HappyWrap159 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut181 happy_x_3 of { (HappyWrap181 happy_var_3) -> - ( acsA (\cs -> sLLAA happy_var_1 happy_var_3 $ HsKindSig (EpAnn (glAR happy_var_1) [mu AnnDcolon happy_var_2] cs) happy_var_1 happy_var_3))}}})- ) (\r -> happyReturn (happyIn158 r))--happyReduce_360 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_360 = happySpecReduce_2 143# happyReduction_360-happyReduction_360 happy_x_2- happy_x_1- = case happyOut157 happy_x_1 of { (HappyWrap157 happy_var_1) -> - case happyOut159 happy_x_2 of { (HappyWrap159 happy_var_2) -> - happyIn159- (reLocA $ sLL happy_var_1 (reLoc happy_var_2) $- HsForAllTy { hst_tele = unLoc happy_var_1- , hst_xforall = noExtField- , hst_body = happy_var_2 }- )}}--happyReduce_361 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_361 = happyMonadReduce 3# 143# happyReduction_361-happyReduction_361 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut160 happy_x_1 of { (HappyWrap160 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut159 happy_x_3 of { (HappyWrap159 happy_var_3) -> - ( acsA (\cs -> (sLL (reLoc happy_var_1) (reLoc happy_var_3) $- HsQualTy { hst_ctxt = Just (addTrailingDarrowC happy_var_1 happy_var_2 cs)- , hst_xqual = NoExtField- , hst_body = happy_var_3 })))}}})- ) (\r -> happyReturn (happyIn159 r))--happyReduce_362 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_362 = happyMonadReduce 3# 143# happyReduction_362-happyReduction_362 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut261 happy_x_1 of { (HappyWrap261 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut161 happy_x_3 of { (HappyWrap161 happy_var_3) -> - ( acsA (\cs -> sLL happy_var_1 (reLoc happy_var_3) (HsIParamTy (EpAnn (glR happy_var_1) [mu AnnDcolon happy_var_2] cs) happy_var_1 happy_var_3)))}}})- ) (\r -> happyReturn (happyIn159 r))--happyReduce_363 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_363 = happySpecReduce_1 143# happyReduction_363-happyReduction_363 happy_x_1- = case happyOut161 happy_x_1 of { (HappyWrap161 happy_var_1) -> - happyIn159- (happy_var_1- )}--happyReduce_364 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_364 = happyMonadReduce 1# 144# happyReduction_364-happyReduction_364 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut163 happy_x_1 of { (HappyWrap163 happy_var_1) -> - ( checkContext happy_var_1)})- ) (\r -> happyReturn (happyIn160 r))--happyReduce_365 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_365 = happySpecReduce_1 145# happyReduction_365-happyReduction_365 happy_x_1- = case happyOut163 happy_x_1 of { (HappyWrap163 happy_var_1) -> - happyIn161- (happy_var_1- )}--happyReduce_366 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_366 = happyMonadReduce 3# 145# happyReduction_366-happyReduction_366 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut163 happy_x_1 of { (HappyWrap163 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut159 happy_x_3 of { (HappyWrap159 happy_var_3) -> - ( acsA (\cs -> sLL (reLoc happy_var_1) (reLoc happy_var_3)- $ HsFunTy (EpAnn (glAR happy_var_1) (mau happy_var_2) cs) (HsUnrestrictedArrow (toUnicode happy_var_2)) happy_var_1 happy_var_3))}}})- ) (\r -> happyReturn (happyIn161 r))--happyReduce_367 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_367 = happyMonadReduce 4# 145# happyReduction_367-happyReduction_367 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut163 happy_x_1 of { (HappyWrap163 happy_var_1) -> - case happyOut162 happy_x_2 of { (HappyWrap162 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut159 happy_x_4 of { (HappyWrap159 happy_var_4) -> - ( hintLinear (getLoc happy_var_2)- >> let arr = (unLoc happy_var_2) (toUnicode happy_var_3)- in acsA (\cs -> sLL (reLoc happy_var_1) (reLoc happy_var_4)- $ HsFunTy (EpAnn (glAR happy_var_1) (mau happy_var_3) cs) arr happy_var_1 happy_var_4))}}}})- ) (\r -> happyReturn (happyIn161 r))--happyReduce_368 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_368 = happyMonadReduce 3# 145# happyReduction_368-happyReduction_368 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut163 happy_x_1 of { (HappyWrap163 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut159 happy_x_3 of { (HappyWrap159 happy_var_3) -> - ( hintLinear (getLoc happy_var_2) >>- acsA (\cs -> sLL (reLoc happy_var_1) (reLoc happy_var_3)- $ HsFunTy (EpAnn (glAR happy_var_1) (mlu happy_var_2) cs) (HsLinearArrow UnicodeSyntax Nothing) happy_var_1 happy_var_3))}}})- ) (\r -> happyReturn (happyIn161 r))--happyReduce_369 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_369 = happySpecReduce_2 146# happyReduction_369-happyReduction_369 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut168 happy_x_2 of { (HappyWrap168 happy_var_2) -> - happyIn162- (sLL happy_var_1 (reLoc happy_var_2) (\u -> mkMultTy u happy_var_1 happy_var_2)- )}}--happyReduce_370 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_370 = happyMonadReduce 1# 147# happyReduction_370-happyReduction_370 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut164 happy_x_1 of { (HappyWrap164 happy_var_1) -> - ( runPV happy_var_1)})- ) (\r -> happyReturn (happyIn163 r))--happyReduce_371 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_371 = happySpecReduce_1 148# happyReduction_371-happyReduction_371 happy_x_1- = case happyOut165 happy_x_1 of { (HappyWrap165 happy_var_1) -> - happyIn164- (happy_var_1- )}--happyReduce_372 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_372 = happySpecReduce_3 148# happyReduction_372-happyReduction_372 happy_x_3- happy_x_2- happy_x_1- = case happyOut165 happy_x_1 of { (HappyWrap165 happy_var_1) -> - case happyOut167 happy_x_2 of { (HappyWrap167 happy_var_2) -> - case happyOut164 happy_x_3 of { (HappyWrap164 happy_var_3) -> - happyIn164- (happy_var_1 >>= \ happy_var_1 ->- happy_var_3 >>= \ happy_var_3 ->- do { when (looksLikeMult happy_var_1 happy_var_2 happy_var_3) $ hintLinear (getLocA happy_var_2)- ; mkHsOpTyPV happy_var_1 happy_var_2 happy_var_3 }- )}}}--happyReduce_373 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_373 = happySpecReduce_2 148# happyReduction_373-happyReduction_373 happy_x_2- happy_x_1- = case happyOut156 happy_x_1 of { (HappyWrap156 happy_var_1) -> - case happyOut164 happy_x_2 of { (HappyWrap164 happy_var_2) -> - happyIn164- (happy_var_2 >>= \ happy_var_2 ->- mkUnpackednessPV happy_var_1 happy_var_2- )}}--happyReduce_374 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_374 = happySpecReduce_1 149# happyReduction_374-happyReduction_374 happy_x_1- = case happyOut168 happy_x_1 of { (HappyWrap168 happy_var_1) -> - happyIn165- (mkHsAppTyHeadPV happy_var_1- )}--happyReduce_375 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_375 = happySpecReduce_1 149# happyReduction_375-happyReduction_375 happy_x_1- = case happyOut167 happy_x_1 of { (HappyWrap167 happy_var_1) -> - happyIn165- (failOpFewArgs happy_var_1- )}--happyReduce_376 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_376 = happySpecReduce_2 149# happyReduction_376-happyReduction_376 happy_x_2- happy_x_1- = case happyOut165 happy_x_1 of { (HappyWrap165 happy_var_1) -> - case happyOut166 happy_x_2 of { (HappyWrap166 happy_var_2) -> - happyIn165- (happy_var_1 >>= \ happy_var_1 ->- mkHsAppTyPV happy_var_1 happy_var_2- )}}--happyReduce_377 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_377 = happySpecReduce_3 149# happyReduction_377-happyReduction_377 happy_x_3- happy_x_2- happy_x_1- = case happyOut165 happy_x_1 of { (HappyWrap165 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut168 happy_x_3 of { (HappyWrap168 happy_var_3) -> - happyIn165- (happy_var_1 >>= \ happy_var_1 ->- mkHsAppKindTyPV happy_var_1 (getLoc happy_var_2) happy_var_3- )}}}--happyReduce_378 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_378 = happySpecReduce_1 150# happyReduction_378-happyReduction_378 happy_x_1- = case happyOut168 happy_x_1 of { (HappyWrap168 happy_var_1) -> - happyIn166- (happy_var_1- )}--happyReduce_379 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_379 = happyMonadReduce 2# 150# happyReduction_379-happyReduction_379 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut156 happy_x_1 of { (HappyWrap156 happy_var_1) -> - case happyOut168 happy_x_2 of { (HappyWrap168 happy_var_2) -> - ( addUnpackednessP happy_var_1 happy_var_2)}})- ) (\r -> happyReturn (happyIn166 r))--happyReduce_380 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_380 = happySpecReduce_1 151# happyReduction_380-happyReduction_380 happy_x_1- = case happyOut283 happy_x_1 of { (HappyWrap283 happy_var_1) -> - happyIn167- (happy_var_1- )}--happyReduce_381 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_381 = happySpecReduce_1 151# happyReduction_381-happyReduction_381 happy_x_1- = case happyOut297 happy_x_1 of { (HappyWrap297 happy_var_1) -> - happyIn167- (happy_var_1- )}--happyReduce_382 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_382 = happyMonadReduce 2# 151# happyReduction_382-happyReduction_382 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut278 happy_x_2 of { (HappyWrap278 happy_var_2) -> - ( amsrn (sLL happy_var_1 (reLoc happy_var_2) (unLoc happy_var_2))- (NameAnnQuote (glAA happy_var_1) (gl happy_var_2) []))}})- ) (\r -> happyReturn (happyIn167 r))--happyReduce_383 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_383 = happyMonadReduce 2# 151# happyReduction_383-happyReduction_383 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut290 happy_x_2 of { (HappyWrap290 happy_var_2) -> - ( amsrn (sLL happy_var_1 (reLoc happy_var_2) (unLoc happy_var_2))- (NameAnnQuote (glAA happy_var_1) (gl happy_var_2) []))}})- ) (\r -> happyReturn (happyIn167 r))--happyReduce_384 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_384 = happyMonadReduce 1# 152# happyReduction_384-happyReduction_384 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut280 happy_x_1 of { (HappyWrap280 happy_var_1) -> - ( acsa (\cs -> sL1a (reLocN happy_var_1) (HsTyVar (EpAnn (glNR happy_var_1) [] cs) NotPromoted happy_var_1)))})- ) (\r -> happyReturn (happyIn168 r))--happyReduce_385 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_385 = happyMonadReduce 1# 152# happyReduction_385-happyReduction_385 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut296 happy_x_1 of { (HappyWrap296 happy_var_1) -> - ( acsa (\cs -> sL1a (reLocN happy_var_1) (HsTyVar (EpAnn (glNR happy_var_1) [] cs) NotPromoted happy_var_1)))})- ) (\r -> happyReturn (happyIn168 r))--happyReduce_386 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_386 = happyMonadReduce 1# 152# happyReduction_386-happyReduction_386 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - ( do { warnStarIsType (getLoc happy_var_1)- ; return $ reLocA $ sL1 happy_var_1 (HsStarTy noExtField (isUnicode happy_var_1)) })})- ) (\r -> happyReturn (happyIn168 r))--happyReduce_387 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_387 = happyMonadReduce 2# 152# happyReduction_387-happyReduction_387 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut168 happy_x_2 of { (HappyWrap168 happy_var_2) -> - ( acsA (\cs -> sLLlA happy_var_1 happy_var_2 (mkBangTy (EpAnn (glR happy_var_1) [mj AnnTilde happy_var_1] cs) SrcLazy happy_var_2)))}})- ) (\r -> happyReturn (happyIn168 r))--happyReduce_388 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_388 = happyMonadReduce 2# 152# happyReduction_388-happyReduction_388 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut168 happy_x_2 of { (HappyWrap168 happy_var_2) -> - ( acsA (\cs -> sLLlA happy_var_1 happy_var_2 (mkBangTy (EpAnn (glR happy_var_1) [mj AnnBang happy_var_1] cs) SrcStrict happy_var_2)))}})- ) (\r -> happyReturn (happyIn168 r))--happyReduce_389 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_389 = happyMonadReduce 3# 152# happyReduction_389-happyReduction_389 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut190 happy_x_2 of { (HappyWrap190 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( do { decls <- acsA (\cs -> (sLL happy_var_1 happy_var_3 $ HsRecTy (EpAnn (glR happy_var_1) (AnnList (Just $ listAsAnchor happy_var_2) (Just $ moc happy_var_1) (Just $ mcc happy_var_3) [] []) cs) happy_var_2))- ; checkRecordSyntax decls })}}})- ) (\r -> happyReturn (happyIn168 r))--happyReduce_390 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_390 = happyMonadReduce 2# 152# happyReduction_390-happyReduction_390 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( acsA (\cs -> sLL happy_var_1 happy_var_2 $ HsTupleTy (EpAnn (glR happy_var_1) (AnnParen AnnParens (glAA happy_var_1) (glAA happy_var_2)) cs)- HsBoxedOrConstraintTuple []))}})- ) (\r -> happyReturn (happyIn168 r))--happyReduce_391 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_391 = happyMonadReduce 5# 152# happyReduction_391-happyReduction_391 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut158 happy_x_2 of { (HappyWrap158 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut172 happy_x_4 of { (HappyWrap172 happy_var_4) -> - case happyOutTok happy_x_5 of { happy_var_5 -> - ( do { h <- addTrailingCommaA happy_var_2 (gl happy_var_3)- ; acsA (\cs -> sLL happy_var_1 happy_var_5 $ HsTupleTy (EpAnn (glR happy_var_1) (AnnParen AnnParens (glAA happy_var_1) (glAA happy_var_5)) cs)- HsBoxedOrConstraintTuple (h : happy_var_4)) })}}}}})- ) (\r -> happyReturn (happyIn168 r))--happyReduce_392 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_392 = happyMonadReduce 2# 152# happyReduction_392-happyReduction_392 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( acsA (\cs -> sLL happy_var_1 happy_var_2 $ HsTupleTy (EpAnn (glR happy_var_1) (AnnParen AnnParensHash (glAA happy_var_1) (glAA happy_var_2)) cs) HsUnboxedTuple []))}})- ) (\r -> happyReturn (happyIn168 r))--happyReduce_393 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_393 = happyMonadReduce 3# 152# happyReduction_393-happyReduction_393 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut172 happy_x_2 of { (HappyWrap172 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( acsA (\cs -> sLL happy_var_1 happy_var_3 $ HsTupleTy (EpAnn (glR happy_var_1) (AnnParen AnnParensHash (glAA happy_var_1) (glAA happy_var_3)) cs) HsUnboxedTuple happy_var_2))}}})- ) (\r -> happyReturn (happyIn168 r))--happyReduce_394 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_394 = happyMonadReduce 3# 152# happyReduction_394-happyReduction_394 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut173 happy_x_2 of { (HappyWrap173 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( acsA (\cs -> sLL happy_var_1 happy_var_3 $ HsSumTy (EpAnn (glR happy_var_1) (AnnParen AnnParensHash (glAA happy_var_1) (glAA happy_var_3)) cs) happy_var_2))}}})- ) (\r -> happyReturn (happyIn168 r))--happyReduce_395 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_395 = happyMonadReduce 3# 152# happyReduction_395-happyReduction_395 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut158 happy_x_2 of { (HappyWrap158 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( acsA (\cs -> sLL happy_var_1 happy_var_3 $ HsListTy (EpAnn (glR happy_var_1) (AnnParen AnnParensSquare (glAA happy_var_1) (glAA happy_var_3)) cs) happy_var_2))}}})- ) (\r -> happyReturn (happyIn168 r))--happyReduce_396 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_396 = happyMonadReduce 3# 152# happyReduction_396-happyReduction_396 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut158 happy_x_2 of { (HappyWrap158 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( acsA (\cs -> sLL happy_var_1 happy_var_3 $ HsParTy (EpAnn (glR happy_var_1) (AnnParen AnnParens (glAA happy_var_1) (glAA happy_var_3)) cs) happy_var_2))}}})- ) (\r -> happyReturn (happyIn168 r))--happyReduce_397 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_397 = happySpecReduce_1 152# happyReduction_397-happyReduction_397 happy_x_1- = case happyOut205 happy_x_1 of { (HappyWrap205 happy_var_1) -> - happyIn168- (mapLocA (HsSpliceTy noExtField) happy_var_1- )}--happyReduce_398 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_398 = happySpecReduce_1 152# happyReduction_398-happyReduction_398 happy_x_1- = case happyOut218 happy_x_1 of { (HappyWrap218 happy_var_1) -> - happyIn168- (mapLocA (HsSpliceTy noExtField) happy_var_1- )}--happyReduce_399 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_399 = happyMonadReduce 2# 152# happyReduction_399-happyReduction_399 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut270 happy_x_2 of { (HappyWrap270 happy_var_2) -> - ( acsA (\cs -> sLL happy_var_1 (reLocN happy_var_2) $ HsTyVar (EpAnn (glR happy_var_1) [mj AnnSimpleQuote happy_var_1,mjN AnnName happy_var_2] cs) IsPromoted happy_var_2))}})- ) (\r -> happyReturn (happyIn168 r))--happyReduce_400 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_400 = happyMonadReduce 6# 152# happyReduction_400-happyReduction_400 (happy_x_6 `HappyStk`- happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut158 happy_x_3 of { (HappyWrap158 happy_var_3) -> - case happyOutTok happy_x_4 of { happy_var_4 -> - case happyOut172 happy_x_5 of { (HappyWrap172 happy_var_5) -> - case happyOutTok happy_x_6 of { happy_var_6 -> - ( do { h <- addTrailingCommaA happy_var_3 (gl happy_var_4)- ; acsA (\cs -> sLL happy_var_1 happy_var_6 $ HsExplicitTupleTy (EpAnn (glR happy_var_1) [mj AnnSimpleQuote happy_var_1,mop happy_var_2,mcp happy_var_6] cs) (h : happy_var_5)) })}}}}}})- ) (\r -> happyReturn (happyIn168 r))--happyReduce_401 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_401 = happyMonadReduce 4# 152# happyReduction_401-happyReduction_401 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut171 happy_x_3 of { (HappyWrap171 happy_var_3) -> - case happyOutTok happy_x_4 of { happy_var_4 -> - ( acsA (\cs -> sLL happy_var_1 happy_var_4 $ HsExplicitListTy (EpAnn (glR happy_var_1) [mj AnnSimpleQuote happy_var_1,mos happy_var_2,mcs happy_var_4] cs) IsPromoted happy_var_3))}}}})- ) (\r -> happyReturn (happyIn168 r))--happyReduce_402 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_402 = happyMonadReduce 2# 152# happyReduction_402-happyReduction_402 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut299 happy_x_2 of { (HappyWrap299 happy_var_2) -> - ( acsA (\cs -> sLL happy_var_1 (reLocN happy_var_2) $ HsTyVar (EpAnn (glR happy_var_1) [mj AnnSimpleQuote happy_var_1,mjN AnnName happy_var_2] cs) IsPromoted happy_var_2))}})- ) (\r -> happyReturn (happyIn168 r))--happyReduce_403 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_403 = happyMonadReduce 5# 152# happyReduction_403-happyReduction_403 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut158 happy_x_2 of { (HappyWrap158 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut172 happy_x_4 of { (HappyWrap172 happy_var_4) -> - case happyOutTok happy_x_5 of { happy_var_5 -> - ( do { h <- addTrailingCommaA happy_var_2 (gl happy_var_3)- ; acsA (\cs -> sLL happy_var_1 happy_var_5 $ HsExplicitListTy (EpAnn (glR happy_var_1) [mos happy_var_1,mcs happy_var_5] cs) NotPromoted (h:happy_var_4)) })}}}}})- ) (\r -> happyReturn (happyIn168 r))--happyReduce_404 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_404 = happySpecReduce_1 152# happyReduction_404-happyReduction_404 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn168- (reLocA $ sLL happy_var_1 happy_var_1 $ HsTyLit noExtField $ HsNumTy (getINTEGERs happy_var_1)- (il_value (getINTEGER happy_var_1))- )}--happyReduce_405 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_405 = happySpecReduce_1 152# happyReduction_405-happyReduction_405 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn168- (reLocA $ sLL happy_var_1 happy_var_1 $ HsTyLit noExtField $ HsCharTy (getCHARs happy_var_1)- (getCHAR happy_var_1)- )}--happyReduce_406 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_406 = happySpecReduce_1 152# happyReduction_406-happyReduction_406 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn168- (reLocA $ sLL happy_var_1 happy_var_1 $ HsTyLit noExtField $ HsStrTy (getSTRINGs happy_var_1)- (getSTRING happy_var_1)- )}--happyReduce_407 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_407 = happySpecReduce_1 152# happyReduction_407-happyReduction_407 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn168- (reLocA $ sL1 happy_var_1 $ mkAnonWildCardTy- )}--happyReduce_408 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_408 = happySpecReduce_1 153# happyReduction_408-happyReduction_408 happy_x_1- = case happyOut153 happy_x_1 of { (HappyWrap153 happy_var_1) -> - happyIn169- (happy_var_1- )}--happyReduce_409 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_409 = happySpecReduce_1 154# happyReduction_409-happyReduction_409 happy_x_1- = case happyOut152 happy_x_1 of { (HappyWrap152 happy_var_1) -> - happyIn170- ([happy_var_1]- )}--happyReduce_410 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_410 = happyMonadReduce 3# 154# happyReduction_410-happyReduction_410 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut152 happy_x_1 of { (HappyWrap152 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut170 happy_x_3 of { (HappyWrap170 happy_var_3) -> - ( do { h <- addTrailingCommaA happy_var_1 (gl happy_var_2)- ; return (h : happy_var_3) })}}})- ) (\r -> happyReturn (happyIn170 r))--happyReduce_411 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_411 = happySpecReduce_1 155# happyReduction_411-happyReduction_411 happy_x_1- = case happyOut172 happy_x_1 of { (HappyWrap172 happy_var_1) -> - happyIn171- (happy_var_1- )}--happyReduce_412 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_412 = happySpecReduce_0 155# happyReduction_412-happyReduction_412 = happyIn171- ([]- )--happyReduce_413 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_413 = happySpecReduce_1 156# happyReduction_413-happyReduction_413 happy_x_1- = case happyOut158 happy_x_1 of { (HappyWrap158 happy_var_1) -> - happyIn172- ([happy_var_1]- )}--happyReduce_414 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_414 = happyMonadReduce 3# 156# happyReduction_414-happyReduction_414 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut158 happy_x_1 of { (HappyWrap158 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut172 happy_x_3 of { (HappyWrap172 happy_var_3) -> - ( do { h <- addTrailingCommaA happy_var_1 (gl happy_var_2)- ; return (h : happy_var_3) })}}})- ) (\r -> happyReturn (happyIn172 r))--happyReduce_415 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_415 = happyMonadReduce 3# 157# happyReduction_415-happyReduction_415 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut158 happy_x_1 of { (HappyWrap158 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut158 happy_x_3 of { (HappyWrap158 happy_var_3) -> - ( do { h <- addTrailingVbarA happy_var_1 (gl happy_var_2)- ; return [h,happy_var_3] })}}})- ) (\r -> happyReturn (happyIn173 r))--happyReduce_416 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_416 = happyMonadReduce 3# 157# happyReduction_416-happyReduction_416 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut158 happy_x_1 of { (HappyWrap158 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut173 happy_x_3 of { (HappyWrap173 happy_var_3) -> - ( do { h <- addTrailingVbarA happy_var_1 (gl happy_var_2)- ; return (h : happy_var_3) })}}})- ) (\r -> happyReturn (happyIn173 r))--happyReduce_417 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_417 = happySpecReduce_2 158# happyReduction_417-happyReduction_417 happy_x_2- happy_x_1- = case happyOut175 happy_x_1 of { (HappyWrap175 happy_var_1) -> - case happyOut174 happy_x_2 of { (HappyWrap174 happy_var_2) -> - happyIn174- (happy_var_1 : happy_var_2- )}}--happyReduce_418 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_418 = happySpecReduce_0 158# happyReduction_418-happyReduction_418 = happyIn174- ([]- )--happyReduce_419 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_419 = happySpecReduce_1 159# happyReduction_419-happyReduction_419 happy_x_1- = case happyOut176 happy_x_1 of { (HappyWrap176 happy_var_1) -> - happyIn175- (happy_var_1- )}--happyReduce_420 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_420 = happyMonadReduce 3# 159# happyReduction_420-happyReduction_420 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut296 happy_x_2 of { (HappyWrap296 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( acsA (\cs -> sLL happy_var_1 happy_var_3 (UserTyVar (EpAnn (glR happy_var_1) [moc happy_var_1, mcc happy_var_3] cs) InferredSpec happy_var_2)))}}})- ) (\r -> happyReturn (happyIn175 r))--happyReduce_421 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_421 = happyMonadReduce 5# 159# happyReduction_421-happyReduction_421 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut296 happy_x_2 of { (HappyWrap296 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut181 happy_x_4 of { (HappyWrap181 happy_var_4) -> - case happyOutTok happy_x_5 of { happy_var_5 -> - ( acsA (\cs -> sLL happy_var_1 happy_var_5 (KindedTyVar (EpAnn (glR happy_var_1) [moc happy_var_1,mu AnnDcolon happy_var_3 ,mcc happy_var_5] cs) InferredSpec happy_var_2 happy_var_4)))}}}}})- ) (\r -> happyReturn (happyIn175 r))--happyReduce_422 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_422 = happyMonadReduce 1# 160# happyReduction_422-happyReduction_422 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut296 happy_x_1 of { (HappyWrap296 happy_var_1) -> - ( acsA (\cs -> (sL1 (reLocN happy_var_1) (UserTyVar (EpAnn (glNR happy_var_1) [] cs) SpecifiedSpec happy_var_1))))})- ) (\r -> happyReturn (happyIn176 r))--happyReduce_423 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_423 = happyMonadReduce 5# 160# happyReduction_423-happyReduction_423 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut296 happy_x_2 of { (HappyWrap296 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut181 happy_x_4 of { (HappyWrap181 happy_var_4) -> - case happyOutTok happy_x_5 of { happy_var_5 -> - ( acsA (\cs -> (sLL happy_var_1 happy_var_5 (KindedTyVar (EpAnn (glR happy_var_1) [mop happy_var_1,mu AnnDcolon happy_var_3 ,mcp happy_var_5] cs) SpecifiedSpec happy_var_2 happy_var_4))))}}}}})- ) (\r -> happyReturn (happyIn176 r))--happyReduce_424 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_424 = happySpecReduce_0 161# happyReduction_424-happyReduction_424 = happyIn177- (noLoc ([],[])- )--happyReduce_425 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_425 = happySpecReduce_2 161# happyReduction_425-happyReduction_425 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut178 happy_x_2 of { (HappyWrap178 happy_var_2) -> - happyIn177- ((sLL happy_var_1 happy_var_2 ([mj AnnVbar happy_var_1]- ,reverse (unLoc happy_var_2)))- )}}--happyReduce_426 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_426 = happyMonadReduce 3# 162# happyReduction_426-happyReduction_426 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut178 happy_x_1 of { (HappyWrap178 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut179 happy_x_3 of { (HappyWrap179 happy_var_3) -> - (- do { let (h:t) = unLoc happy_var_1 -- Safe from fds1 rules- ; h' <- addTrailingCommaA h (gl happy_var_2)- ; return (sLLlA happy_var_1 happy_var_3 (happy_var_3 : h' : t)) })}}})- ) (\r -> happyReturn (happyIn178 r))--happyReduce_427 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_427 = happySpecReduce_1 162# happyReduction_427-happyReduction_427 happy_x_1- = case happyOut179 happy_x_1 of { (HappyWrap179 happy_var_1) -> - happyIn178- (sL1A happy_var_1 [happy_var_1]- )}--happyReduce_428 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_428 = happyMonadReduce 3# 163# happyReduction_428-happyReduction_428 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut180 happy_x_1 of { (HappyWrap180 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut180 happy_x_3 of { (HappyWrap180 happy_var_3) -> - ( acsA (\cs -> L (comb3 happy_var_1 happy_var_2 happy_var_3)- (FunDep (EpAnn (glR happy_var_1) [mu AnnRarrow happy_var_2] cs)- (reverse (unLoc happy_var_1))- (reverse (unLoc happy_var_3)))))}}})- ) (\r -> happyReturn (happyIn179 r))--happyReduce_429 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_429 = happySpecReduce_0 164# happyReduction_429-happyReduction_429 = happyIn180- (noLoc []- )--happyReduce_430 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_430 = happySpecReduce_2 164# happyReduction_430-happyReduction_430 happy_x_2- happy_x_1- = case happyOut180 happy_x_1 of { (HappyWrap180 happy_var_1) -> - case happyOut296 happy_x_2 of { (HappyWrap296 happy_var_2) -> - happyIn180- (sLL happy_var_1 (reLocN happy_var_2) (happy_var_2 : (unLoc happy_var_1))- )}}--happyReduce_431 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_431 = happySpecReduce_1 165# happyReduction_431-happyReduction_431 happy_x_1- = case happyOut159 happy_x_1 of { (HappyWrap159 happy_var_1) -> - happyIn181- (happy_var_1- )}--happyReduce_432 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_432 = happyMonadReduce 4# 166# happyReduction_432-happyReduction_432 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut183 happy_x_3 of { (HappyWrap183 happy_var_3) -> - case happyOutTok happy_x_4 of { happy_var_4 -> - ( checkEmptyGADTs $- L (comb2 happy_var_1 happy_var_3)- ([mj AnnWhere happy_var_1- ,moc happy_var_2- ,mcc happy_var_4]- , unLoc happy_var_3))}}}})- ) (\r -> happyReturn (happyIn182 r))--happyReduce_433 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_433 = happyMonadReduce 4# 166# happyReduction_433-happyReduction_433 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut183 happy_x_3 of { (HappyWrap183 happy_var_3) -> - ( checkEmptyGADTs $- L (comb2 happy_var_1 happy_var_3)- ([mj AnnWhere happy_var_1]- , unLoc happy_var_3))}})- ) (\r -> happyReturn (happyIn182 r))--happyReduce_434 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_434 = happySpecReduce_0 166# happyReduction_434-happyReduction_434 = happyIn182- (noLoc ([],[])- )--happyReduce_435 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_435 = happyMonadReduce 3# 167# happyReduction_435-happyReduction_435 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut184 happy_x_1 of { (HappyWrap184 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut183 happy_x_3 of { (HappyWrap183 happy_var_3) -> - ( do { h <- addTrailingSemiA happy_var_1 (gl happy_var_2)- ; return (L (comb2 (reLoc happy_var_1) happy_var_3) (h : unLoc happy_var_3)) })}}})- ) (\r -> happyReturn (happyIn183 r))--happyReduce_436 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_436 = happySpecReduce_1 167# happyReduction_436-happyReduction_436 happy_x_1- = case happyOut184 happy_x_1 of { (HappyWrap184 happy_var_1) -> - happyIn183- (L (glA happy_var_1) [happy_var_1]- )}--happyReduce_437 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_437 = happySpecReduce_0 167# happyReduction_437-happyReduction_437 = happyIn183- (noLoc []- )--happyReduce_438 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_438 = happyMonadReduce 4# 168# happyReduction_438-happyReduction_438 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut274 happy_x_2 of { (HappyWrap274 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut153 happy_x_4 of { (HappyWrap153 happy_var_4) -> - ( mkGadtDecl (comb2A happy_var_2 happy_var_4) (unLoc happy_var_2) happy_var_4 [mu AnnDcolon happy_var_3])}}})- ) (\r -> happyReturn (happyIn184 r))--happyReduce_439 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_439 = happySpecReduce_2 169# happyReduction_439-happyReduction_439 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut186 happy_x_2 of { (HappyWrap186 happy_var_2) -> - happyIn185- (sLL happy_var_1 happy_var_2 ([mj AnnEqual happy_var_1],unLoc happy_var_2)- )}}--happyReduce_440 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_440 = happyMonadReduce 3# 170# happyReduction_440-happyReduction_440 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut186 happy_x_1 of { (HappyWrap186 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut187 happy_x_3 of { (HappyWrap187 happy_var_3) -> - ( do { let (h:t) = unLoc happy_var_1- ; h' <- addTrailingVbarA h (gl happy_var_2)- ; return (sLLlA happy_var_1 happy_var_3 (happy_var_3 : h' : t)) })}}})- ) (\r -> happyReturn (happyIn186 r))--happyReduce_441 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_441 = happySpecReduce_1 170# happyReduction_441-happyReduction_441 happy_x_1- = case happyOut187 happy_x_1 of { (HappyWrap187 happy_var_1) -> - happyIn186- (sL1A happy_var_1 [happy_var_1]- )}--happyReduce_442 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_442 = happyMonadReduce 4# 171# happyReduction_442-happyReduction_442 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut188 happy_x_1 of { (HappyWrap188 happy_var_1) -> - case happyOut160 happy_x_2 of { (HappyWrap160 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut189 happy_x_4 of { (HappyWrap189 happy_var_4) -> - ( acsA (\cs -> let (con,details) = unLoc happy_var_4 in- (L (comb4 happy_var_1 (reLoc happy_var_2) happy_var_3 happy_var_4) (mkConDeclH98- (EpAnn (spanAsAnchor (comb4 happy_var_1 (reLoc happy_var_2) happy_var_3 happy_var_4))- (mu AnnDarrow happy_var_3:(fst $ unLoc happy_var_1)) cs)- con- (snd $ unLoc happy_var_1)- (Just happy_var_2)- details))))}}}})- ) (\r -> happyReturn (happyIn187 r))--happyReduce_443 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_443 = happyMonadReduce 2# 171# happyReduction_443-happyReduction_443 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut188 happy_x_1 of { (HappyWrap188 happy_var_1) -> - case happyOut189 happy_x_2 of { (HappyWrap189 happy_var_2) -> - ( acsA (\cs -> let (con,details) = unLoc happy_var_2 in- (L (comb2 happy_var_1 happy_var_2) (mkConDeclH98 (EpAnn (spanAsAnchor (comb2 happy_var_1 happy_var_2)) (fst $ unLoc happy_var_1) cs)- con- (snd $ unLoc happy_var_1)- Nothing -- No context- details))))}})- ) (\r -> happyReturn (happyIn187 r))--happyReduce_444 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_444 = happySpecReduce_3 172# happyReduction_444-happyReduction_444 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut174 happy_x_2 of { (HappyWrap174 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn188- (sLL happy_var_1 happy_var_3 ([mu AnnForall happy_var_1,mj AnnDot happy_var_3], Just happy_var_2)- )}}}--happyReduce_445 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_445 = happySpecReduce_0 172# happyReduction_445-happyReduction_445 = happyIn188- (noLoc ([], Nothing)- )--happyReduce_446 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_446 = happyMonadReduce 1# 173# happyReduction_446-happyReduction_446 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut164 happy_x_1 of { (HappyWrap164 happy_var_1) -> - ( fmap (reLoc. (mapLoc (\b -> (dataConBuilderCon b,- dataConBuilderDetails b))))- (runPV happy_var_1))})- ) (\r -> happyReturn (happyIn189 r))--happyReduce_447 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_447 = happySpecReduce_0 174# happyReduction_447-happyReduction_447 = happyIn190- ([]- )--happyReduce_448 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_448 = happySpecReduce_1 174# happyReduction_448-happyReduction_448 happy_x_1- = case happyOut191 happy_x_1 of { (HappyWrap191 happy_var_1) -> - happyIn190- (happy_var_1- )}--happyReduce_449 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_449 = happyMonadReduce 3# 175# happyReduction_449-happyReduction_449 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut192 happy_x_1 of { (HappyWrap192 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut191 happy_x_3 of { (HappyWrap191 happy_var_3) -> - ( do { h <- addTrailingCommaA happy_var_1 (gl happy_var_2)- ; return (h : happy_var_3) })}}})- ) (\r -> happyReturn (happyIn191 r))--happyReduce_450 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_450 = happySpecReduce_1 175# happyReduction_450-happyReduction_450 happy_x_1- = case happyOut192 happy_x_1 of { (HappyWrap192 happy_var_1) -> - happyIn191- ([happy_var_1]- )}--happyReduce_451 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_451 = happyMonadReduce 3# 176# happyReduction_451-happyReduction_451 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut154 happy_x_1 of { (HappyWrap154 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut159 happy_x_3 of { (HappyWrap159 happy_var_3) -> - ( acsA (\cs -> L (comb2 happy_var_1 (reLoc happy_var_3))- (ConDeclField (EpAnn (glR happy_var_1) [mu AnnDcolon happy_var_2] cs)- (reverse (map (\ln@(L l n) -> L (locA l) $ FieldOcc noExtField ln) (unLoc happy_var_1))) happy_var_3 Nothing)))}}})- ) (\r -> happyReturn (happyIn192 r))--happyReduce_452 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_452 = happySpecReduce_0 177# happyReduction_452-happyReduction_452 = happyIn193- (noLoc []- )--happyReduce_453 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_453 = happySpecReduce_1 177# happyReduction_453-happyReduction_453 happy_x_1- = case happyOut194 happy_x_1 of { (HappyWrap194 happy_var_1) -> - happyIn193- (happy_var_1- )}--happyReduce_454 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_454 = happySpecReduce_2 178# happyReduction_454-happyReduction_454 happy_x_2- happy_x_1- = case happyOut194 happy_x_1 of { (HappyWrap194 happy_var_1) -> - case happyOut195 happy_x_2 of { (HappyWrap195 happy_var_2) -> - happyIn194- (sLL happy_var_1 happy_var_2 (happy_var_2 : unLoc happy_var_1)- )}}--happyReduce_455 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_455 = happySpecReduce_1 178# happyReduction_455-happyReduction_455 happy_x_1- = case happyOut195 happy_x_1 of { (HappyWrap195 happy_var_1) -> - happyIn194- (sLL happy_var_1 happy_var_1 [happy_var_1]- )}--happyReduce_456 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_456 = happyMonadReduce 2# 179# happyReduction_456-happyReduction_456 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut196 happy_x_2 of { (HappyWrap196 happy_var_2) -> - ( let { full_loc = comb2A happy_var_1 happy_var_2 }- in acs (\cs -> L full_loc $ HsDerivingClause (EpAnn (glR happy_var_1) [mj AnnDeriving happy_var_1] cs) Nothing happy_var_2))}})- ) (\r -> happyReturn (happyIn195 r))--happyReduce_457 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_457 = happyMonadReduce 3# 179# happyReduction_457-happyReduction_457 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut85 happy_x_2 of { (HappyWrap85 happy_var_2) -> - case happyOut196 happy_x_3 of { (HappyWrap196 happy_var_3) -> - ( let { full_loc = comb2A happy_var_1 happy_var_3 }- in acs (\cs -> L full_loc $ HsDerivingClause (EpAnn (glR happy_var_1) [mj AnnDeriving happy_var_1] cs) (Just happy_var_2) happy_var_3))}}})- ) (\r -> happyReturn (happyIn195 r))--happyReduce_458 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_458 = happyMonadReduce 3# 179# happyReduction_458-happyReduction_458 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut196 happy_x_2 of { (HappyWrap196 happy_var_2) -> - case happyOut86 happy_x_3 of { (HappyWrap86 happy_var_3) -> - ( let { full_loc = comb2 happy_var_1 happy_var_3 }- in acs (\cs -> L full_loc $ HsDerivingClause (EpAnn (glR happy_var_1) [mj AnnDeriving happy_var_1] cs) (Just happy_var_3) happy_var_2))}}})- ) (\r -> happyReturn (happyIn195 r))--happyReduce_459 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_459 = happySpecReduce_1 180# happyReduction_459-happyReduction_459 happy_x_1- = case happyOut284 happy_x_1 of { (HappyWrap284 happy_var_1) -> - happyIn196- (let { tc = sL1 (reLocL happy_var_1) $ mkHsImplicitSigType $- sL1 (reLocL happy_var_1) $ HsTyVar noAnn NotPromoted happy_var_1 } in- sL1 (reLocC happy_var_1) (DctSingle noExtField tc)- )}--happyReduce_460 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_460 = happyMonadReduce 2# 180# happyReduction_460-happyReduction_460 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( amsrc (sLL happy_var_1 happy_var_2 (DctMulti noExtField []))- (AnnContext Nothing [glAA happy_var_1] [glAA happy_var_2]))}})- ) (\r -> happyReturn (happyIn196 r))--happyReduce_461 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_461 = happyMonadReduce 3# 180# happyReduction_461-happyReduction_461 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut170 happy_x_2 of { (HappyWrap170 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( amsrc (sLL happy_var_1 happy_var_3 (DctMulti noExtField happy_var_2))- (AnnContext Nothing [glAA happy_var_1] [glAA happy_var_3]))}}})- ) (\r -> happyReturn (happyIn196 r))--happyReduce_462 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_462 = happySpecReduce_1 181# happyReduction_462-happyReduction_462 happy_x_1- = case happyOut202 happy_x_1 of { (HappyWrap202 happy_var_1) -> - happyIn197- (happy_var_1- )}--happyReduce_463 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_463 = happyMonadReduce 3# 181# happyReduction_463-happyReduction_463 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut207 happy_x_1 of { (HappyWrap207 happy_var_1) -> - case happyOut150 happy_x_2 of { (HappyWrap150 happy_var_2) -> - case happyOut199 happy_x_3 of { (HappyWrap199 happy_var_3) -> - ( runPV (unECP happy_var_1) >>= \ happy_var_1 ->- do { let { l = comb2Al happy_var_1 happy_var_3 }- ; r <- checkValDef l happy_var_1 happy_var_2 happy_var_3;- -- Depending upon what the pattern looks like we might get either- -- a FunBind or PatBind back from checkValDef. See Note- -- [FunBind vs PatBind]- ; cs <- getCommentsFor l- ; return $! (sL (commentsA l cs) $ ValD noExtField r) })}}})- ) (\r -> happyReturn (happyIn197 r))--happyReduce_464 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_464 = happySpecReduce_1 181# happyReduction_464-happyReduction_464 happy_x_1- = case happyOut112 happy_x_1 of { (HappyWrap112 happy_var_1) -> - happyIn197- (happy_var_1- )}--happyReduce_465 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_465 = happySpecReduce_1 182# happyReduction_465-happyReduction_465 happy_x_1- = case happyOut197 happy_x_1 of { (HappyWrap197 happy_var_1) -> - happyIn198- (happy_var_1- )}--happyReduce_466 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_466 = happyMonadReduce 1# 182# happyReduction_466-happyReduction_466 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut217 happy_x_1 of { (HappyWrap217 happy_var_1) -> - ( mkSpliceDecl happy_var_1)})- ) (\r -> happyReturn (happyIn198 r))--happyReduce_467 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_467 = happyMonadReduce 3# 183# happyReduction_467-happyReduction_467 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut206 happy_x_2 of { (HappyWrap206 happy_var_2) -> - case happyOut130 happy_x_3 of { (HappyWrap130 happy_var_3) -> - ( runPV (unECP happy_var_2) >>= \ happy_var_2 ->- do { let L l (bs, csw) = adaptWhereBinds happy_var_3- ; let loc = (comb3 happy_var_1 (reLoc happy_var_2) (L l bs))- ; acs (\cs ->- sL loc (GRHSs csw (unguardedRHS (EpAnn (anc $ rs loc) (GrhsAnn Nothing (mj AnnEqual happy_var_1)) cs) loc happy_var_2)- bs)) })}}})- ) (\r -> happyReturn (happyIn199 r))--happyReduce_468 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_468 = happyMonadReduce 2# 183# happyReduction_468-happyReduction_468 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut200 happy_x_1 of { (HappyWrap200 happy_var_1) -> - case happyOut130 happy_x_2 of { (HappyWrap130 happy_var_2) -> - ( do { let {L l (bs, csw) = adaptWhereBinds happy_var_2}- ; acs (\cs -> sL (comb2 happy_var_1 (L l bs))- (GRHSs (cs Semi.<> csw) (reverse (unLoc happy_var_1)) bs)) })}})- ) (\r -> happyReturn (happyIn199 r))--happyReduce_469 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_469 = happySpecReduce_2 184# happyReduction_469-happyReduction_469 happy_x_2- happy_x_1- = case happyOut200 happy_x_1 of { (HappyWrap200 happy_var_1) -> - case happyOut201 happy_x_2 of { (HappyWrap201 happy_var_2) -> - happyIn200- (sLL happy_var_1 happy_var_2 (happy_var_2 : unLoc happy_var_1)- )}}--happyReduce_470 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_470 = happySpecReduce_1 184# happyReduction_470-happyReduction_470 happy_x_1- = case happyOut201 happy_x_1 of { (HappyWrap201 happy_var_1) -> - happyIn200- (sL1 happy_var_1 [happy_var_1]- )}--happyReduce_471 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_471 = happyMonadReduce 4# 185# happyReduction_471-happyReduction_471 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut234 happy_x_2 of { (HappyWrap234 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut206 happy_x_4 of { (HappyWrap206 happy_var_4) -> - ( runPV (unECP happy_var_4) >>= \ happy_var_4 ->- acs (\cs -> sL (comb2A happy_var_1 happy_var_4) $ GRHS (EpAnn (glR happy_var_1) (GrhsAnn (Just $ glAA happy_var_1) (mj AnnEqual happy_var_3)) cs) (unLoc happy_var_2) happy_var_4))}}}})- ) (\r -> happyReturn (happyIn201 r))--happyReduce_472 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_472 = happyMonadReduce 3# 186# happyReduction_472-happyReduction_472 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut207 happy_x_1 of { (HappyWrap207 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut153 happy_x_3 of { (HappyWrap153 happy_var_3) -> - ( do { happy_var_1 <- runPV (unECP happy_var_1)- ; v <- checkValSigLhs happy_var_1- ; acsA (\cs -> (sLLAl happy_var_1 (reLoc happy_var_3) $ SigD noExtField $- TypeSig (EpAnn (glAR happy_var_1) (AnnSig (mu AnnDcolon happy_var_2) []) cs) [v] (mkHsWildCardBndrs happy_var_3)))})}}})- ) (\r -> happyReturn (happyIn202 r))--happyReduce_473 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_473 = happyMonadReduce 5# 186# happyReduction_473-happyReduction_473 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut299 happy_x_1 of { (HappyWrap299 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut154 happy_x_3 of { (HappyWrap154 happy_var_3) -> - case happyOutTok happy_x_4 of { happy_var_4 -> - case happyOut153 happy_x_5 of { (HappyWrap153 happy_var_5) -> - ( do { v <- addTrailingCommaN happy_var_1 (gl happy_var_2)- ; let sig cs = TypeSig (EpAnn (glNR happy_var_1) (AnnSig (mu AnnDcolon happy_var_4) []) cs) (v : reverse (unLoc happy_var_3))- (mkHsWildCardBndrs happy_var_5)- ; acsA (\cs -> sLL (reLocN happy_var_1) (reLoc happy_var_5) $ SigD noExtField (sig cs) ) })}}}}})- ) (\r -> happyReturn (happyIn202 r))--happyReduce_474 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_474 = happyMonadReduce 3# 186# happyReduction_474-happyReduction_474 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut71 happy_x_1 of { (HappyWrap71 happy_var_1) -> - case happyOut70 happy_x_2 of { (HappyWrap70 happy_var_2) -> - case happyOut72 happy_x_3 of { (HappyWrap72 happy_var_3) -> - ( do { mbPrecAnn <- traverse (\l2 -> do { checkPrecP l2 happy_var_3- ; pure (mj AnnVal l2) })- happy_var_2- ; let (fixText, fixPrec) = case happy_var_2 of- -- If an explicit precedence isn't supplied,- -- it defaults to maxPrecedence- Nothing -> (NoSourceText, maxPrecedence)- Just l2 -> (fst $ unLoc l2, snd $ unLoc l2)- ; acsA (\cs -> sLL happy_var_1 happy_var_3 $ SigD noExtField- (FixSig (EpAnn (glR happy_var_1) (mj AnnInfix happy_var_1 : maybeToList mbPrecAnn) cs) (FixitySig noExtField (fromOL $ unLoc happy_var_3)- (Fixity fixText fixPrec (unLoc happy_var_1)))))- })}}})- ) (\r -> happyReturn (happyIn202 r))--happyReduce_475 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_475 = happySpecReduce_1 186# happyReduction_475-happyReduction_475 happy_x_1- = case happyOut117 happy_x_1 of { (HappyWrap117 happy_var_1) -> - happyIn202- (sL1 happy_var_1 . SigD noExtField . unLoc $ happy_var_1- )}--happyReduce_476 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_476 = happyMonadReduce 4# 186# happyReduction_476-happyReduction_476 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut274 happy_x_2 of { (HappyWrap274 happy_var_2) -> - case happyOut151 happy_x_3 of { (HappyWrap151 happy_var_3) -> - case happyOutTok happy_x_4 of { happy_var_4 -> - ( let (dcolon, tc) = happy_var_3- in acsA- (\cs -> sLL happy_var_1 happy_var_4- (SigD noExtField (CompleteMatchSig (EpAnn (glR happy_var_1) ([ mo happy_var_1 ] ++ dcolon ++ [mc happy_var_4]) cs) (getCOMPLETE_PRAGs happy_var_1) happy_var_2 tc))))}}}})- ) (\r -> happyReturn (happyIn202 r))--happyReduce_477 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_477 = happyMonadReduce 4# 186# happyReduction_477-happyReduction_477 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut203 happy_x_2 of { (HappyWrap203 happy_var_2) -> - case happyOut118 happy_x_3 of { (HappyWrap118 happy_var_3) -> - case happyOutTok happy_x_4 of { happy_var_4 -> - ( acsA (\cs -> (sLL happy_var_1 happy_var_4 $ SigD noExtField (InlineSig (EpAnn (glR happy_var_1) ((mo happy_var_1:fst happy_var_2) ++ [mc happy_var_4]) cs) happy_var_3- (mkInlinePragma (getINLINE_PRAGs happy_var_1) (getINLINE happy_var_1)- (snd happy_var_2))))))}}}})- ) (\r -> happyReturn (happyIn202 r))--happyReduce_478 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_478 = happyMonadReduce 3# 186# happyReduction_478-happyReduction_478 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut300 happy_x_2 of { (HappyWrap300 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( acsA (\cs -> sLL happy_var_1 happy_var_3 (SigD noExtField (SCCFunSig (EpAnn (glR happy_var_1) [mo happy_var_1, mc happy_var_3] cs) (getSCC_PRAGs happy_var_1) happy_var_2 Nothing))))}}})- ) (\r -> happyReturn (happyIn202 r))--happyReduce_479 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_479 = happyMonadReduce 4# 186# happyReduction_479-happyReduction_479 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut300 happy_x_2 of { (HappyWrap300 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - ( do { scc <- getSCC happy_var_3- ; let str_lit = StringLiteral (getSTRINGs happy_var_3) scc Nothing- ; acsA (\cs -> sLL happy_var_1 happy_var_4 (SigD noExtField (SCCFunSig (EpAnn (glR happy_var_1) [mo happy_var_1, mc happy_var_4] cs) (getSCC_PRAGs happy_var_1) happy_var_2 (Just ( sL1 happy_var_3 str_lit))))) })}}}})- ) (\r -> happyReturn (happyIn202 r))--happyReduce_480 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_480 = happyMonadReduce 6# 186# happyReduction_480-happyReduction_480 (happy_x_6 `HappyStk`- happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut203 happy_x_2 of { (HappyWrap203 happy_var_2) -> - case happyOut300 happy_x_3 of { (HappyWrap300 happy_var_3) -> - case happyOutTok happy_x_4 of { happy_var_4 -> - case happyOut155 happy_x_5 of { (HappyWrap155 happy_var_5) -> - case happyOutTok happy_x_6 of { happy_var_6 -> - ( acsA (\cs ->- let inl_prag = mkInlinePragma (getSPEC_PRAGs happy_var_1)- (NoUserInlinePrag, FunLike) (snd happy_var_2)- in sLL happy_var_1 happy_var_6 $ SigD noExtField (SpecSig (EpAnn (glR happy_var_1) (mo happy_var_1:mu AnnDcolon happy_var_4:mc happy_var_6:(fst happy_var_2)) cs) happy_var_3 (fromOL happy_var_5) inl_prag)))}}}}}})- ) (\r -> happyReturn (happyIn202 r))--happyReduce_481 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_481 = happyMonadReduce 6# 186# happyReduction_481-happyReduction_481 (happy_x_6 `HappyStk`- happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut203 happy_x_2 of { (HappyWrap203 happy_var_2) -> - case happyOut300 happy_x_3 of { (HappyWrap300 happy_var_3) -> - case happyOutTok happy_x_4 of { happy_var_4 -> - case happyOut155 happy_x_5 of { (HappyWrap155 happy_var_5) -> - case happyOutTok happy_x_6 of { happy_var_6 -> - ( acsA (\cs -> sLL happy_var_1 happy_var_6 $ SigD noExtField (SpecSig (EpAnn (glR happy_var_1) (mo happy_var_1:mu AnnDcolon happy_var_4:mc happy_var_6:(fst happy_var_2)) cs) happy_var_3 (fromOL happy_var_5)- (mkInlinePragma (getSPEC_INLINE_PRAGs happy_var_1)- (getSPEC_INLINE happy_var_1) (snd happy_var_2)))))}}}}}})- ) (\r -> happyReturn (happyIn202 r))--happyReduce_482 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_482 = happyMonadReduce 4# 186# happyReduction_482-happyReduction_482 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut169 happy_x_3 of { (HappyWrap169 happy_var_3) -> - case happyOutTok happy_x_4 of { happy_var_4 -> - ( acsA (\cs -> sLL happy_var_1 happy_var_4- $ SigD noExtField (SpecInstSig (EpAnn (glR happy_var_1) [mo happy_var_1,mj AnnInstance happy_var_2,mc happy_var_4] cs) (getSPEC_PRAGs happy_var_1) happy_var_3)))}}}})- ) (\r -> happyReturn (happyIn202 r))--happyReduce_483 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_483 = happyMonadReduce 3# 186# happyReduction_483-happyReduction_483 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut263 happy_x_2 of { (HappyWrap263 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( acsA (\cs -> sLL happy_var_1 happy_var_3 $ SigD noExtField (MinimalSig (EpAnn (glR happy_var_1) [mo happy_var_1,mc happy_var_3] cs) (getMINIMAL_PRAGs happy_var_1) happy_var_2)))}}})- ) (\r -> happyReturn (happyIn202 r))--happyReduce_484 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_484 = happySpecReduce_0 187# happyReduction_484-happyReduction_484 = happyIn203- (([],Nothing)- )--happyReduce_485 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_485 = happySpecReduce_1 187# happyReduction_485-happyReduction_485 happy_x_1- = case happyOut204 happy_x_1 of { (HappyWrap204 happy_var_1) -> - happyIn203- ((fst happy_var_1,Just (snd happy_var_1))- )}--happyReduce_486 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_486 = happySpecReduce_3 188# happyReduction_486-happyReduction_486 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn204- (([mj AnnOpenS happy_var_1,mj AnnVal happy_var_2,mj AnnCloseS happy_var_3]- ,ActiveAfter (getINTEGERs happy_var_2) (fromInteger (il_value (getINTEGER happy_var_2))))- )}}}--happyReduce_487 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_487 = happyReduce 4# 188# happyReduction_487-happyReduction_487 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut134 happy_x_2 of { (HappyWrap134 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - happyIn204- ((happy_var_2++[mj AnnOpenS happy_var_1,mj AnnVal happy_var_3,mj AnnCloseS happy_var_4]- ,ActiveBefore (getINTEGERs happy_var_3) (fromInteger (il_value (getINTEGER happy_var_3))))- ) `HappyStk` happyRest}}}}--happyReduce_488 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_488 = happySpecReduce_1 189# happyReduction_488-happyReduction_488 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn205- (let { loc = getLoc happy_var_1- ; ITquasiQuote (quoter, quote, quoteSpan) = unLoc happy_var_1- ; quoterId = mkUnqual varName quoter }- in sL1 happy_var_1 (mkHsQuasiQuote quoterId (mkSrcSpanPs quoteSpan) quote)- )}--happyReduce_489 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_489 = happySpecReduce_1 189# happyReduction_489-happyReduction_489 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn205- (let { loc = getLoc happy_var_1- ; ITqQuasiQuote (qual, quoter, quote, quoteSpan) = unLoc happy_var_1- ; quoterId = mkQual varName (qual, quoter) }- in sL1 happy_var_1 (mkHsQuasiQuote quoterId (mkSrcSpanPs quoteSpan) quote)- )}--happyReduce_490 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_490 = happySpecReduce_3 190# happyReduction_490-happyReduction_490 happy_x_3- happy_x_2- happy_x_1- = case happyOut207 happy_x_1 of { (HappyWrap207 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut159 happy_x_3 of { (HappyWrap159 happy_var_3) -> - happyIn206- (ECP $- unECP happy_var_1 >>= \ happy_var_1 ->- rejectPragmaPV happy_var_1 >>- mkHsTySigPV (noAnnSrcSpan $ comb2Al happy_var_1 (reLoc happy_var_3)) happy_var_1 happy_var_3- [(mu AnnDcolon happy_var_2)]- )}}}--happyReduce_491 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_491 = happyMonadReduce 3# 190# happyReduction_491-happyReduction_491 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut207 happy_x_1 of { (HappyWrap207 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut206 happy_x_3 of { (HappyWrap206 happy_var_3) -> - ( runPV (unECP happy_var_1) >>= \ happy_var_1 ->- runPV (unECP happy_var_3) >>= \ happy_var_3 ->- fmap ecpFromCmd $- acsA (\cs -> sLLAA happy_var_1 happy_var_3 $ HsCmdArrApp (EpAnn (glAR happy_var_1) (mu Annlarrowtail happy_var_2) cs) happy_var_1 happy_var_3- HsFirstOrderApp True))}}})- ) (\r -> happyReturn (happyIn206 r))--happyReduce_492 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_492 = happyMonadReduce 3# 190# happyReduction_492-happyReduction_492 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut207 happy_x_1 of { (HappyWrap207 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut206 happy_x_3 of { (HappyWrap206 happy_var_3) -> - ( runPV (unECP happy_var_1) >>= \ happy_var_1 ->- runPV (unECP happy_var_3) >>= \ happy_var_3 ->- fmap ecpFromCmd $- acsA (\cs -> sLLAA happy_var_1 happy_var_3 $ HsCmdArrApp (EpAnn (glAR happy_var_1) (mu Annrarrowtail happy_var_2) cs) happy_var_3 happy_var_1- HsFirstOrderApp False))}}})- ) (\r -> happyReturn (happyIn206 r))--happyReduce_493 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_493 = happyMonadReduce 3# 190# happyReduction_493-happyReduction_493 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut207 happy_x_1 of { (HappyWrap207 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut206 happy_x_3 of { (HappyWrap206 happy_var_3) -> - ( runPV (unECP happy_var_1) >>= \ happy_var_1 ->- runPV (unECP happy_var_3) >>= \ happy_var_3 ->- fmap ecpFromCmd $- acsA (\cs -> sLLAA happy_var_1 happy_var_3 $ HsCmdArrApp (EpAnn (glAR happy_var_1) (mu AnnLarrowtail happy_var_2) cs) happy_var_1 happy_var_3- HsHigherOrderApp True))}}})- ) (\r -> happyReturn (happyIn206 r))--happyReduce_494 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_494 = happyMonadReduce 3# 190# happyReduction_494-happyReduction_494 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut207 happy_x_1 of { (HappyWrap207 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut206 happy_x_3 of { (HappyWrap206 happy_var_3) -> - ( runPV (unECP happy_var_1) >>= \ happy_var_1 ->- runPV (unECP happy_var_3) >>= \ happy_var_3 ->- fmap ecpFromCmd $- acsA (\cs -> sLLAA happy_var_1 happy_var_3 $ HsCmdArrApp (EpAnn (glAR happy_var_1) (mu AnnRarrowtail happy_var_2) cs) happy_var_3 happy_var_1- HsHigherOrderApp False))}}})- ) (\r -> happyReturn (happyIn206 r))--happyReduce_495 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_495 = happySpecReduce_1 190# happyReduction_495-happyReduction_495 happy_x_1- = case happyOut207 happy_x_1 of { (HappyWrap207 happy_var_1) -> - happyIn206- (happy_var_1- )}--happyReduce_496 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_496 = happySpecReduce_1 190# happyReduction_496-happyReduction_496 happy_x_1- = case happyOut321 happy_x_1 of { (HappyWrap321 happy_var_1) -> - happyIn206- (happy_var_1- )}--happyReduce_497 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_497 = happySpecReduce_1 191# happyReduction_497-happyReduction_497 happy_x_1- = case happyOut209 happy_x_1 of { (HappyWrap209 happy_var_1) -> - happyIn207- (happy_var_1- )}--happyReduce_498 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_498 = happySpecReduce_3 191# happyReduction_498-happyReduction_498 happy_x_3- happy_x_2- happy_x_1- = case happyOut207 happy_x_1 of { (HappyWrap207 happy_var_1) -> - case happyOut291 happy_x_2 of { (HappyWrap291 happy_var_2) -> - case happyOut208 happy_x_3 of { (HappyWrap208 happy_var_3) -> - happyIn207- (ECP $- superInfixOp $- happy_var_2 >>= \ happy_var_2 ->- unECP happy_var_1 >>= \ happy_var_1 ->- unECP happy_var_3 >>= \ happy_var_3 ->- rejectPragmaPV happy_var_1 >>- (mkHsOpAppPV (comb2A (reLoc happy_var_1) happy_var_3) happy_var_1 happy_var_2 happy_var_3)- )}}}--happyReduce_499 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_499 = happySpecReduce_1 192# happyReduction_499-happyReduction_499 happy_x_1- = case happyOut209 happy_x_1 of { (HappyWrap209 happy_var_1) -> - happyIn208- (happy_var_1- )}--happyReduce_500 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_500 = happySpecReduce_1 192# happyReduction_500-happyReduction_500 happy_x_1- = case happyOut322 happy_x_1 of { (HappyWrap322 happy_var_1) -> - happyIn208- (happy_var_1- )}--happyReduce_501 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_501 = happySpecReduce_2 193# happyReduction_501-happyReduction_501 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut212 happy_x_2 of { (HappyWrap212 happy_var_2) -> - happyIn209- (ECP $- unECP happy_var_2 >>= \ happy_var_2 ->- mkHsNegAppPV (comb2A happy_var_1 happy_var_2) happy_var_2- [mj AnnMinus happy_var_1]- )}}--happyReduce_502 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_502 = happySpecReduce_1 193# happyReduction_502-happyReduction_502 happy_x_1- = case happyOut212 happy_x_1 of { (HappyWrap212 happy_var_1) -> - happyIn209- (happy_var_1- )}--happyReduce_503 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_503 = happySpecReduce_1 194# happyReduction_503-happyReduction_503 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn210- ((msemim happy_var_1,True)- )}--happyReduce_504 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_504 = happySpecReduce_0 194# happyReduction_504-happyReduction_504 = happyIn210- ((Nothing,False)- )--happyReduce_505 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_505 = happyMonadReduce 3# 195# happyReduction_505-happyReduction_505 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( do { scc <- getSCC happy_var_2- ; acs (\cs -> (sLL happy_var_1 happy_var_3- (HsPragSCC- (EpAnn (glR happy_var_1) (AnnPragma (mo happy_var_1) (mc happy_var_3) [mj AnnValStr happy_var_2]) cs)- (getSCC_PRAGs happy_var_1)- (StringLiteral (getSTRINGs happy_var_2) scc Nothing))))})}}})- ) (\r -> happyReturn (happyIn211 r))--happyReduce_506 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_506 = happyMonadReduce 3# 195# happyReduction_506-happyReduction_506 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( acs (\cs -> (sLL happy_var_1 happy_var_3- (HsPragSCC- (EpAnn (glR happy_var_1) (AnnPragma (mo happy_var_1) (mc happy_var_3) [mj AnnVal happy_var_2]) cs)- (getSCC_PRAGs happy_var_1)- (StringLiteral NoSourceText (getVARID happy_var_2) Nothing)))))}}})- ) (\r -> happyReturn (happyIn211 r))--happyReduce_507 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_507 = happySpecReduce_2 196# happyReduction_507-happyReduction_507 happy_x_2- happy_x_1- = case happyOut212 happy_x_1 of { (HappyWrap212 happy_var_1) -> - case happyOut213 happy_x_2 of { (HappyWrap213 happy_var_2) -> - happyIn212- (ECP $- superFunArg $- unECP happy_var_1 >>= \ happy_var_1 ->- unECP happy_var_2 >>= \ happy_var_2 ->- mkHsAppPV (noAnnSrcSpan $ comb2A (reLoc happy_var_1) happy_var_2) happy_var_1 happy_var_2- )}}--happyReduce_508 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_508 = happySpecReduce_3 196# happyReduction_508-happyReduction_508 happy_x_3- happy_x_2- happy_x_1- = case happyOut212 happy_x_1 of { (HappyWrap212 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut168 happy_x_3 of { (HappyWrap168 happy_var_3) -> - happyIn212- (ECP $- unECP happy_var_1 >>= \ happy_var_1 ->- mkHsAppTypePV (noAnnSrcSpan $ comb2 (reLoc happy_var_1) (reLoc happy_var_3)) happy_var_1 (getLoc happy_var_2) happy_var_3- )}}}--happyReduce_509 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_509 = happyMonadReduce 2# 196# happyReduction_509-happyReduction_509 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut213 happy_x_2 of { (HappyWrap213 happy_var_2) -> - ( runPV (unECP happy_var_2) >>= \ happy_var_2 ->- fmap ecpFromExp $- acsA (\cs -> sLL happy_var_1 (reLoc happy_var_2) $ HsStatic (EpAnn (glR happy_var_1) [mj AnnStatic happy_var_1] cs) happy_var_2))}})- ) (\r -> happyReturn (happyIn212 r))--happyReduce_510 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_510 = happySpecReduce_1 196# happyReduction_510-happyReduction_510 happy_x_1- = case happyOut213 happy_x_1 of { (HappyWrap213 happy_var_1) -> - happyIn212- (happy_var_1- )}--happyReduce_511 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_511 = happySpecReduce_3 197# happyReduction_511-happyReduction_511 happy_x_3- happy_x_2- happy_x_1- = case happyOut300 happy_x_1 of { (HappyWrap300 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut213 happy_x_3 of { (HappyWrap213 happy_var_3) -> - happyIn213- (ECP $- unECP happy_var_3 >>= \ happy_var_3 ->- mkHsAsPatPV (comb2 (reLocN happy_var_1) (reLoc happy_var_3)) happy_var_1 happy_var_3 [mj AnnAt happy_var_2]- )}}}--happyReduce_512 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_512 = happySpecReduce_2 197# happyReduction_512-happyReduction_512 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut213 happy_x_2 of { (HappyWrap213 happy_var_2) -> - happyIn213- (ECP $- unECP happy_var_2 >>= \ happy_var_2 ->- mkHsLazyPatPV (comb2 happy_var_1 (reLoc happy_var_2)) happy_var_2 [mj AnnTilde happy_var_1]- )}}--happyReduce_513 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_513 = happySpecReduce_2 197# happyReduction_513-happyReduction_513 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut213 happy_x_2 of { (HappyWrap213 happy_var_2) -> - happyIn213- (ECP $- unECP happy_var_2 >>= \ happy_var_2 ->- mkHsBangPatPV (comb2 happy_var_1 (reLoc happy_var_2)) happy_var_2 [mj AnnBang happy_var_1]- )}}--happyReduce_514 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_514 = happySpecReduce_2 197# happyReduction_514-happyReduction_514 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut213 happy_x_2 of { (HappyWrap213 happy_var_2) -> - happyIn213- (ECP $- unECP happy_var_2 >>= \ happy_var_2 ->- mkHsNegAppPV (comb2A happy_var_1 happy_var_2) happy_var_2 [mj AnnMinus happy_var_1]- )}}--happyReduce_515 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_515 = happyReduce 5# 197# happyReduction_515-happyReduction_515 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut247 happy_x_2 of { (HappyWrap247 happy_var_2) -> - case happyOut248 happy_x_3 of { (HappyWrap248 happy_var_3) -> - case happyOutTok happy_x_4 of { happy_var_4 -> - case happyOut206 happy_x_5 of { (HappyWrap206 happy_var_5) -> - happyIn213- (ECP $- unECP happy_var_5 >>= \ happy_var_5 ->- mkHsLamPV (comb2 happy_var_1 (reLoc happy_var_5)) (\cs -> mkMatchGroup FromSource- (reLocA $ sLLlA happy_var_1 happy_var_5- [reLocA $ sLLlA happy_var_1 happy_var_5- $ Match { m_ext = EpAnn (glR happy_var_1) [mj AnnLam happy_var_1] cs- , m_ctxt = LambdaExpr- , m_pats = happy_var_2:happy_var_3- , m_grhss = unguardedGRHSs (comb2 happy_var_4 (reLoc happy_var_5)) happy_var_5 (EpAnn (glR happy_var_4) (GrhsAnn Nothing (mu AnnRarrow happy_var_4)) emptyComments) }]))- ) `HappyStk` happyRest}}}}}--happyReduce_516 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_516 = happyReduce 4# 197# happyReduction_516-happyReduction_516 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut129 happy_x_2 of { (HappyWrap129 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut206 happy_x_4 of { (HappyWrap206 happy_var_4) -> - happyIn213- (ECP $- unECP happy_var_4 >>= \ happy_var_4 ->- mkHsLetPV (comb2A happy_var_1 happy_var_4) (unLoc happy_var_2) happy_var_4- (AnnsLet (glAA happy_var_1) (glAA happy_var_3))- ) `HappyStk` happyRest}}}}--happyReduce_517 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_517 = happySpecReduce_3 197# happyReduction_517-happyReduction_517 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut236 happy_x_3 of { (HappyWrap236 happy_var_3) -> - happyIn213- (ECP $ happy_var_3 >>= \ happy_var_3 ->- mkHsLamCasePV (comb2 happy_var_1 (reLoc happy_var_3)) happy_var_3 [mj AnnLam happy_var_1,mj AnnCase happy_var_2]- )}}}--happyReduce_518 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_518 = happyMonadReduce 8# 197# happyReduction_518-happyReduction_518 (happy_x_8 `HappyStk`- happy_x_7 `HappyStk`- happy_x_6 `HappyStk`- happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut206 happy_x_2 of { (HappyWrap206 happy_var_2) -> - case happyOut210 happy_x_3 of { (HappyWrap210 happy_var_3) -> - case happyOutTok happy_x_4 of { happy_var_4 -> - case happyOut206 happy_x_5 of { (HappyWrap206 happy_var_5) -> - case happyOut210 happy_x_6 of { (HappyWrap210 happy_var_6) -> - case happyOutTok happy_x_7 of { happy_var_7 -> - case happyOut206 happy_x_8 of { (HappyWrap206 happy_var_8) -> - ( runPV (unECP happy_var_2) >>= \ (happy_var_2 :: LHsExpr GhcPs) ->- return $ ECP $- unECP happy_var_5 >>= \ happy_var_5 ->- unECP happy_var_8 >>= \ happy_var_8 ->- mkHsIfPV (comb2A happy_var_1 happy_var_8) happy_var_2 (snd happy_var_3) happy_var_5 (snd happy_var_6) happy_var_8- (AnnsIf- { aiIf = glAA happy_var_1- , aiThen = glAA happy_var_4- , aiElse = glAA happy_var_7- , aiThenSemi = fst happy_var_3- , aiElseSemi = fst happy_var_6}))}}}}}}}})- ) (\r -> happyReturn (happyIn213 r))--happyReduce_519 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_519 = happyMonadReduce 2# 197# happyReduction_519-happyReduction_519 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut243 happy_x_2 of { (HappyWrap243 happy_var_2) -> - ( hintMultiWayIf (getLoc happy_var_1) >>= \_ ->- fmap ecpFromExp $- acsA (\cs -> sLL happy_var_1 happy_var_2 $ HsMultiIf (EpAnn (glR happy_var_1) (mj AnnIf happy_var_1:(fst $ unLoc happy_var_2)) cs)- (reverse $ snd $ unLoc happy_var_2)))}})- ) (\r -> happyReturn (happyIn213 r))--happyReduce_520 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_520 = happyMonadReduce 4# 197# happyReduction_520-happyReduction_520 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut206 happy_x_2 of { (HappyWrap206 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut236 happy_x_4 of { (HappyWrap236 happy_var_4) -> - ( runPV (unECP happy_var_2) >>= \ (happy_var_2 :: LHsExpr GhcPs) ->- return $ ECP $- happy_var_4 >>= \ happy_var_4 ->- mkHsCasePV (comb3 happy_var_1 happy_var_3 (reLoc happy_var_4)) happy_var_2 happy_var_4- (EpAnnHsCase (glAA happy_var_1) (glAA happy_var_3) []))}}}})- ) (\r -> happyReturn (happyIn213 r))--happyReduce_521 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_521 = happyMonadReduce 2# 197# happyReduction_521-happyReduction_521 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut249 happy_x_2 of { (HappyWrap249 happy_var_2) -> - ( do- hintQualifiedDo happy_var_1- return $ ECP $- happy_var_2 >>= \ happy_var_2 ->- mkHsDoPV (comb2A happy_var_1 happy_var_2)- (fmap mkModuleNameFS (getDO happy_var_1))- happy_var_2- (AnnList (Just $ glAR happy_var_2) Nothing Nothing [mj AnnDo happy_var_1] []))}})- ) (\r -> happyReturn (happyIn213 r))--happyReduce_522 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_522 = happyMonadReduce 2# 197# happyReduction_522-happyReduction_522 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut249 happy_x_2 of { (HappyWrap249 happy_var_2) -> - ( hintQualifiedDo happy_var_1 >> runPV happy_var_2 >>= \ happy_var_2 ->- fmap ecpFromExp $- acsA (\cs -> L (comb2A happy_var_1 happy_var_2)- (mkHsDoAnns (MDoExpr $- fmap mkModuleNameFS (getMDO happy_var_1))- happy_var_2- (EpAnn (glR happy_var_1) (AnnList (Just $ glAR happy_var_2) Nothing Nothing [mj AnnMdo happy_var_1] []) cs) )))}})- ) (\r -> happyReturn (happyIn213 r))--happyReduce_523 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_523 = happyMonadReduce 4# 197# happyReduction_523-happyReduction_523 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut213 happy_x_2 of { (HappyWrap213 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut206 happy_x_4 of { (HappyWrap206 happy_var_4) -> - ( (checkPattern <=< runPV) (unECP happy_var_2) >>= \ p ->- runPV (unECP happy_var_4) >>= \ happy_var_4@cmd ->- fmap ecpFromExp $- acsA (\cs -> sLLlA happy_var_1 happy_var_4 $ HsProc (EpAnn (glR happy_var_1) [mj AnnProc happy_var_1,mu AnnRarrow happy_var_3] cs) p (sLLlA happy_var_1 happy_var_4 $ HsCmdTop noExtField cmd)))}}}})- ) (\r -> happyReturn (happyIn213 r))--happyReduce_524 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_524 = happySpecReduce_1 197# happyReduction_524-happyReduction_524 happy_x_1- = case happyOut214 happy_x_1 of { (HappyWrap214 happy_var_1) -> - happyIn213- (happy_var_1- )}--happyReduce_525 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_525 = happyReduce 4# 198# happyReduction_525-happyReduction_525 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut214 happy_x_1 of { (HappyWrap214 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut255 happy_x_3 of { (HappyWrap255 happy_var_3) -> - case happyOutTok happy_x_4 of { happy_var_4 -> - happyIn214- (ECP $- getBit OverloadedRecordUpdateBit >>= \ overloaded ->- unECP happy_var_1 >>= \ happy_var_1 ->- happy_var_3 >>= \ happy_var_3 ->- mkHsRecordPV overloaded (comb2 (reLoc happy_var_1) happy_var_4) (comb2 happy_var_2 happy_var_4) happy_var_1 happy_var_3- [moc happy_var_2,mcc happy_var_4]- ) `HappyStk` happyRest}}}}--happyReduce_526 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_526 = happyMonadReduce 3# 198# happyReduction_526-happyReduction_526 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut214 happy_x_1 of { (HappyWrap214 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut301 happy_x_3 of { (HappyWrap301 happy_var_3) -> - ( runPV (unECP happy_var_1) >>= \ happy_var_1 ->- fmap ecpFromExp $ acsa (\cs ->- let fl = sLL happy_var_2 happy_var_3 (HsFieldLabel ((EpAnn (glR happy_var_2) (AnnFieldLabel (Just $ glAA happy_var_2)) emptyComments)) happy_var_3) in- mkRdrGetField (noAnnSrcSpan $ comb2 (reLoc happy_var_1) happy_var_3) happy_var_1 fl (EpAnn (glAR happy_var_1) NoEpAnns cs)))}}})- ) (\r -> happyReturn (happyIn214 r))--happyReduce_527 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_527 = happySpecReduce_1 198# happyReduction_527-happyReduction_527 happy_x_1- = case happyOut215 happy_x_1 of { (HappyWrap215 happy_var_1) -> - happyIn214- (happy_var_1- )}--happyReduce_528 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_528 = happySpecReduce_1 199# happyReduction_528-happyReduction_528 happy_x_1- = case happyOut300 happy_x_1 of { (HappyWrap300 happy_var_1) -> - happyIn215- (ECP $ mkHsVarPV $! happy_var_1- )}--happyReduce_529 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_529 = happySpecReduce_1 199# happyReduction_529-happyReduction_529 happy_x_1- = case happyOut271 happy_x_1 of { (HappyWrap271 happy_var_1) -> - happyIn215- (ECP $ mkHsVarPV $! happy_var_1- )}--happyReduce_530 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_530 = happyMonadReduce 1# 199# happyReduction_530-happyReduction_530 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut261 happy_x_1 of { (HappyWrap261 happy_var_1) -> - ( acsExpr (\cs -> sL1a happy_var_1 (HsIPVar (comment (glRR happy_var_1) cs) $! unLoc happy_var_1)))})- ) (\r -> happyReturn (happyIn215 r))--happyReduce_531 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_531 = happyMonadReduce 1# 199# happyReduction_531-happyReduction_531 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut262 happy_x_1 of { (HappyWrap262 happy_var_1) -> - ( acsExpr (\cs -> sL1a happy_var_1 (HsOverLabel (comment (glRR happy_var_1) cs) $! unLoc happy_var_1)))})- ) (\r -> happyReturn (happyIn215 r))--happyReduce_532 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_532 = happySpecReduce_1 199# happyReduction_532-happyReduction_532 happy_x_1- = case happyOut315 happy_x_1 of { (HappyWrap315 happy_var_1) -> - happyIn215- (ECP $ pvA (mkHsLitPV $! happy_var_1)- )}--happyReduce_533 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_533 = happySpecReduce_1 199# happyReduction_533-happyReduction_533 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn215- (ECP $ pvA $ mkHsOverLitPV (sL1 happy_var_1 $ mkHsIntegral (getINTEGER happy_var_1))- )}--happyReduce_534 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_534 = happySpecReduce_1 199# happyReduction_534-happyReduction_534 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn215- (ECP $ pvA $ mkHsOverLitPV (sL1 happy_var_1 $ mkHsFractional (getRATIONAL happy_var_1))- )}--happyReduce_535 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_535 = happySpecReduce_3 199# happyReduction_535-happyReduction_535 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut224 happy_x_2 of { (HappyWrap224 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn215- (ECP $- unECP happy_var_2 >>= \ happy_var_2 ->- mkHsParPV (comb2 happy_var_1 happy_var_3) happy_var_2 (AnnParen AnnParens (glAA happy_var_1) (glAA happy_var_3))- )}}}--happyReduce_536 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_536 = happySpecReduce_3 199# happyReduction_536-happyReduction_536 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut225 happy_x_2 of { (HappyWrap225 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn215- (ECP $- happy_var_2 >>= \ happy_var_2 ->- mkSumOrTuplePV (noAnnSrcSpan $ comb2 happy_var_1 happy_var_3) Boxed happy_var_2- [mop happy_var_1,mcp happy_var_3]- )}}}--happyReduce_537 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_537 = happySpecReduce_3 199# happyReduction_537-happyReduction_537 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut216 happy_x_2 of { (HappyWrap216 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn215- (ECP $- acsA (\cs -> sLL happy_var_1 happy_var_3 $ mkRdrProjection (NE.reverse (unLoc happy_var_2)) (EpAnn (glR happy_var_1) (AnnProjection (glAA happy_var_1) (glAA happy_var_3)) cs))- >>= ecpFromExp'- )}}}--happyReduce_538 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_538 = happySpecReduce_3 199# happyReduction_538-happyReduction_538 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut224 happy_x_2 of { (HappyWrap224 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn215- (ECP $- unECP happy_var_2 >>= \ happy_var_2 ->- mkSumOrTuplePV (noAnnSrcSpan $ comb2 happy_var_1 happy_var_3) Unboxed (Tuple [Right happy_var_2])- [moh happy_var_1,mch happy_var_3]- )}}}--happyReduce_539 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_539 = happySpecReduce_3 199# happyReduction_539-happyReduction_539 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut225 happy_x_2 of { (HappyWrap225 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn215- (ECP $- happy_var_2 >>= \ happy_var_2 ->- mkSumOrTuplePV (noAnnSrcSpan $ comb2 happy_var_1 happy_var_3) Unboxed happy_var_2- [moh happy_var_1,mch happy_var_3]- )}}}--happyReduce_540 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_540 = happySpecReduce_3 199# happyReduction_540-happyReduction_540 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut228 happy_x_2 of { (HappyWrap228 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn215- (ECP $ happy_var_2 (comb2 happy_var_1 happy_var_3) (mos happy_var_1,mcs happy_var_3)- )}}}--happyReduce_541 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_541 = happySpecReduce_1 199# happyReduction_541-happyReduction_541 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn215- (ECP $ pvA $ mkHsWildCardPV (getLoc happy_var_1)- )}--happyReduce_542 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_542 = happySpecReduce_1 199# happyReduction_542-happyReduction_542 happy_x_1- = case happyOut218 happy_x_1 of { (HappyWrap218 happy_var_1) -> - happyIn215- (ECP $ pvA $ mkHsSplicePV happy_var_1- )}--happyReduce_543 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_543 = happySpecReduce_1 199# happyReduction_543-happyReduction_543 happy_x_1- = case happyOut219 happy_x_1 of { (HappyWrap219 happy_var_1) -> - happyIn215- (ecpFromExp $ mapLoc (HsSpliceE noAnn) (reLocA happy_var_1)- )}--happyReduce_544 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_544 = happyMonadReduce 2# 199# happyReduction_544-happyReduction_544 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut300 happy_x_2 of { (HappyWrap300 happy_var_2) -> - ( fmap ecpFromExp $ acsA (\cs -> sLL happy_var_1 (reLocN happy_var_2) $ HsBracket (EpAnn (glR happy_var_1) [mj AnnSimpleQuote happy_var_1] cs) (VarBr noExtField True happy_var_2)))}})- ) (\r -> happyReturn (happyIn215 r))--happyReduce_545 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_545 = happyMonadReduce 2# 199# happyReduction_545-happyReduction_545 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut271 happy_x_2 of { (HappyWrap271 happy_var_2) -> - ( fmap ecpFromExp $ acsA (\cs -> sLL happy_var_1 (reLocN happy_var_2) $ HsBracket (EpAnn (glR happy_var_1) [mj AnnSimpleQuote happy_var_1] cs) (VarBr noExtField True happy_var_2)))}})- ) (\r -> happyReturn (happyIn215 r))--happyReduce_546 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_546 = happyMonadReduce 2# 199# happyReduction_546-happyReduction_546 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut296 happy_x_2 of { (HappyWrap296 happy_var_2) -> - ( fmap ecpFromExp $ acsA (\cs -> sLL happy_var_1 (reLocN happy_var_2) $ HsBracket (EpAnn (glR happy_var_1) [mj AnnThTyQuote happy_var_1 ] cs) (VarBr noExtField False happy_var_2)))}})- ) (\r -> happyReturn (happyIn215 r))--happyReduce_547 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_547 = happyMonadReduce 2# 199# happyReduction_547-happyReduction_547 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut279 happy_x_2 of { (HappyWrap279 happy_var_2) -> - ( fmap ecpFromExp $ acsA (\cs -> sLL happy_var_1 (reLocN happy_var_2) $ HsBracket (EpAnn (glR happy_var_1) [mj AnnThTyQuote happy_var_1 ] cs) (VarBr noExtField False happy_var_2)))}})- ) (\r -> happyReturn (happyIn215 r))--happyReduce_548 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_548 = happyMonadReduce 1# 199# happyReduction_548-happyReduction_548 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - ( reportEmptyDoubleQuotes (getLoc happy_var_1))})- ) (\r -> happyReturn (happyIn215 r))--happyReduce_549 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_549 = happyMonadReduce 3# 199# happyReduction_549-happyReduction_549 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut206 happy_x_2 of { (HappyWrap206 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( runPV (unECP happy_var_2) >>= \ happy_var_2 ->- fmap ecpFromExp $- acsA (\cs -> sLL happy_var_1 happy_var_3 $ HsBracket (EpAnn (glR happy_var_1) (if (hasE happy_var_1) then [mj AnnOpenE happy_var_1, mu AnnCloseQ happy_var_3]- else [mu AnnOpenEQ happy_var_1,mu AnnCloseQ happy_var_3]) cs) (ExpBr noExtField happy_var_2)))}}})- ) (\r -> happyReturn (happyIn215 r))--happyReduce_550 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_550 = happyMonadReduce 3# 199# happyReduction_550-happyReduction_550 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut206 happy_x_2 of { (HappyWrap206 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( runPV (unECP happy_var_2) >>= \ happy_var_2 ->- fmap ecpFromExp $- acsA (\cs -> sLL happy_var_1 happy_var_3 $ HsBracket (EpAnn (glR happy_var_1) (if (hasE happy_var_1) then [mj AnnOpenE happy_var_1,mc happy_var_3] else [mo happy_var_1,mc happy_var_3]) cs) (TExpBr noExtField happy_var_2)))}}})- ) (\r -> happyReturn (happyIn215 r))--happyReduce_551 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_551 = happyMonadReduce 3# 199# happyReduction_551-happyReduction_551 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut158 happy_x_2 of { (HappyWrap158 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( fmap ecpFromExp $- acsA (\cs -> sLL happy_var_1 happy_var_3 $ HsBracket (EpAnn (glR happy_var_1) [mo happy_var_1,mu AnnCloseQ happy_var_3] cs) (TypBr noExtField happy_var_2)))}}})- ) (\r -> happyReturn (happyIn215 r))--happyReduce_552 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_552 = happyMonadReduce 3# 199# happyReduction_552-happyReduction_552 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut207 happy_x_2 of { (HappyWrap207 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( (checkPattern <=< runPV) (unECP happy_var_2) >>= \p ->- fmap ecpFromExp $- acsA (\cs -> sLL happy_var_1 happy_var_3 $ HsBracket (EpAnn (glR happy_var_1) [mo happy_var_1,mu AnnCloseQ happy_var_3] cs) (PatBr noExtField p)))}}})- ) (\r -> happyReturn (happyIn215 r))--happyReduce_553 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_553 = happyMonadReduce 3# 199# happyReduction_553-happyReduction_553 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut222 happy_x_2 of { (HappyWrap222 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( fmap ecpFromExp $- acsA (\cs -> sLL happy_var_1 happy_var_3 $ HsBracket (EpAnn (glR happy_var_1) (mo happy_var_1:mu AnnCloseQ happy_var_3:fst happy_var_2) cs) (DecBrL noExtField (snd happy_var_2))))}}})- ) (\r -> happyReturn (happyIn215 r))--happyReduce_554 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_554 = happySpecReduce_1 199# happyReduction_554-happyReduction_554 happy_x_1- = case happyOut205 happy_x_1 of { (HappyWrap205 happy_var_1) -> - happyIn215- (ECP $ pvA $ mkHsSplicePV happy_var_1- )}--happyReduce_555 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_555 = happyMonadReduce 4# 199# happyReduction_555-happyReduction_555 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut213 happy_x_2 of { (HappyWrap213 happy_var_2) -> - case happyOut220 happy_x_3 of { (HappyWrap220 happy_var_3) -> - case happyOutTok happy_x_4 of { happy_var_4 -> - ( runPV (unECP happy_var_2) >>= \ happy_var_2 ->- fmap ecpFromCmd $- acsA (\cs -> sLL happy_var_1 happy_var_4 $ HsCmdArrForm (EpAnn (glR happy_var_1) (AnnList (Just $ glR happy_var_1) (Just $ mu AnnOpenB happy_var_1) (Just $ mu AnnCloseB happy_var_4) [] []) cs) happy_var_2 Prefix- Nothing (reverse happy_var_3)))}}}})- ) (\r -> happyReturn (happyIn215 r))--happyReduce_556 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_556 = happyMonadReduce 3# 200# happyReduction_556-happyReduction_556 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut216 happy_x_1 of { (HappyWrap216 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut301 happy_x_3 of { (HappyWrap301 happy_var_3) -> - ( acs (\cs -> sLL happy_var_1 happy_var_3 ((sLL happy_var_2 happy_var_3 $ HsFieldLabel (EpAnn (glR happy_var_1) (AnnFieldLabel (Just $ glAA happy_var_2)) cs) happy_var_3) `NE.cons` unLoc happy_var_1)))}}})- ) (\r -> happyReturn (happyIn216 r))--happyReduce_557 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_557 = happyMonadReduce 2# 200# happyReduction_557-happyReduction_557 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut301 happy_x_2 of { (HappyWrap301 happy_var_2) -> - ( acs (\cs -> sLL happy_var_1 happy_var_2 ((sLL happy_var_1 happy_var_2 $ HsFieldLabel (EpAnn (glR happy_var_1) (AnnFieldLabel (Just $ glAA happy_var_1)) cs) happy_var_2) :| [])))}})- ) (\r -> happyReturn (happyIn216 r))--happyReduce_558 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_558 = happySpecReduce_1 201# happyReduction_558-happyReduction_558 happy_x_1- = case happyOut218 happy_x_1 of { (HappyWrap218 happy_var_1) -> - happyIn217- (mapLoc (HsSpliceE noAnn) (reLocA happy_var_1)- )}--happyReduce_559 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_559 = happySpecReduce_1 201# happyReduction_559-happyReduction_559 happy_x_1- = case happyOut219 happy_x_1 of { (HappyWrap219 happy_var_1) -> - happyIn217- (mapLoc (HsSpliceE noAnn) (reLocA happy_var_1)- )}--happyReduce_560 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_560 = happyMonadReduce 2# 202# happyReduction_560-happyReduction_560 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut215 happy_x_2 of { (HappyWrap215 happy_var_2) -> - ( runPV (unECP happy_var_2) >>= \ happy_var_2 ->- acs (\cs -> sLLlA happy_var_1 happy_var_2 $ mkUntypedSplice (EpAnn (glR happy_var_1) [mj AnnDollar happy_var_1] cs) DollarSplice happy_var_2))}})- ) (\r -> happyReturn (happyIn218 r))--happyReduce_561 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_561 = happyMonadReduce 2# 203# happyReduction_561-happyReduction_561 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut215 happy_x_2 of { (HappyWrap215 happy_var_2) -> - ( runPV (unECP happy_var_2) >>= \ happy_var_2 ->- acs (\cs -> sLLlA happy_var_1 happy_var_2 $ mkTypedSplice (EpAnn (glR happy_var_1) [mj AnnDollarDollar happy_var_1] cs) DollarSplice happy_var_2))}})- ) (\r -> happyReturn (happyIn219 r))--happyReduce_562 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_562 = happySpecReduce_2 204# happyReduction_562-happyReduction_562 happy_x_2- happy_x_1- = case happyOut220 happy_x_1 of { (HappyWrap220 happy_var_1) -> - case happyOut221 happy_x_2 of { (HappyWrap221 happy_var_2) -> - happyIn220- (happy_var_2 : happy_var_1- )}}--happyReduce_563 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_563 = happySpecReduce_0 204# happyReduction_563-happyReduction_563 = happyIn220- ([]- )--happyReduce_564 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_564 = happyMonadReduce 1# 205# happyReduction_564-happyReduction_564 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut213 happy_x_1 of { (HappyWrap213 happy_var_1) -> - ( runPV (unECP happy_var_1) >>= \ (cmd :: LHsCmd GhcPs) ->- runPV (checkCmdBlockArguments cmd) >>= \ _ ->- return (sL1A cmd $ HsCmdTop noExtField cmd))})- ) (\r -> happyReturn (happyIn221 r))--happyReduce_565 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_565 = happySpecReduce_3 206# happyReduction_565-happyReduction_565 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut223 happy_x_2 of { (HappyWrap223 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn222- (([mj AnnOpenC happy_var_1- ,mj AnnCloseC happy_var_3],happy_var_2)- )}}}--happyReduce_566 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_566 = happySpecReduce_3 206# happyReduction_566-happyReduction_566 happy_x_3- happy_x_2- happy_x_1- = case happyOut223 happy_x_2 of { (HappyWrap223 happy_var_2) -> - happyIn222- (([],happy_var_2)- )}--happyReduce_567 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_567 = happySpecReduce_1 207# happyReduction_567-happyReduction_567 happy_x_1- = case happyOut74 happy_x_1 of { (HappyWrap74 happy_var_1) -> - happyIn223- (cvTopDecls happy_var_1- )}--happyReduce_568 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_568 = happySpecReduce_1 207# happyReduction_568-happyReduction_568 happy_x_1- = case happyOut73 happy_x_1 of { (HappyWrap73 happy_var_1) -> - happyIn223- (cvTopDecls happy_var_1- )}--happyReduce_569 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_569 = happySpecReduce_1 208# happyReduction_569-happyReduction_569 happy_x_1- = case happyOut206 happy_x_1 of { (HappyWrap206 happy_var_1) -> - happyIn224- (happy_var_1- )}--happyReduce_570 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_570 = happyMonadReduce 2# 208# happyReduction_570-happyReduction_570 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut207 happy_x_1 of { (HappyWrap207 happy_var_1) -> - case happyOut291 happy_x_2 of { (HappyWrap291 happy_var_2) -> - ( runPV (unECP happy_var_1) >>= \ happy_var_1 ->- runPV (rejectPragmaPV happy_var_1) >>- runPV happy_var_2 >>= \ happy_var_2 ->- return $ ecpFromExp $- reLocA $ sLL (reLoc happy_var_1) (reLocN happy_var_2) $ SectionL noAnn happy_var_1 (n2l happy_var_2))}})- ) (\r -> happyReturn (happyIn224 r))--happyReduce_571 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_571 = happySpecReduce_2 208# happyReduction_571-happyReduction_571 happy_x_2- happy_x_1- = case happyOut292 happy_x_1 of { (HappyWrap292 happy_var_1) -> - case happyOut207 happy_x_2 of { (HappyWrap207 happy_var_2) -> - happyIn224- (ECP $- superInfixOp $- unECP happy_var_2 >>= \ happy_var_2 ->- happy_var_1 >>= \ happy_var_1 ->- pvA $ mkHsSectionR_PV (comb2 (reLocN happy_var_1) (reLoc happy_var_2)) (n2l happy_var_1) happy_var_2- )}}--happyReduce_572 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_572 = happySpecReduce_3 208# happyReduction_572-happyReduction_572 happy_x_3- happy_x_2- happy_x_1- = case happyOut206 happy_x_1 of { (HappyWrap206 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut224 happy_x_3 of { (HappyWrap224 happy_var_3) -> - happyIn224- (ECP $- unECP happy_var_1 >>= \ happy_var_1 ->- unECP happy_var_3 >>= \ happy_var_3 ->- mkHsViewPatPV (comb2 (reLoc happy_var_1) (reLoc happy_var_3)) happy_var_1 happy_var_3 [mu AnnRarrow happy_var_2]- )}}}--happyReduce_573 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_573 = happySpecReduce_2 209# happyReduction_573-happyReduction_573 happy_x_2- happy_x_1- = case happyOut224 happy_x_1 of { (HappyWrap224 happy_var_1) -> - case happyOut226 happy_x_2 of { (HappyWrap226 happy_var_2) -> - happyIn225- (unECP happy_var_1 >>= \ happy_var_1 ->- happy_var_2 >>= \ happy_var_2 ->- do { t <- amsA happy_var_1 [AddCommaAnn (EpaSpan $ rs $ fst happy_var_2)]- ; return (Tuple (Right t : snd happy_var_2)) }- )}}--happyReduce_574 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_574 = happySpecReduce_2 209# happyReduction_574-happyReduction_574 happy_x_2- happy_x_1- = case happyOut318 happy_x_1 of { (HappyWrap318 happy_var_1) -> - case happyOut227 happy_x_2 of { (HappyWrap227 happy_var_2) -> - happyIn225- (happy_var_2 >>= \ happy_var_2 ->- do { let {cos = map (\ll -> (Left (EpAnn (anc $ rs ll) (EpaSpan $ rs ll) emptyComments))) (fst happy_var_1) }- ; return (Tuple (cos ++ happy_var_2)) }- )}}--happyReduce_575 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_575 = happySpecReduce_2 209# happyReduction_575-happyReduction_575 happy_x_2- happy_x_1- = case happyOut224 happy_x_1 of { (HappyWrap224 happy_var_1) -> - case happyOut320 happy_x_2 of { (HappyWrap320 happy_var_2) -> - happyIn225- (unECP happy_var_1 >>= \ happy_var_1 -> return $- (Sum 1 (snd happy_var_2 + 1) happy_var_1 [] (fst happy_var_2))- )}}--happyReduce_576 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_576 = happySpecReduce_3 209# happyReduction_576-happyReduction_576 happy_x_3- happy_x_2- happy_x_1- = case happyOut320 happy_x_1 of { (HappyWrap320 happy_var_1) -> - case happyOut224 happy_x_2 of { (HappyWrap224 happy_var_2) -> - case happyOut319 happy_x_3 of { (HappyWrap319 happy_var_3) -> - happyIn225- (unECP happy_var_2 >>= \ happy_var_2 -> return $- (Sum (snd happy_var_1 + 1) (snd happy_var_1 + snd happy_var_3 + 1) happy_var_2 (fst happy_var_1) (fst happy_var_3))- )}}}--happyReduce_577 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_577 = happySpecReduce_2 210# happyReduction_577-happyReduction_577 happy_x_2- happy_x_1- = case happyOut318 happy_x_1 of { (HappyWrap318 happy_var_1) -> - case happyOut227 happy_x_2 of { (HappyWrap227 happy_var_2) -> - happyIn226- (happy_var_2 >>= \ happy_var_2 ->- do { let {cos = map (\l -> (Left (EpAnn (anc $ rs l) (EpaSpan $ rs l) emptyComments))) (tail $ fst happy_var_1) }- ; return ((head $ fst happy_var_1, cos ++ happy_var_2)) }- )}}--happyReduce_578 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_578 = happySpecReduce_2 211# happyReduction_578-happyReduction_578 happy_x_2- happy_x_1- = case happyOut224 happy_x_1 of { (HappyWrap224 happy_var_1) -> - case happyOut226 happy_x_2 of { (HappyWrap226 happy_var_2) -> - happyIn227- (unECP happy_var_1 >>= \ happy_var_1 ->- happy_var_2 >>= \ happy_var_2 ->- do { t <- amsA happy_var_1 [AddCommaAnn (EpaSpan $ rs $ fst happy_var_2)]- ; return (Right t : snd happy_var_2) }- )}}--happyReduce_579 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_579 = happySpecReduce_1 211# happyReduction_579-happyReduction_579 happy_x_1- = case happyOut224 happy_x_1 of { (HappyWrap224 happy_var_1) -> - happyIn227- (unECP happy_var_1 >>= \ happy_var_1 ->- return [Right happy_var_1]- )}--happyReduce_580 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_580 = happySpecReduce_0 211# happyReduction_580-happyReduction_580 = happyIn227- (return [Left noAnn]- )--happyReduce_581 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_581 = happySpecReduce_1 212# happyReduction_581-happyReduction_581 happy_x_1- = case happyOut224 happy_x_1 of { (HappyWrap224 happy_var_1) -> - happyIn228- (\loc (ao,ac) -> unECP happy_var_1 >>= \ happy_var_1 ->- mkHsExplicitListPV loc [happy_var_1] (AnnList Nothing (Just ao) (Just ac) [] [])- )}--happyReduce_582 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_582 = happySpecReduce_1 212# happyReduction_582-happyReduction_582 happy_x_1- = case happyOut229 happy_x_1 of { (HappyWrap229 happy_var_1) -> - happyIn228- (\loc (ao,ac) -> happy_var_1 >>= \ happy_var_1 ->- mkHsExplicitListPV loc (reverse happy_var_1) (AnnList Nothing (Just ao) (Just ac) [] [])- )}--happyReduce_583 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_583 = happySpecReduce_2 212# happyReduction_583-happyReduction_583 happy_x_2- happy_x_1- = case happyOut224 happy_x_1 of { (HappyWrap224 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - happyIn228- (\loc (ao,ac) -> unECP happy_var_1 >>= \ happy_var_1 ->- acsA (\cs -> L loc $ ArithSeq (EpAnn (spanAsAnchor loc) [ao,mj AnnDotdot happy_var_2,ac] cs) Nothing (From happy_var_1))- >>= ecpFromExp'- )}}--happyReduce_584 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_584 = happyReduce 4# 212# happyReduction_584-happyReduction_584 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut224 happy_x_1 of { (HappyWrap224 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut206 happy_x_3 of { (HappyWrap206 happy_var_3) -> - case happyOutTok happy_x_4 of { happy_var_4 -> - happyIn228- (\loc (ao,ac) ->- unECP happy_var_1 >>= \ happy_var_1 ->- unECP happy_var_3 >>= \ happy_var_3 ->- acsA (\cs -> L loc $ ArithSeq (EpAnn (spanAsAnchor loc) [ao,mj AnnComma happy_var_2,mj AnnDotdot happy_var_4,ac] cs) Nothing (FromThen happy_var_1 happy_var_3))- >>= ecpFromExp'- ) `HappyStk` happyRest}}}}--happyReduce_585 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_585 = happySpecReduce_3 212# happyReduction_585-happyReduction_585 happy_x_3- happy_x_2- happy_x_1- = case happyOut224 happy_x_1 of { (HappyWrap224 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut206 happy_x_3 of { (HappyWrap206 happy_var_3) -> - happyIn228- (\loc (ao,ac) ->- unECP happy_var_1 >>= \ happy_var_1 ->- unECP happy_var_3 >>= \ happy_var_3 ->- acsA (\cs -> L loc $ ArithSeq (EpAnn (spanAsAnchor loc) [ao,mj AnnDotdot happy_var_2,ac] cs) Nothing (FromTo happy_var_1 happy_var_3))- >>= ecpFromExp'- )}}}--happyReduce_586 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_586 = happyReduce 5# 212# happyReduction_586-happyReduction_586 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut224 happy_x_1 of { (HappyWrap224 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut206 happy_x_3 of { (HappyWrap206 happy_var_3) -> - case happyOutTok happy_x_4 of { happy_var_4 -> - case happyOut206 happy_x_5 of { (HappyWrap206 happy_var_5) -> - happyIn228- (\loc (ao,ac) ->- unECP happy_var_1 >>= \ happy_var_1 ->- unECP happy_var_3 >>= \ happy_var_3 ->- unECP happy_var_5 >>= \ happy_var_5 ->- acsA (\cs -> L loc $ ArithSeq (EpAnn (spanAsAnchor loc) [ao,mj AnnComma happy_var_2,mj AnnDotdot happy_var_4,ac] cs) Nothing (FromThenTo happy_var_1 happy_var_3 happy_var_5))- >>= ecpFromExp'- ) `HappyStk` happyRest}}}}}--happyReduce_587 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_587 = happySpecReduce_3 212# happyReduction_587-happyReduction_587 happy_x_3- happy_x_2- happy_x_1- = case happyOut224 happy_x_1 of { (HappyWrap224 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut230 happy_x_3 of { (HappyWrap230 happy_var_3) -> - happyIn228- (\loc (ao,ac) ->- checkMonadComp >>= \ ctxt ->- unECP happy_var_1 >>= \ happy_var_1 -> do { t <- addTrailingVbarA happy_var_1 (gl happy_var_2)- ; acsA (\cs -> L loc $ mkHsCompAnns ctxt (unLoc happy_var_3) t (EpAnn (spanAsAnchor loc) (AnnList Nothing (Just ao) (Just ac) [] []) cs))- >>= ecpFromExp' }- )}}}--happyReduce_588 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_588 = happySpecReduce_3 213# happyReduction_588-happyReduction_588 happy_x_3- happy_x_2- happy_x_1- = case happyOut229 happy_x_1 of { (HappyWrap229 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut224 happy_x_3 of { (HappyWrap224 happy_var_3) -> - happyIn229- (happy_var_1 >>= \ happy_var_1 ->- unECP happy_var_3 >>= \ happy_var_3 ->- case happy_var_1 of- (h:t) -> do- h' <- addTrailingCommaA h (gl happy_var_2)- return (((:) $! happy_var_3) $! (h':t))- )}}}--happyReduce_589 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_589 = happySpecReduce_3 213# happyReduction_589-happyReduction_589 happy_x_3- happy_x_2- happy_x_1- = case happyOut224 happy_x_1 of { (HappyWrap224 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut224 happy_x_3 of { (HappyWrap224 happy_var_3) -> - happyIn229- (unECP happy_var_1 >>= \ happy_var_1 ->- unECP happy_var_3 >>= \ happy_var_3 ->- do { h <- addTrailingCommaA happy_var_1 (gl happy_var_2)- ; return [happy_var_3,h] }- )}}}--happyReduce_590 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_590 = happySpecReduce_1 214# happyReduction_590-happyReduction_590 happy_x_1- = case happyOut231 happy_x_1 of { (HappyWrap231 happy_var_1) -> - happyIn230- (case (unLoc happy_var_1) of- [qs] -> sL1 happy_var_1 qs- -- We just had one thing in our "parallel" list so- -- we simply return that thing directly-- qss -> sL1 happy_var_1 [sL1a happy_var_1 $ ParStmt noExtField [ParStmtBlock noExtField qs [] noSyntaxExpr |- qs <- qss]- noExpr noSyntaxExpr]- -- We actually found some actual parallel lists so- -- we wrap them into as a ParStmt- )}--happyReduce_591 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_591 = happyMonadReduce 3# 215# happyReduction_591-happyReduction_591 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut232 happy_x_1 of { (HappyWrap232 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut231 happy_x_3 of { (HappyWrap231 happy_var_3) -> - ( case unLoc happy_var_1 of- (h:t) -> do- h' <- addTrailingVbarA h (gl happy_var_2)- return (sLL happy_var_1 happy_var_3 (reverse (h':t) : unLoc happy_var_3)))}}})- ) (\r -> happyReturn (happyIn231 r))--happyReduce_592 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_592 = happySpecReduce_1 215# happyReduction_592-happyReduction_592 happy_x_1- = case happyOut232 happy_x_1 of { (HappyWrap232 happy_var_1) -> - happyIn231- (L (getLoc happy_var_1) [reverse (unLoc happy_var_1)]- )}--happyReduce_593 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_593 = happyMonadReduce 3# 216# happyReduction_593-happyReduction_593 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut232 happy_x_1 of { (HappyWrap232 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut233 happy_x_3 of { (HappyWrap233 happy_var_3) -> - ( case unLoc happy_var_1 of- (h:t) -> do- h' <- addTrailingCommaA h (gl happy_var_2)- return (sLL happy_var_1 happy_var_3 [sLLa happy_var_1 happy_var_3 ((unLoc happy_var_3) (glRR happy_var_1) (reverse (h':t)))]))}}})- ) (\r -> happyReturn (happyIn232 r))--happyReduce_594 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_594 = happyMonadReduce 3# 216# happyReduction_594-happyReduction_594 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut232 happy_x_1 of { (HappyWrap232 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut254 happy_x_3 of { (HappyWrap254 happy_var_3) -> - ( runPV happy_var_3 >>= \ happy_var_3 ->- case unLoc happy_var_1 of- (h:t) -> do- h' <- addTrailingCommaA h (gl happy_var_2)- return (sLL happy_var_1 (reLoc happy_var_3) (happy_var_3 : (h':t))))}}})- ) (\r -> happyReturn (happyIn232 r))--happyReduce_595 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_595 = happyMonadReduce 1# 216# happyReduction_595-happyReduction_595 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut233 happy_x_1 of { (HappyWrap233 happy_var_1) -> - ( return (sLL happy_var_1 happy_var_1 [L (getLocAnn happy_var_1) ((unLoc happy_var_1) (glRR happy_var_1) [])]))})- ) (\r -> happyReturn (happyIn232 r))--happyReduce_596 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_596 = happyMonadReduce 1# 216# happyReduction_596-happyReduction_596 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut254 happy_x_1 of { (HappyWrap254 happy_var_1) -> - ( runPV happy_var_1 >>= \ happy_var_1 ->- return $ sL1A happy_var_1 [happy_var_1])})- ) (\r -> happyReturn (happyIn232 r))--happyReduce_597 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_597 = happyMonadReduce 2# 217# happyReduction_597-happyReduction_597 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut206 happy_x_2 of { (HappyWrap206 happy_var_2) -> - ( runPV (unECP happy_var_2) >>= \ happy_var_2 ->- acs (\cs->- sLLlA happy_var_1 happy_var_2 (\r ss -> (mkTransformStmt (EpAnn (anc r) [mj AnnThen happy_var_1] cs) ss happy_var_2))))}})- ) (\r -> happyReturn (happyIn233 r))--happyReduce_598 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_598 = happyMonadReduce 4# 217# happyReduction_598-happyReduction_598 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut206 happy_x_2 of { (HappyWrap206 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut206 happy_x_4 of { (HappyWrap206 happy_var_4) -> - ( runPV (unECP happy_var_2) >>= \ happy_var_2 ->- runPV (unECP happy_var_4) >>= \ happy_var_4 ->- acs (\cs -> sLLlA happy_var_1 happy_var_4 (- \r ss -> (mkTransformByStmt (EpAnn (anc r) [mj AnnThen happy_var_1,mj AnnBy happy_var_3] cs) ss happy_var_2 happy_var_4))))}}}})- ) (\r -> happyReturn (happyIn233 r))--happyReduce_599 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_599 = happyMonadReduce 4# 217# happyReduction_599-happyReduction_599 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut206 happy_x_4 of { (HappyWrap206 happy_var_4) -> - ( runPV (unECP happy_var_4) >>= \ happy_var_4 ->- acs (\cs -> sLLlA happy_var_1 happy_var_4 (- \r ss -> (mkGroupUsingStmt (EpAnn (anc r) [mj AnnThen happy_var_1,mj AnnGroup happy_var_2,mj AnnUsing happy_var_3] cs) ss happy_var_4))))}}}})- ) (\r -> happyReturn (happyIn233 r))--happyReduce_600 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_600 = happyMonadReduce 6# 217# happyReduction_600-happyReduction_600 (happy_x_6 `HappyStk`- happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut206 happy_x_4 of { (HappyWrap206 happy_var_4) -> - case happyOutTok happy_x_5 of { happy_var_5 -> - case happyOut206 happy_x_6 of { (HappyWrap206 happy_var_6) -> - ( runPV (unECP happy_var_4) >>= \ happy_var_4 ->- runPV (unECP happy_var_6) >>= \ happy_var_6 ->- acs (\cs -> sLLlA happy_var_1 happy_var_6 (- \r ss -> (mkGroupByUsingStmt (EpAnn (anc r) [mj AnnThen happy_var_1,mj AnnGroup happy_var_2,mj AnnBy happy_var_3,mj AnnUsing happy_var_5] cs) ss happy_var_4 happy_var_6))))}}}}}})- ) (\r -> happyReturn (happyIn233 r))--happyReduce_601 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_601 = happySpecReduce_1 218# happyReduction_601-happyReduction_601 happy_x_1- = case happyOut235 happy_x_1 of { (HappyWrap235 happy_var_1) -> - happyIn234- (L (getLoc happy_var_1) (reverse (unLoc happy_var_1))- )}--happyReduce_602 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_602 = happyMonadReduce 3# 219# happyReduction_602-happyReduction_602 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut235 happy_x_1 of { (HappyWrap235 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut254 happy_x_3 of { (HappyWrap254 happy_var_3) -> - ( runPV happy_var_3 >>= \ happy_var_3 ->- case unLoc happy_var_1 of- (h:t) -> do- h' <- addTrailingCommaA h (gl happy_var_2)- return (sLL happy_var_1 (reLoc happy_var_3) (happy_var_3 : (h':t))))}}})- ) (\r -> happyReturn (happyIn235 r))--happyReduce_603 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_603 = happyMonadReduce 1# 219# happyReduction_603-happyReduction_603 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut254 happy_x_1 of { (HappyWrap254 happy_var_1) -> - ( runPV happy_var_1 >>= \ happy_var_1 ->- return $ sL1A happy_var_1 [happy_var_1])})- ) (\r -> happyReturn (happyIn235 r))--happyReduce_604 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_604 = happySpecReduce_3 220# happyReduction_604-happyReduction_604 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut237 happy_x_2 of { (HappyWrap237 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn236- (happy_var_2 >>= \ happy_var_2 -> amsrl- (sLL happy_var_1 happy_var_3 (reverse (snd $ unLoc happy_var_2)))- (AnnList (Just $ glR happy_var_2) (Just $ moc happy_var_1) (Just $ mcc happy_var_3) (fst $ unLoc happy_var_2) [])- )}}}--happyReduce_605 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_605 = happySpecReduce_3 220# happyReduction_605-happyReduction_605 happy_x_3- happy_x_2- happy_x_1- = case happyOut237 happy_x_2 of { (HappyWrap237 happy_var_2) -> - happyIn236- (happy_var_2 >>= \ happy_var_2 -> amsrl- (L (getLoc happy_var_2) (reverse (snd $ unLoc happy_var_2)))- (AnnList (Just $ glR happy_var_2) Nothing Nothing (fst $ unLoc happy_var_2) [])- )}--happyReduce_606 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_606 = happySpecReduce_2 220# happyReduction_606-happyReduction_606 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - happyIn236- (amsrl (sLL happy_var_1 happy_var_2 []) (AnnList Nothing (Just $ moc happy_var_1) (Just $ mcc happy_var_2) [] [])- )}}--happyReduce_607 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_607 = happySpecReduce_2 220# happyReduction_607-happyReduction_607 happy_x_2- happy_x_1- = happyIn236- (return $ noLocA []- )--happyReduce_608 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_608 = happySpecReduce_1 221# happyReduction_608-happyReduction_608 happy_x_1- = case happyOut238 happy_x_1 of { (HappyWrap238 happy_var_1) -> - happyIn237- (happy_var_1 >>= \ happy_var_1 -> return $- sL1 happy_var_1 (fst $ unLoc happy_var_1,snd $ unLoc happy_var_1)- )}--happyReduce_609 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_609 = happySpecReduce_2 221# happyReduction_609-happyReduction_609 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut237 happy_x_2 of { (HappyWrap237 happy_var_2) -> - happyIn237- (happy_var_2 >>= \ happy_var_2 -> return $- sLL happy_var_1 happy_var_2 (((mz AnnSemi happy_var_1) ++ (fst $ unLoc happy_var_2) )- ,snd $ unLoc happy_var_2)- )}}--happyReduce_610 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_610 = happySpecReduce_3 222# happyReduction_610-happyReduction_610 happy_x_3- happy_x_2- happy_x_1- = case happyOut238 happy_x_1 of { (HappyWrap238 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut239 happy_x_3 of { (HappyWrap239 happy_var_3) -> - happyIn238- (happy_var_1 >>= \ happy_var_1 ->- happy_var_3 >>= \ happy_var_3 ->- case snd $ unLoc happy_var_1 of- [] -> return (sLL happy_var_1 (reLoc happy_var_3) ((fst $ unLoc happy_var_1) ++ (mz AnnSemi happy_var_2)- ,[happy_var_3]))- (h:t) -> do- h' <- addTrailingSemiA h (gl happy_var_2)- return (sLL happy_var_1 (reLoc happy_var_3) (fst $ unLoc happy_var_1,happy_var_3 : h' : t))- )}}}--happyReduce_611 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_611 = happySpecReduce_2 222# happyReduction_611-happyReduction_611 happy_x_2- happy_x_1- = case happyOut238 happy_x_1 of { (HappyWrap238 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - happyIn238- (happy_var_1 >>= \ happy_var_1 ->- case snd $ unLoc happy_var_1 of- [] -> return (sLL happy_var_1 happy_var_2 ((fst $ unLoc happy_var_1) ++ (mz AnnSemi happy_var_2)- ,[]))- (h:t) -> do- h' <- addTrailingSemiA h (gl happy_var_2)- return (sLL happy_var_1 happy_var_2 (fst $ unLoc happy_var_1, h' : t))- )}}--happyReduce_612 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_612 = happySpecReduce_1 222# happyReduction_612-happyReduction_612 happy_x_1- = case happyOut239 happy_x_1 of { (HappyWrap239 happy_var_1) -> - happyIn238- (happy_var_1 >>= \ happy_var_1 -> return $ sL1 (reLoc happy_var_1) ([],[happy_var_1])- )}--happyReduce_613 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_613 = happySpecReduce_2 223# happyReduction_613-happyReduction_613 happy_x_2- happy_x_1- = case happyOut245 happy_x_1 of { (HappyWrap245 happy_var_1) -> - case happyOut240 happy_x_2 of { (HappyWrap240 happy_var_2) -> - happyIn239- (happy_var_2 >>= \ happy_var_2 ->- acsA (\cs -> sLL (reLoc happy_var_1) happy_var_2- (Match { m_ext = (EpAnn (glAR happy_var_1) [] cs)- , m_ctxt = CaseAlt- , m_pats = [happy_var_1]- , m_grhss = unLoc happy_var_2 }))- )}}--happyReduce_614 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_614 = happySpecReduce_2 224# happyReduction_614-happyReduction_614 happy_x_2- happy_x_1- = case happyOut241 happy_x_1 of { (HappyWrap241 happy_var_1) -> - case happyOut130 happy_x_2 of { (HappyWrap130 happy_var_2) -> - happyIn240- (happy_var_1 >>= \alt ->- do { let {L l (bs, csw) = adaptWhereBinds happy_var_2}- ; acs (\cs -> sLL alt (L l bs) (GRHSs (cs Semi.<> csw) (unLoc alt) bs)) }- )}}--happyReduce_615 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_615 = happySpecReduce_2 225# happyReduction_615-happyReduction_615 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut206 happy_x_2 of { (HappyWrap206 happy_var_2) -> - happyIn241- (unECP happy_var_2 >>= \ happy_var_2 ->- acs (\cs -> sLLlA happy_var_1 happy_var_2 (unguardedRHS (EpAnn (glR happy_var_1) (GrhsAnn Nothing (mu AnnRarrow happy_var_1)) cs) (comb2 happy_var_1 (reLoc happy_var_2)) happy_var_2))- )}}--happyReduce_616 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_616 = happySpecReduce_1 225# happyReduction_616-happyReduction_616 happy_x_1- = case happyOut242 happy_x_1 of { (HappyWrap242 happy_var_1) -> - happyIn241- (happy_var_1 >>= \gdpats ->- return $ sL1 gdpats (reverse (unLoc gdpats))- )}--happyReduce_617 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_617 = happySpecReduce_2 226# happyReduction_617-happyReduction_617 happy_x_2- happy_x_1- = case happyOut242 happy_x_1 of { (HappyWrap242 happy_var_1) -> - case happyOut244 happy_x_2 of { (HappyWrap244 happy_var_2) -> - happyIn242- (happy_var_1 >>= \gdpats ->- happy_var_2 >>= \gdpat ->- return $ sLL gdpats gdpat (gdpat : unLoc gdpats)- )}}--happyReduce_618 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_618 = happySpecReduce_1 226# happyReduction_618-happyReduction_618 happy_x_1- = case happyOut244 happy_x_1 of { (HappyWrap244 happy_var_1) -> - happyIn242- (happy_var_1 >>= \gdpat -> return $ sL1 gdpat [gdpat]- )}--happyReduce_619 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_619 = happyMonadReduce 3# 227# happyReduction_619-happyReduction_619 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut242 happy_x_2 of { (HappyWrap242 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( runPV happy_var_2 >>= \ happy_var_2 ->- return $ sLL happy_var_1 happy_var_3 ([moc happy_var_1,mcc happy_var_3],unLoc happy_var_2))}}})- ) (\r -> happyReturn (happyIn243 r))--happyReduce_620 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_620 = happyMonadReduce 2# 227# happyReduction_620-happyReduction_620 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut242 happy_x_1 of { (HappyWrap242 happy_var_1) -> - ( runPV happy_var_1 >>= \ happy_var_1 ->- return $ sL1 happy_var_1 ([],unLoc happy_var_1))})- ) (\r -> happyReturn (happyIn243 r))--happyReduce_621 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_621 = happyReduce 4# 228# happyReduction_621-happyReduction_621 (happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut234 happy_x_2 of { (HappyWrap234 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - case happyOut206 happy_x_4 of { (HappyWrap206 happy_var_4) -> - happyIn244- (unECP happy_var_4 >>= \ happy_var_4 ->- acs (\cs -> sL (comb2A happy_var_1 happy_var_4) $ GRHS (EpAnn (glR happy_var_1) (GrhsAnn (Just $ glAA happy_var_1) (mu AnnRarrow happy_var_3)) cs) (unLoc happy_var_2) happy_var_4)- ) `HappyStk` happyRest}}}}--happyReduce_622 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_622 = happyMonadReduce 1# 229# happyReduction_622-happyReduction_622 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut206 happy_x_1 of { (HappyWrap206 happy_var_1) -> - ( (checkPattern <=< runPV) (unECP happy_var_1))})- ) (\r -> happyReturn (happyIn245 r))--happyReduce_623 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_623 = happyMonadReduce 1# 230# happyReduction_623-happyReduction_623 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut206 happy_x_1 of { (HappyWrap206 happy_var_1) -> - ( -- See Note [Parser-Validator Hint] in GHC.Parser.PostProcess- checkPattern_hints [SuggestMissingDo]- (unECP happy_var_1))})- ) (\r -> happyReturn (happyIn246 r))--happyReduce_624 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_624 = happyMonadReduce 1# 231# happyReduction_624-happyReduction_624 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut213 happy_x_1 of { (HappyWrap213 happy_var_1) -> - ( (checkPattern <=< runPV) (unECP happy_var_1))})- ) (\r -> happyReturn (happyIn247 r))--happyReduce_625 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_625 = happySpecReduce_2 232# happyReduction_625-happyReduction_625 happy_x_2- happy_x_1- = case happyOut247 happy_x_1 of { (HappyWrap247 happy_var_1) -> - case happyOut248 happy_x_2 of { (HappyWrap248 happy_var_2) -> - happyIn248- (happy_var_1 : happy_var_2- )}}--happyReduce_626 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_626 = happySpecReduce_0 232# happyReduction_626-happyReduction_626 = happyIn248- ([]- )--happyReduce_627 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_627 = happySpecReduce_3 233# happyReduction_627-happyReduction_627 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut250 happy_x_2 of { (HappyWrap250 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn249- (happy_var_2 >>= \ happy_var_2 -> amsrl- (sLL happy_var_1 happy_var_3 (reverse $ snd $ unLoc happy_var_2)) (AnnList (Just $ glR happy_var_2) (Just $ moc happy_var_1) (Just $ mcc happy_var_3) (fromOL $ fst $ unLoc happy_var_2) [])- )}}}--happyReduce_628 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_628 = happySpecReduce_3 233# happyReduction_628-happyReduction_628 happy_x_3- happy_x_2- happy_x_1- = case happyOut250 happy_x_2 of { (HappyWrap250 happy_var_2) -> - happyIn249- (happy_var_2 >>= \ happy_var_2 -> amsrl- (L (gl happy_var_2) (reverse $ snd $ unLoc happy_var_2)) (AnnList (Just $ glR happy_var_2) Nothing Nothing (fromOL $ fst $ unLoc happy_var_2) [])- )}--happyReduce_629 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_629 = happySpecReduce_3 234# happyReduction_629-happyReduction_629 happy_x_3- happy_x_2- happy_x_1- = case happyOut250 happy_x_1 of { (HappyWrap250 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut253 happy_x_3 of { (HappyWrap253 happy_var_3) -> - happyIn250- (happy_var_1 >>= \ happy_var_1 ->- happy_var_3 >>= \ (happy_var_3 :: LStmt GhcPs (LocatedA b)) ->- case (snd $ unLoc happy_var_1) of- [] -> return (sLL happy_var_1 (reLoc happy_var_3) ((fst $ unLoc happy_var_1) `snocOL` (mj AnnSemi happy_var_2)- ,happy_var_3 : (snd $ unLoc happy_var_1)))- (h:t) -> do- { h' <- addTrailingSemiA h (gl happy_var_2)- ; return $ sLL happy_var_1 (reLoc happy_var_3) (fst $ unLoc happy_var_1,happy_var_3 :(h':t)) }- )}}}--happyReduce_630 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_630 = happySpecReduce_2 234# happyReduction_630-happyReduction_630 happy_x_2- happy_x_1- = case happyOut250 happy_x_1 of { (HappyWrap250 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - happyIn250- (happy_var_1 >>= \ happy_var_1 ->- case (snd $ unLoc happy_var_1) of- [] -> return (sLL happy_var_1 happy_var_2 ((fst $ unLoc happy_var_1) `snocOL` (mj AnnSemi happy_var_2),snd $ unLoc happy_var_1))- (h:t) -> do- { h' <- addTrailingSemiA h (gl happy_var_2)- ; return $ sL1 happy_var_1 (fst $ unLoc happy_var_1,h':t) }- )}}--happyReduce_631 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_631 = happySpecReduce_1 234# happyReduction_631-happyReduction_631 happy_x_1- = case happyOut253 happy_x_1 of { (HappyWrap253 happy_var_1) -> - happyIn250- (happy_var_1 >>= \ happy_var_1 ->- return $ sL1A happy_var_1 (nilOL,[happy_var_1])- )}--happyReduce_632 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_632 = happySpecReduce_0 234# happyReduction_632-happyReduction_632 = happyIn250- (return $ noLoc (nilOL,[])- )--happyReduce_633 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_633 = happyMonadReduce 1# 235# happyReduction_633-happyReduction_633 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut253 happy_x_1 of { (HappyWrap253 happy_var_1) -> - ( fmap Just (runPV happy_var_1))})- ) (\r -> happyReturn (happyIn251 r))--happyReduce_634 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_634 = happySpecReduce_0 235# happyReduction_634-happyReduction_634 = happyIn251- (Nothing- )--happyReduce_635 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_635 = happyMonadReduce 1# 236# happyReduction_635-happyReduction_635 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut253 happy_x_1 of { (HappyWrap253 happy_var_1) -> - ( runPV happy_var_1)})- ) (\r -> happyReturn (happyIn252 r))--happyReduce_636 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_636 = happySpecReduce_1 237# happyReduction_636-happyReduction_636 happy_x_1- = case happyOut254 happy_x_1 of { (HappyWrap254 happy_var_1) -> - happyIn253- (happy_var_1- )}--happyReduce_637 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_637 = happySpecReduce_2 237# happyReduction_637-happyReduction_637 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut249 happy_x_2 of { (HappyWrap249 happy_var_2) -> - happyIn253- (happy_var_2 >>= \ happy_var_2 ->- acsA (\cs -> (sLL happy_var_1 (reLoc happy_var_2) $ mkRecStmt- (EpAnn (glR happy_var_1) (hsDoAnn happy_var_1 happy_var_2 AnnRec) cs)- happy_var_2))- )}}--happyReduce_638 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_638 = happySpecReduce_3 238# happyReduction_638-happyReduction_638 happy_x_3- happy_x_2- happy_x_1- = case happyOut246 happy_x_1 of { (HappyWrap246 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut206 happy_x_3 of { (HappyWrap206 happy_var_3) -> - happyIn254- (unECP happy_var_3 >>= \ happy_var_3 ->- acsA (\cs -> sLLlA (reLoc happy_var_1) happy_var_3- $ mkPsBindStmt (EpAnn (glAR happy_var_1) [mu AnnLarrow happy_var_2] cs) happy_var_1 happy_var_3)- )}}}--happyReduce_639 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_639 = happySpecReduce_1 238# happyReduction_639-happyReduction_639 happy_x_1- = case happyOut206 happy_x_1 of { (HappyWrap206 happy_var_1) -> - happyIn254- (unECP happy_var_1 >>= \ happy_var_1 ->- return $ sL1 happy_var_1 $ mkBodyStmt happy_var_1- )}--happyReduce_640 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_640 = happySpecReduce_2 238# happyReduction_640-happyReduction_640 happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut129 happy_x_2 of { (HappyWrap129 happy_var_2) -> - happyIn254- (acsA (\cs -> (sLL happy_var_1 happy_var_2- $ mkLetStmt (EpAnn (glR happy_var_1) [mj AnnLet happy_var_1] cs) (unLoc happy_var_2)))- )}}--happyReduce_641 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_641 = happySpecReduce_1 239# happyReduction_641-happyReduction_641 happy_x_1- = case happyOut256 happy_x_1 of { (HappyWrap256 happy_var_1) -> - happyIn255- (happy_var_1- )}--happyReduce_642 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_642 = happySpecReduce_0 239# happyReduction_642-happyReduction_642 = happyIn255- (return ([], Nothing)- )--happyReduce_643 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_643 = happySpecReduce_3 240# happyReduction_643-happyReduction_643 happy_x_3- happy_x_2- happy_x_1- = case happyOut257 happy_x_1 of { (HappyWrap257 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut256 happy_x_3 of { (HappyWrap256 happy_var_3) -> - happyIn256- (happy_var_1 >>= \ happy_var_1 ->- happy_var_3 >>= \ happy_var_3 -> do- h <- addTrailingCommaFBind happy_var_1 (gl happy_var_2)- return (case happy_var_3 of (flds, dd) -> (h : flds, dd))- )}}}--happyReduce_644 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_644 = happySpecReduce_1 240# happyReduction_644-happyReduction_644 happy_x_1- = case happyOut257 happy_x_1 of { (HappyWrap257 happy_var_1) -> - happyIn256- (happy_var_1 >>= \ happy_var_1 ->- return ([happy_var_1], Nothing)- )}--happyReduce_645 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_645 = happySpecReduce_1 240# happyReduction_645-happyReduction_645 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn256- (return ([], Just (getLoc happy_var_1))- )}--happyReduce_646 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_646 = happySpecReduce_3 241# happyReduction_646-happyReduction_646 happy_x_3- happy_x_2- happy_x_1- = case happyOut300 happy_x_1 of { (HappyWrap300 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut224 happy_x_3 of { (HappyWrap224 happy_var_3) -> - happyIn257- (unECP happy_var_3 >>= \ happy_var_3 ->- fmap Left $ acsA (\cs -> sLL (reLocN happy_var_1) (reLoc happy_var_3) $ HsRecField (EpAnn (glNR happy_var_1) [mj AnnEqual happy_var_2] cs) (sL1N happy_var_1 $ mkFieldOcc happy_var_1) happy_var_3 False)- )}}}--happyReduce_647 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_647 = happySpecReduce_1 241# happyReduction_647-happyReduction_647 happy_x_1- = case happyOut300 happy_x_1 of { (HappyWrap300 happy_var_1) -> - happyIn257- (placeHolderPunRhs >>= \rhs ->- fmap Left $ acsa (\cs -> sL1a (reLocN happy_var_1) $ HsRecField (EpAnn (glNR happy_var_1) [] cs) (sL1N happy_var_1 $ mkFieldOcc happy_var_1) rhs True)- )}--happyReduce_648 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_648 = happyReduce 5# 241# happyReduction_648-happyReduction_648 (happy_x_5 `HappyStk`- happy_x_4 `HappyStk`- happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest)- = case happyOut301 happy_x_1 of { (HappyWrap301 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut258 happy_x_3 of { (HappyWrap258 happy_var_3) -> - case happyOutTok happy_x_4 of { happy_var_4 -> - case happyOut224 happy_x_5 of { (HappyWrap224 happy_var_5) -> - happyIn257- (do- let top = sL1 happy_var_1 $ HsFieldLabel noAnn happy_var_1- ((L lf (HsFieldLabel _ f)):t) = reverse (unLoc happy_var_3)- lf' = comb2 happy_var_2 (L lf ())- fields = top : L lf' (HsFieldLabel (EpAnn (spanAsAnchor lf') (AnnFieldLabel (Just $ glAA happy_var_2)) emptyComments) f) : t- final = last fields- l = comb2 happy_var_1 happy_var_3- isPun = False- happy_var_5 <- unECP happy_var_5- fmap Right $ mkHsProjUpdatePV (comb2 happy_var_1 (reLoc happy_var_5)) (L l fields) happy_var_5 isPun- [mj AnnEqual happy_var_4]- ) `HappyStk` happyRest}}}}}--happyReduce_649 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_649 = happySpecReduce_3 241# happyReduction_649-happyReduction_649 happy_x_3- happy_x_2- happy_x_1- = case happyOut301 happy_x_1 of { (HappyWrap301 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut258 happy_x_3 of { (HappyWrap258 happy_var_3) -> - happyIn257- (do- let top = sL1 happy_var_1 $ HsFieldLabel noAnn happy_var_1- ((L lf (HsFieldLabel _ f)):t) = reverse (unLoc happy_var_3)- lf' = comb2 happy_var_2 (L lf ())- fields = top : L lf' (HsFieldLabel (EpAnn (spanAsAnchor lf') (AnnFieldLabel (Just $ glAA happy_var_2)) emptyComments) f) : t- final = last fields- l = comb2 happy_var_1 happy_var_3- isPun = True- var <- mkHsVarPV (L (noAnnSrcSpan $ getLoc final) (mkRdrUnqual . mkVarOcc . unpackFS . unLoc . hflLabel . unLoc $ final))- fmap Right $ mkHsProjUpdatePV l (L l fields) var isPun []- )}}}--happyReduce_650 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_650 = happyMonadReduce 3# 242# happyReduction_650-happyReduction_650 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut258 happy_x_1 of { (HappyWrap258 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut301 happy_x_3 of { (HappyWrap301 happy_var_3) -> - ( getCommentsFor (getLoc happy_var_3) >>= \cs ->- return (sLL happy_var_1 happy_var_3 ((sLL happy_var_2 happy_var_3 (HsFieldLabel (EpAnn (glR happy_var_2) (AnnFieldLabel $ Just $ glAA happy_var_2) cs) happy_var_3)) : unLoc happy_var_1)))}}})- ) (\r -> happyReturn (happyIn258 r))--happyReduce_651 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_651 = happyMonadReduce 1# 242# happyReduction_651-happyReduction_651 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut301 happy_x_1 of { (HappyWrap301 happy_var_1) -> - ( getCommentsFor (getLoc happy_var_1) >>= \cs ->- return (sL1 happy_var_1 [sL1 happy_var_1 (HsFieldLabel (EpAnn (glR happy_var_1) (AnnFieldLabel Nothing) cs) happy_var_1)]))})- ) (\r -> happyReturn (happyIn258 r))--happyReduce_652 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_652 = happyMonadReduce 3# 243# happyReduction_652-happyReduction_652 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut259 happy_x_1 of { (HappyWrap259 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut260 happy_x_3 of { (HappyWrap260 happy_var_3) -> - ( case unLoc happy_var_1 of- (h:t) -> do- h' <- addTrailingSemiA h (gl happy_var_2)- return (let { this = happy_var_3; rest = h':t }- in rest `seq` this `seq` sLL happy_var_1 (reLoc happy_var_3) (this : rest)))}}})- ) (\r -> happyReturn (happyIn259 r))--happyReduce_653 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_653 = happyMonadReduce 2# 243# happyReduction_653-happyReduction_653 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut259 happy_x_1 of { (HappyWrap259 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( case unLoc happy_var_1 of- (h:t) -> do- h' <- addTrailingSemiA h (gl happy_var_2)- return (sLL happy_var_1 happy_var_2 (h':t)))}})- ) (\r -> happyReturn (happyIn259 r))--happyReduce_654 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_654 = happySpecReduce_1 243# happyReduction_654-happyReduction_654 happy_x_1- = case happyOut260 happy_x_1 of { (HappyWrap260 happy_var_1) -> - happyIn259- (let this = happy_var_1 in this `seq` (sL1 (reLoc happy_var_1) [this])- )}--happyReduce_655 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_655 = happyMonadReduce 3# 244# happyReduction_655-happyReduction_655 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut261 happy_x_1 of { (HappyWrap261 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut206 happy_x_3 of { (HappyWrap206 happy_var_3) -> - ( runPV (unECP happy_var_3) >>= \ happy_var_3 ->- acsA (\cs -> sLLlA happy_var_1 happy_var_3 (IPBind (EpAnn (glR happy_var_1) [mj AnnEqual happy_var_2] cs) (Left happy_var_1) happy_var_3)))}}})- ) (\r -> happyReturn (happyIn260 r))--happyReduce_656 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_656 = happySpecReduce_1 245# happyReduction_656-happyReduction_656 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn261- (sL1 happy_var_1 (HsIPName (getIPDUPVARID happy_var_1))- )}--happyReduce_657 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_657 = happySpecReduce_1 246# happyReduction_657-happyReduction_657 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn262- (sL1 happy_var_1 (getLABELVARID happy_var_1)- )}--happyReduce_658 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_658 = happySpecReduce_1 247# happyReduction_658-happyReduction_658 happy_x_1- = case happyOut264 happy_x_1 of { (HappyWrap264 happy_var_1) -> - happyIn263- (happy_var_1- )}--happyReduce_659 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_659 = happySpecReduce_0 247# happyReduction_659-happyReduction_659 = happyIn263- (noLocA mkTrue- )--happyReduce_660 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_660 = happySpecReduce_1 248# happyReduction_660-happyReduction_660 happy_x_1- = case happyOut265 happy_x_1 of { (HappyWrap265 happy_var_1) -> - happyIn264- (happy_var_1- )}--happyReduce_661 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_661 = happyMonadReduce 3# 248# happyReduction_661-happyReduction_661 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut265 happy_x_1 of { (HappyWrap265 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut264 happy_x_3 of { (HappyWrap264 happy_var_3) -> - ( do { h <- addTrailingVbarL happy_var_1 (gl happy_var_2)- ; return (reLocA $ sLLAA happy_var_1 happy_var_3 (Or [h,happy_var_3])) })}}})- ) (\r -> happyReturn (happyIn264 r))--happyReduce_662 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_662 = happySpecReduce_1 249# happyReduction_662-happyReduction_662 happy_x_1- = case happyOut266 happy_x_1 of { (HappyWrap266 happy_var_1) -> - happyIn265- (reLocA $ sLLAA (head happy_var_1) (last happy_var_1) (And (happy_var_1))- )}--happyReduce_663 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_663 = happySpecReduce_1 250# happyReduction_663-happyReduction_663 happy_x_1- = case happyOut267 happy_x_1 of { (HappyWrap267 happy_var_1) -> - happyIn266- ([happy_var_1]- )}--happyReduce_664 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_664 = happyMonadReduce 3# 250# happyReduction_664-happyReduction_664 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut267 happy_x_1 of { (HappyWrap267 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut266 happy_x_3 of { (HappyWrap266 happy_var_3) -> - ( do { h <- addTrailingCommaL happy_var_1 (gl happy_var_2)- ; return (h : happy_var_3) })}}})- ) (\r -> happyReturn (happyIn266 r))--happyReduce_665 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_665 = happyMonadReduce 3# 251# happyReduction_665-happyReduction_665 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut264 happy_x_2 of { (HappyWrap264 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( amsrl (sLL happy_var_1 happy_var_3 (Parens happy_var_2))- (AnnList Nothing (Just (mop happy_var_1)) (Just (mcp happy_var_3)) [] []))}}})- ) (\r -> happyReturn (happyIn267 r))--happyReduce_666 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_666 = happySpecReduce_1 251# happyReduction_666-happyReduction_666 happy_x_1- = case happyOut269 happy_x_1 of { (HappyWrap269 happy_var_1) -> - happyIn267- (reLocA $ sL1N happy_var_1 (Var happy_var_1)- )}--happyReduce_667 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_667 = happySpecReduce_1 252# happyReduction_667-happyReduction_667 happy_x_1- = case happyOut269 happy_x_1 of { (HappyWrap269 happy_var_1) -> - happyIn268- (sL1N happy_var_1 [happy_var_1]- )}--happyReduce_668 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_668 = happyMonadReduce 3# 252# happyReduction_668-happyReduction_668 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut269 happy_x_1 of { (HappyWrap269 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut268 happy_x_3 of { (HappyWrap268 happy_var_3) -> - ( do { h <- addTrailingCommaN happy_var_1 (gl happy_var_2)- ; return (sLL (reLocN happy_var_1) happy_var_3 (h : unLoc happy_var_3)) })}}})- ) (\r -> happyReturn (happyIn268 r))--happyReduce_669 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_669 = happySpecReduce_1 253# happyReduction_669-happyReduction_669 happy_x_1- = case happyOut299 happy_x_1 of { (HappyWrap299 happy_var_1) -> - happyIn269- (happy_var_1- )}--happyReduce_670 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_670 = happySpecReduce_1 253# happyReduction_670-happyReduction_670 happy_x_1- = case happyOut273 happy_x_1 of { (HappyWrap273 happy_var_1) -> - happyIn269- (happy_var_1- )}--happyReduce_671 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_671 = happySpecReduce_1 254# happyReduction_671-happyReduction_671 happy_x_1- = case happyOut272 happy_x_1 of { (HappyWrap272 happy_var_1) -> - happyIn270- (happy_var_1- )}--happyReduce_672 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_672 = happySpecReduce_1 254# happyReduction_672-happyReduction_672 happy_x_1- = case happyOut275 happy_x_1 of { (HappyWrap275 happy_var_1) -> - happyIn270- (L (getLoc happy_var_1) $ nameRdrName (dataConName (unLoc happy_var_1))- )}--happyReduce_673 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_673 = happySpecReduce_1 255# happyReduction_673-happyReduction_673 happy_x_1- = case happyOut272 happy_x_1 of { (HappyWrap272 happy_var_1) -> - happyIn271- (happy_var_1- )}--happyReduce_674 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_674 = happySpecReduce_1 255# happyReduction_674-happyReduction_674 happy_x_1- = case happyOut276 happy_x_1 of { (HappyWrap276 happy_var_1) -> - happyIn271- (L (getLoc happy_var_1) $ nameRdrName (dataConName (unLoc happy_var_1))- )}--happyReduce_675 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_675 = happySpecReduce_1 256# happyReduction_675-happyReduction_675 happy_x_1- = case happyOut311 happy_x_1 of { (HappyWrap311 happy_var_1) -> - happyIn272- (happy_var_1- )}--happyReduce_676 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_676 = happyMonadReduce 3# 256# happyReduction_676-happyReduction_676 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut313 happy_x_2 of { (HappyWrap313 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( amsrn (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))- (NameAnn NameParens (glAA happy_var_1) (glNRR happy_var_2) (glAA happy_var_3) []))}}})- ) (\r -> happyReturn (happyIn272 r))--happyReduce_677 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_677 = happySpecReduce_1 257# happyReduction_677-happyReduction_677 happy_x_1- = case happyOut312 happy_x_1 of { (HappyWrap312 happy_var_1) -> - happyIn273- (happy_var_1- )}--happyReduce_678 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_678 = happyMonadReduce 3# 257# happyReduction_678-happyReduction_678 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut314 happy_x_2 of { (HappyWrap314 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( amsrn (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))- (NameAnn NameParens (glAA happy_var_1) (glNRR happy_var_2) (glAA happy_var_3) []))}}})- ) (\r -> happyReturn (happyIn273 r))--happyReduce_679 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_679 = happySpecReduce_1 257# happyReduction_679-happyReduction_679 happy_x_1- = case happyOut276 happy_x_1 of { (HappyWrap276 happy_var_1) -> - happyIn273- (L (getLoc happy_var_1) $ nameRdrName (dataConName (unLoc happy_var_1))- )}--happyReduce_680 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_680 = happySpecReduce_1 258# happyReduction_680-happyReduction_680 happy_x_1- = case happyOut273 happy_x_1 of { (HappyWrap273 happy_var_1) -> - happyIn274- (sL1N happy_var_1 [happy_var_1]- )}--happyReduce_681 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_681 = happyMonadReduce 3# 258# happyReduction_681-happyReduction_681 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut273 happy_x_1 of { (HappyWrap273 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOut274 happy_x_3 of { (HappyWrap274 happy_var_3) -> - ( do { h <- addTrailingCommaN happy_var_1 (gl happy_var_2)- ; return (sLL (reLocN happy_var_1) happy_var_3 (h : unLoc happy_var_3)) })}}})- ) (\r -> happyReturn (happyIn274 r))--happyReduce_682 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_682 = happyMonadReduce 2# 259# happyReduction_682-happyReduction_682 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( amsrn (sLL happy_var_1 happy_var_2 unitDataCon) (NameAnnOnly NameParens (glAA happy_var_1) (glAA happy_var_2) []))}})- ) (\r -> happyReturn (happyIn275 r))--happyReduce_683 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_683 = happyMonadReduce 3# 259# happyReduction_683-happyReduction_683 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut318 happy_x_2 of { (HappyWrap318 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( amsrn (sLL happy_var_1 happy_var_3 $ tupleDataCon Boxed (snd happy_var_2 + 1))- (NameAnnCommas NameParens (glAA happy_var_1) (map (EpaSpan . realSrcSpan) (fst happy_var_2)) (glAA happy_var_3) []))}}})- ) (\r -> happyReturn (happyIn275 r))--happyReduce_684 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_684 = happyMonadReduce 2# 259# happyReduction_684-happyReduction_684 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( amsrn (sLL happy_var_1 happy_var_2 $ unboxedUnitDataCon) (NameAnnOnly NameParensHash (glAA happy_var_1) (glAA happy_var_2) []))}})- ) (\r -> happyReturn (happyIn275 r))--happyReduce_685 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_685 = happyMonadReduce 3# 259# happyReduction_685-happyReduction_685 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut318 happy_x_2 of { (HappyWrap318 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( amsrn (sLL happy_var_1 happy_var_3 $ tupleDataCon Unboxed (snd happy_var_2 + 1))- (NameAnnCommas NameParensHash (glAA happy_var_1) (map (EpaSpan . realSrcSpan) (fst happy_var_2)) (glAA happy_var_3) []))}}})- ) (\r -> happyReturn (happyIn275 r))--happyReduce_686 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_686 = happySpecReduce_1 260# happyReduction_686-happyReduction_686 happy_x_1- = case happyOut275 happy_x_1 of { (HappyWrap275 happy_var_1) -> - happyIn276- (happy_var_1- )}--happyReduce_687 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_687 = happyMonadReduce 2# 260# happyReduction_687-happyReduction_687 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( amsrn (sLL happy_var_1 happy_var_2 nilDataCon) (NameAnnOnly NameSquare (glAA happy_var_1) (glAA happy_var_2) []))}})- ) (\r -> happyReturn (happyIn276 r))--happyReduce_688 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_688 = happySpecReduce_1 261# happyReduction_688-happyReduction_688 happy_x_1- = case happyOut314 happy_x_1 of { (HappyWrap314 happy_var_1) -> - happyIn277- (happy_var_1- )}--happyReduce_689 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_689 = happyMonadReduce 3# 261# happyReduction_689-happyReduction_689 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut312 happy_x_2 of { (HappyWrap312 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( amsrn (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))- (NameAnn NameBackquotes (glAA happy_var_1) (glNRR happy_var_2) (glAA happy_var_3) []))}}})- ) (\r -> happyReturn (happyIn277 r))--happyReduce_690 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_690 = happySpecReduce_1 262# happyReduction_690-happyReduction_690 happy_x_1- = case happyOut313 happy_x_1 of { (HappyWrap313 happy_var_1) -> - happyIn278- (happy_var_1- )}--happyReduce_691 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_691 = happyMonadReduce 3# 262# happyReduction_691-happyReduction_691 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut311 happy_x_2 of { (HappyWrap311 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( amsrn (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))- (NameAnn NameBackquotes (glAA happy_var_1) (glNRR happy_var_2) (glAA happy_var_3) []))}}})- ) (\r -> happyReturn (happyIn278 r))--happyReduce_692 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_692 = happySpecReduce_1 263# happyReduction_692-happyReduction_692 happy_x_1- = case happyOut280 happy_x_1 of { (HappyWrap280 happy_var_1) -> - happyIn279- (happy_var_1- )}--happyReduce_693 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_693 = happyMonadReduce 2# 263# happyReduction_693-happyReduction_693 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( amsrn (sLL happy_var_1 happy_var_2 $ getRdrName unitTyCon)- (NameAnnOnly NameParens (glAA happy_var_1) (glAA happy_var_2) []))}})- ) (\r -> happyReturn (happyIn279 r))--happyReduce_694 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_694 = happyMonadReduce 2# 263# happyReduction_694-happyReduction_694 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( amsrn (sLL happy_var_1 happy_var_2 $ getRdrName unboxedUnitTyCon)- (NameAnnOnly NameParensHash (glAA happy_var_1) (glAA happy_var_2) []))}})- ) (\r -> happyReturn (happyIn279 r))--happyReduce_695 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_695 = happySpecReduce_1 264# happyReduction_695-happyReduction_695 happy_x_1- = case happyOut281 happy_x_1 of { (HappyWrap281 happy_var_1) -> - happyIn280- (happy_var_1- )}--happyReduce_696 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_696 = happyMonadReduce 3# 264# happyReduction_696-happyReduction_696 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut318 happy_x_2 of { (HappyWrap318 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( amsrn (sLL happy_var_1 happy_var_3 $ getRdrName (tupleTyCon Boxed- (snd happy_var_2 + 1)))- (NameAnnCommas NameParens (glAA happy_var_1) (map (EpaSpan . realSrcSpan) (fst happy_var_2)) (glAA happy_var_3) []))}}})- ) (\r -> happyReturn (happyIn280 r))--happyReduce_697 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_697 = happyMonadReduce 3# 264# happyReduction_697-happyReduction_697 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut318 happy_x_2 of { (HappyWrap318 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( amsrn (sLL happy_var_1 happy_var_3 $ getRdrName (tupleTyCon Unboxed- (snd happy_var_2 + 1)))- (NameAnnCommas NameParensHash (glAA happy_var_1) (map (EpaSpan . realSrcSpan) (fst happy_var_2)) (glAA happy_var_3) []))}}})- ) (\r -> happyReturn (happyIn280 r))--happyReduce_698 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_698 = happyMonadReduce 3# 264# happyReduction_698-happyReduction_698 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( amsrn (sLL happy_var_1 happy_var_3 $ getRdrName unrestrictedFunTyCon)- (NameAnn NameParens (glAA happy_var_1) (glAA happy_var_2) (glAA happy_var_3) []))}}})- ) (\r -> happyReturn (happyIn280 r))--happyReduce_699 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_699 = happyMonadReduce 2# 264# happyReduction_699-happyReduction_699 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - ( amsrn (sLL happy_var_1 happy_var_2 $ listTyCon_RDR)- (NameAnnOnly NameSquare (glAA happy_var_1) (glAA happy_var_2) []))}})- ) (\r -> happyReturn (happyIn280 r))--happyReduce_700 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_700 = happySpecReduce_1 265# happyReduction_700-happyReduction_700 happy_x_1- = case happyOut284 happy_x_1 of { (HappyWrap284 happy_var_1) -> - happyIn281- (happy_var_1- )}--happyReduce_701 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_701 = happyMonadReduce 3# 265# happyReduction_701-happyReduction_701 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut286 happy_x_2 of { (HappyWrap286 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( amsrn (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))- (NameAnn NameParens (glAA happy_var_1) (glNRR happy_var_2) (glAA happy_var_3) []))}}})- ) (\r -> happyReturn (happyIn281 r))--happyReduce_702 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_702 = happySpecReduce_1 266# happyReduction_702-happyReduction_702 happy_x_1- = case happyOut284 happy_x_1 of { (HappyWrap284 happy_var_1) -> - happyIn282- (happy_var_1- )}--happyReduce_703 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_703 = happyMonadReduce 3# 266# happyReduction_703-happyReduction_703 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( let { name :: Located RdrName- ; name = sL1 happy_var_2 $! mkQual tcClsName (getQCONSYM happy_var_2) }- in amsrn (sLL happy_var_1 happy_var_3 (unLoc name)) (NameAnn NameParens (glAA happy_var_1) (glAA happy_var_2) (glAA happy_var_3) []))}}})- ) (\r -> happyReturn (happyIn282 r))--happyReduce_704 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_704 = happyMonadReduce 3# 266# happyReduction_704-happyReduction_704 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( let { name :: Located RdrName- ; name = sL1 happy_var_2 $! mkUnqual tcClsName (getCONSYM happy_var_2) }- in amsrn (sLL happy_var_1 happy_var_3 (unLoc name)) (NameAnn NameParens (glAA happy_var_1) (glAA happy_var_2) (glAA happy_var_3) []))}}})- ) (\r -> happyReturn (happyIn282 r))--happyReduce_705 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_705 = happyMonadReduce 3# 266# happyReduction_705-happyReduction_705 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( let { name :: Located RdrName- ; name = sL1 happy_var_2 $! consDataCon_RDR }- in amsrn (sLL happy_var_1 happy_var_3 (unLoc name)) (NameAnn NameParens (glAA happy_var_1) (glAA happy_var_2) (glAA happy_var_3) []))}}})- ) (\r -> happyReturn (happyIn282 r))--happyReduce_706 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_706 = happySpecReduce_1 267# happyReduction_706-happyReduction_706 happy_x_1- = case happyOut286 happy_x_1 of { (HappyWrap286 happy_var_1) -> - happyIn283- (happy_var_1- )}--happyReduce_707 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_707 = happyMonadReduce 3# 267# happyReduction_707-happyReduction_707 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut284 happy_x_2 of { (HappyWrap284 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( amsrn (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))- (NameAnn NameBackquotes (glAA happy_var_1) (glNRR happy_var_2) (glAA happy_var_3) []))}}})- ) (\r -> happyReturn (happyIn283 r))--happyReduce_708 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_708 = happySpecReduce_1 268# happyReduction_708-happyReduction_708 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn284- (sL1n happy_var_1 $! mkQual tcClsName (getQCONID happy_var_1)- )}--happyReduce_709 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_709 = happySpecReduce_1 268# happyReduction_709-happyReduction_709 happy_x_1- = case happyOut285 happy_x_1 of { (HappyWrap285 happy_var_1) -> - happyIn284- (happy_var_1- )}--happyReduce_710 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_710 = happySpecReduce_1 269# happyReduction_710-happyReduction_710 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn285- (sL1n happy_var_1 $! mkUnqual tcClsName (getCONID happy_var_1)- )}--happyReduce_711 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_711 = happySpecReduce_1 270# happyReduction_711-happyReduction_711 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn286- (sL1n happy_var_1 $! mkQual tcClsName (getQCONSYM happy_var_1)- )}--happyReduce_712 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_712 = happySpecReduce_1 270# happyReduction_712-happyReduction_712 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn286- (sL1n happy_var_1 $! mkQual tcClsName (getQVARSYM happy_var_1)- )}--happyReduce_713 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_713 = happySpecReduce_1 270# happyReduction_713-happyReduction_713 happy_x_1- = case happyOut287 happy_x_1 of { (HappyWrap287 happy_var_1) -> - happyIn286- (happy_var_1- )}--happyReduce_714 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_714 = happySpecReduce_1 271# happyReduction_714-happyReduction_714 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn287- (sL1n happy_var_1 $! mkUnqual tcClsName (getCONSYM happy_var_1)- )}--happyReduce_715 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_715 = happySpecReduce_1 271# happyReduction_715-happyReduction_715 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn287- (sL1n happy_var_1 $!- -- See Note [eqTyCon (~) is built-in syntax] in GHC.Builtin.Types- if getVARSYM happy_var_1 == fsLit "~"- then eqTyCon_RDR- else mkUnqual tcClsName (getVARSYM happy_var_1)- )}--happyReduce_716 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_716 = happySpecReduce_1 271# happyReduction_716-happyReduction_716 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn287- (sL1n happy_var_1 $! consDataCon_RDR- )}--happyReduce_717 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_717 = happySpecReduce_1 271# happyReduction_717-happyReduction_717 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn287- (sL1n happy_var_1 $! mkUnqual tcClsName (fsLit "-")- )}--happyReduce_718 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_718 = happySpecReduce_1 271# happyReduction_718-happyReduction_718 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn287- (sL1n happy_var_1 $! mkUnqual tcClsName (fsLit ".")- )}--happyReduce_719 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_719 = happySpecReduce_1 272# happyReduction_719-happyReduction_719 happy_x_1- = case happyOut285 happy_x_1 of { (HappyWrap285 happy_var_1) -> - happyIn288- (happy_var_1- )}--happyReduce_720 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_720 = happyMonadReduce 3# 272# happyReduction_720-happyReduction_720 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut287 happy_x_2 of { (HappyWrap287 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( amsrn (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))- (NameAnn NameParens (glAA happy_var_1) (glNRR happy_var_2) (glAA happy_var_3) []))}}})- ) (\r -> happyReturn (happyIn288 r))--happyReduce_721 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_721 = happySpecReduce_1 273# happyReduction_721-happyReduction_721 happy_x_1- = case happyOut290 happy_x_1 of { (HappyWrap290 happy_var_1) -> - happyIn289- (happy_var_1- )}--happyReduce_722 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_722 = happySpecReduce_1 273# happyReduction_722-happyReduction_722 happy_x_1- = case happyOut277 happy_x_1 of { (HappyWrap277 happy_var_1) -> - happyIn289- (happy_var_1- )}--happyReduce_723 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_723 = happySpecReduce_1 273# happyReduction_723-happyReduction_723 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn289- (sL1n happy_var_1 $ getRdrName unrestrictedFunTyCon- )}--happyReduce_724 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_724 = happySpecReduce_1 274# happyReduction_724-happyReduction_724 happy_x_1- = case happyOut307 happy_x_1 of { (HappyWrap307 happy_var_1) -> - happyIn290- (happy_var_1- )}--happyReduce_725 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_725 = happyMonadReduce 3# 274# happyReduction_725-happyReduction_725 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut303 happy_x_2 of { (HappyWrap303 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( amsrn (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))- (NameAnn NameBackquotes (glAA happy_var_1) (glNRR happy_var_2) (glAA happy_var_3) []))}}})- ) (\r -> happyReturn (happyIn290 r))--happyReduce_726 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_726 = happySpecReduce_1 275# happyReduction_726-happyReduction_726 happy_x_1- = case happyOut294 happy_x_1 of { (HappyWrap294 happy_var_1) -> - happyIn291- (mkHsVarOpPV happy_var_1- )}--happyReduce_727 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_727 = happySpecReduce_1 275# happyReduction_727-happyReduction_727 happy_x_1- = case happyOut278 happy_x_1 of { (HappyWrap278 happy_var_1) -> - happyIn291- (mkHsConOpPV happy_var_1- )}--happyReduce_728 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_728 = happySpecReduce_1 275# happyReduction_728-happyReduction_728 happy_x_1- = case happyOut293 happy_x_1 of { (HappyWrap293 happy_var_1) -> - happyIn291- (pvN happy_var_1- )}--happyReduce_729 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_729 = happySpecReduce_1 276# happyReduction_729-happyReduction_729 happy_x_1- = case happyOut295 happy_x_1 of { (HappyWrap295 happy_var_1) -> - happyIn292- (mkHsVarOpPV happy_var_1- )}--happyReduce_730 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_730 = happySpecReduce_1 276# happyReduction_730-happyReduction_730 happy_x_1- = case happyOut278 happy_x_1 of { (HappyWrap278 happy_var_1) -> - happyIn292- (mkHsConOpPV happy_var_1- )}--happyReduce_731 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_731 = happySpecReduce_1 276# happyReduction_731-happyReduction_731 happy_x_1- = case happyOut293 happy_x_1 of { (HappyWrap293 happy_var_1) -> - happyIn292- (pvN happy_var_1- )}--happyReduce_732 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_732 = happySpecReduce_3 277# happyReduction_732-happyReduction_732 happy_x_3- happy_x_2- happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { happy_var_3 -> - happyIn293- (mkHsInfixHolePV (comb2 happy_var_1 happy_var_3)- (\cs -> EpAnn (glR happy_var_1) (EpAnnUnboundVar (glAA happy_var_1, glAA happy_var_3) (glAA happy_var_2)) cs)- )}}}--happyReduce_733 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_733 = happySpecReduce_1 278# happyReduction_733-happyReduction_733 happy_x_1- = case happyOut304 happy_x_1 of { (HappyWrap304 happy_var_1) -> - happyIn294- (happy_var_1- )}--happyReduce_734 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_734 = happyMonadReduce 3# 278# happyReduction_734-happyReduction_734 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut302 happy_x_2 of { (HappyWrap302 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( amsrn (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))- (NameAnn NameBackquotes (glAA happy_var_1) (glNRR happy_var_2) (glAA happy_var_3) []))}}})- ) (\r -> happyReturn (happyIn294 r))--happyReduce_735 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_735 = happySpecReduce_1 279# happyReduction_735-happyReduction_735 happy_x_1- = case happyOut305 happy_x_1 of { (HappyWrap305 happy_var_1) -> - happyIn295- (happy_var_1- )}--happyReduce_736 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_736 = happyMonadReduce 3# 279# happyReduction_736-happyReduction_736 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut302 happy_x_2 of { (HappyWrap302 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( amsrn (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))- (NameAnn NameBackquotes (glAA happy_var_1) (glNRR happy_var_2) (glAA happy_var_3) []))}}})- ) (\r -> happyReturn (happyIn295 r))--happyReduce_737 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_737 = happySpecReduce_1 280# happyReduction_737-happyReduction_737 happy_x_1- = case happyOut298 happy_x_1 of { (HappyWrap298 happy_var_1) -> - happyIn296- (happy_var_1- )}--happyReduce_738 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_738 = happyMonadReduce 3# 281# happyReduction_738-happyReduction_738 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut298 happy_x_2 of { (HappyWrap298 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( amsrn (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))- (NameAnn NameBackquotes (glAA happy_var_1) (glNRR happy_var_2) (glAA happy_var_3) []))}}})- ) (\r -> happyReturn (happyIn297 r))--happyReduce_739 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_739 = happySpecReduce_1 282# happyReduction_739-happyReduction_739 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn298- (sL1n happy_var_1 $! mkUnqual tvName (getVARID happy_var_1)- )}--happyReduce_740 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_740 = happySpecReduce_1 282# happyReduction_740-happyReduction_740 happy_x_1- = case happyOut309 happy_x_1 of { (HappyWrap309 happy_var_1) -> - happyIn298- (sL1n happy_var_1 $! mkUnqual tvName (unLoc happy_var_1)- )}--happyReduce_741 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_741 = happySpecReduce_1 282# happyReduction_741-happyReduction_741 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn298- (sL1n happy_var_1 $! mkUnqual tvName (fsLit "unsafe")- )}--happyReduce_742 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_742 = happySpecReduce_1 282# happyReduction_742-happyReduction_742 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn298- (sL1n happy_var_1 $! mkUnqual tvName (fsLit "safe")- )}--happyReduce_743 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_743 = happySpecReduce_1 282# happyReduction_743-happyReduction_743 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn298- (sL1n happy_var_1 $! mkUnqual tvName (fsLit "interruptible")- )}--happyReduce_744 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_744 = happySpecReduce_1 283# happyReduction_744-happyReduction_744 happy_x_1- = case happyOut303 happy_x_1 of { (HappyWrap303 happy_var_1) -> - happyIn299- (happy_var_1- )}--happyReduce_745 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_745 = happyMonadReduce 3# 283# happyReduction_745-happyReduction_745 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut307 happy_x_2 of { (HappyWrap307 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( amsrn (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))- (NameAnn NameParens (glAA happy_var_1) (glNRR happy_var_2) (glAA happy_var_3) []))}}})- ) (\r -> happyReturn (happyIn299 r))--happyReduce_746 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_746 = happySpecReduce_1 284# happyReduction_746-happyReduction_746 happy_x_1- = case happyOut302 happy_x_1 of { (HappyWrap302 happy_var_1) -> - happyIn300- (happy_var_1- )}--happyReduce_747 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_747 = happyMonadReduce 3# 284# happyReduction_747-happyReduction_747 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut307 happy_x_2 of { (HappyWrap307 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( amsrn (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))- (NameAnn NameParens (glAA happy_var_1) (glNRR happy_var_2) (glAA happy_var_3) []))}}})- ) (\r -> happyReturn (happyIn300 r))--happyReduce_748 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_748 = happyMonadReduce 3# 284# happyReduction_748-happyReduction_748 (happy_x_3 `HappyStk`- happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOutTok happy_x_1 of { happy_var_1 -> - case happyOut306 happy_x_2 of { (HappyWrap306 happy_var_2) -> - case happyOutTok happy_x_3 of { happy_var_3 -> - ( amsrn (sLL happy_var_1 happy_var_3 (unLoc happy_var_2))- (NameAnn NameParens (glAA happy_var_1) (glNRR happy_var_2) (glAA happy_var_3) []))}}})- ) (\r -> happyReturn (happyIn300 r))--happyReduce_749 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_749 = happySpecReduce_1 285# happyReduction_749-happyReduction_749 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn301- (sL1 happy_var_1 $! getVARID happy_var_1- )}--happyReduce_750 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_750 = happySpecReduce_1 286# happyReduction_750-happyReduction_750 happy_x_1- = case happyOut303 happy_x_1 of { (HappyWrap303 happy_var_1) -> - happyIn302- (happy_var_1- )}--happyReduce_751 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_751 = happySpecReduce_1 286# happyReduction_751-happyReduction_751 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn302- (sL1n happy_var_1 $! mkQual varName (getQVARID happy_var_1)- )}--happyReduce_752 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_752 = happySpecReduce_1 287# happyReduction_752-happyReduction_752 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn303- (sL1n happy_var_1 $! mkUnqual varName (getVARID happy_var_1)- )}--happyReduce_753 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_753 = happySpecReduce_1 287# happyReduction_753-happyReduction_753 happy_x_1- = case happyOut309 happy_x_1 of { (HappyWrap309 happy_var_1) -> - happyIn303- (sL1n happy_var_1 $! mkUnqual varName (unLoc happy_var_1)- )}--happyReduce_754 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_754 = happySpecReduce_1 287# happyReduction_754-happyReduction_754 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn303- (sL1n happy_var_1 $! mkUnqual varName (fsLit "unsafe")- )}--happyReduce_755 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_755 = happySpecReduce_1 287# happyReduction_755-happyReduction_755 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn303- (sL1n happy_var_1 $! mkUnqual varName (fsLit "safe")- )}--happyReduce_756 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_756 = happySpecReduce_1 287# happyReduction_756-happyReduction_756 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn303- (sL1n happy_var_1 $! mkUnqual varName (fsLit "interruptible")- )}--happyReduce_757 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_757 = happySpecReduce_1 287# happyReduction_757-happyReduction_757 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn303- (sL1n happy_var_1 $! mkUnqual varName (fsLit "forall")- )}--happyReduce_758 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_758 = happySpecReduce_1 287# happyReduction_758-happyReduction_758 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn303- (sL1n happy_var_1 $! mkUnqual varName (fsLit "family")- )}--happyReduce_759 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_759 = happySpecReduce_1 287# happyReduction_759-happyReduction_759 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn303- (sL1n happy_var_1 $! mkUnqual varName (fsLit "role")- )}--happyReduce_760 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_760 = happySpecReduce_1 288# happyReduction_760-happyReduction_760 happy_x_1- = case happyOut307 happy_x_1 of { (HappyWrap307 happy_var_1) -> - happyIn304- (happy_var_1- )}--happyReduce_761 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_761 = happySpecReduce_1 288# happyReduction_761-happyReduction_761 happy_x_1- = case happyOut306 happy_x_1 of { (HappyWrap306 happy_var_1) -> - happyIn304- (happy_var_1- )}--happyReduce_762 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_762 = happySpecReduce_1 289# happyReduction_762-happyReduction_762 happy_x_1- = case happyOut308 happy_x_1 of { (HappyWrap308 happy_var_1) -> - happyIn305- (happy_var_1- )}--happyReduce_763 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_763 = happySpecReduce_1 289# happyReduction_763-happyReduction_763 happy_x_1- = case happyOut306 happy_x_1 of { (HappyWrap306 happy_var_1) -> - happyIn305- (happy_var_1- )}--happyReduce_764 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_764 = happySpecReduce_1 290# happyReduction_764-happyReduction_764 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn306- (sL1n happy_var_1 $ mkQual varName (getQVARSYM happy_var_1)- )}--happyReduce_765 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_765 = happySpecReduce_1 291# happyReduction_765-happyReduction_765 happy_x_1- = case happyOut308 happy_x_1 of { (HappyWrap308 happy_var_1) -> - happyIn307- (happy_var_1- )}--happyReduce_766 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_766 = happySpecReduce_1 291# happyReduction_766-happyReduction_766 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn307- (sL1n happy_var_1 $ mkUnqual varName (fsLit "-")- )}--happyReduce_767 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_767 = happySpecReduce_1 292# happyReduction_767-happyReduction_767 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn308- (sL1n happy_var_1 $ mkUnqual varName (getVARSYM happy_var_1)- )}--happyReduce_768 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_768 = happySpecReduce_1 292# happyReduction_768-happyReduction_768 happy_x_1- = case happyOut310 happy_x_1 of { (HappyWrap310 happy_var_1) -> - happyIn308- (sL1n happy_var_1 $ mkUnqual varName (unLoc happy_var_1)- )}--happyReduce_769 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_769 = happySpecReduce_1 293# happyReduction_769-happyReduction_769 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn309- (sL1 happy_var_1 (fsLit "as")- )}--happyReduce_770 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_770 = happySpecReduce_1 293# happyReduction_770-happyReduction_770 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn309- (sL1 happy_var_1 (fsLit "qualified")- )}--happyReduce_771 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_771 = happySpecReduce_1 293# happyReduction_771-happyReduction_771 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn309- (sL1 happy_var_1 (fsLit "hiding")- )}--happyReduce_772 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_772 = happySpecReduce_1 293# happyReduction_772-happyReduction_772 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn309- (sL1 happy_var_1 (fsLit "export")- )}--happyReduce_773 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_773 = happySpecReduce_1 293# happyReduction_773-happyReduction_773 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn309- (sL1 happy_var_1 (fsLit "label")- )}--happyReduce_774 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_774 = happySpecReduce_1 293# happyReduction_774-happyReduction_774 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn309- (sL1 happy_var_1 (fsLit "dynamic")- )}--happyReduce_775 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_775 = happySpecReduce_1 293# happyReduction_775-happyReduction_775 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn309- (sL1 happy_var_1 (fsLit "stdcall")- )}--happyReduce_776 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_776 = happySpecReduce_1 293# happyReduction_776-happyReduction_776 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn309- (sL1 happy_var_1 (fsLit "ccall")- )}--happyReduce_777 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_777 = happySpecReduce_1 293# happyReduction_777-happyReduction_777 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn309- (sL1 happy_var_1 (fsLit "capi")- )}--happyReduce_778 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_778 = happySpecReduce_1 293# happyReduction_778-happyReduction_778 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn309- (sL1 happy_var_1 (fsLit "prim")- )}--happyReduce_779 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_779 = happySpecReduce_1 293# happyReduction_779-happyReduction_779 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn309- (sL1 happy_var_1 (fsLit "javascript")- )}--happyReduce_780 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_780 = happySpecReduce_1 293# happyReduction_780-happyReduction_780 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn309- (sL1 happy_var_1 (fsLit "group")- )}--happyReduce_781 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_781 = happySpecReduce_1 293# happyReduction_781-happyReduction_781 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn309- (sL1 happy_var_1 (fsLit "stock")- )}--happyReduce_782 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_782 = happySpecReduce_1 293# happyReduction_782-happyReduction_782 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn309- (sL1 happy_var_1 (fsLit "anyclass")- )}--happyReduce_783 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_783 = happySpecReduce_1 293# happyReduction_783-happyReduction_783 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn309- (sL1 happy_var_1 (fsLit "via")- )}--happyReduce_784 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_784 = happySpecReduce_1 293# happyReduction_784-happyReduction_784 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn309- (sL1 happy_var_1 (fsLit "unit")- )}--happyReduce_785 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_785 = happySpecReduce_1 293# happyReduction_785-happyReduction_785 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn309- (sL1 happy_var_1 (fsLit "dependency")- )}--happyReduce_786 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_786 = happySpecReduce_1 293# happyReduction_786-happyReduction_786 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn309- (sL1 happy_var_1 (fsLit "signature")- )}--happyReduce_787 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_787 = happySpecReduce_1 294# happyReduction_787-happyReduction_787 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn310- (sL1 happy_var_1 (fsLit ".")- )}--happyReduce_788 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_788 = happySpecReduce_1 294# happyReduction_788-happyReduction_788 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn310- (sL1 happy_var_1 (fsLit (starSym (isUnicode happy_var_1)))- )}--happyReduce_789 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_789 = happySpecReduce_1 295# happyReduction_789-happyReduction_789 happy_x_1- = case happyOut312 happy_x_1 of { (HappyWrap312 happy_var_1) -> - happyIn311- (happy_var_1- )}--happyReduce_790 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_790 = happySpecReduce_1 295# happyReduction_790-happyReduction_790 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn311- (sL1n happy_var_1 $! mkQual dataName (getQCONID happy_var_1)- )}--happyReduce_791 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_791 = happySpecReduce_1 296# happyReduction_791-happyReduction_791 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn312- (sL1n happy_var_1 $ mkUnqual dataName (getCONID happy_var_1)- )}--happyReduce_792 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_792 = happySpecReduce_1 297# happyReduction_792-happyReduction_792 happy_x_1- = case happyOut314 happy_x_1 of { (HappyWrap314 happy_var_1) -> - happyIn313- (happy_var_1- )}--happyReduce_793 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_793 = happySpecReduce_1 297# happyReduction_793-happyReduction_793 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn313- (sL1n happy_var_1 $ mkQual dataName (getQCONSYM happy_var_1)- )}--happyReduce_794 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_794 = happySpecReduce_1 298# happyReduction_794-happyReduction_794 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn314- (sL1n happy_var_1 $ mkUnqual dataName (getCONSYM happy_var_1)- )}--happyReduce_795 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_795 = happySpecReduce_1 298# happyReduction_795-happyReduction_795 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn314- (sL1n happy_var_1 $ consDataCon_RDR- )}--happyReduce_796 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_796 = happySpecReduce_1 299# happyReduction_796-happyReduction_796 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn315- (sL1 happy_var_1 $ HsChar (getCHARs happy_var_1) $ getCHAR happy_var_1- )}--happyReduce_797 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_797 = happySpecReduce_1 299# happyReduction_797-happyReduction_797 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn315- (sL1 happy_var_1 $ HsString (getSTRINGs happy_var_1)- $ getSTRING happy_var_1- )}--happyReduce_798 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_798 = happySpecReduce_1 299# happyReduction_798-happyReduction_798 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn315- (sL1 happy_var_1 $ HsIntPrim (getPRIMINTEGERs happy_var_1)- $ getPRIMINTEGER happy_var_1- )}--happyReduce_799 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_799 = happySpecReduce_1 299# happyReduction_799-happyReduction_799 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn315- (sL1 happy_var_1 $ HsWordPrim (getPRIMWORDs happy_var_1)- $ getPRIMWORD happy_var_1- )}--happyReduce_800 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_800 = happySpecReduce_1 299# happyReduction_800-happyReduction_800 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn315- (sL1 happy_var_1 $ HsCharPrim (getPRIMCHARs happy_var_1)- $ getPRIMCHAR happy_var_1- )}--happyReduce_801 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_801 = happySpecReduce_1 299# happyReduction_801-happyReduction_801 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn315- (sL1 happy_var_1 $ HsStringPrim (getPRIMSTRINGs happy_var_1)- $ getPRIMSTRING happy_var_1- )}--happyReduce_802 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_802 = happySpecReduce_1 299# happyReduction_802-happyReduction_802 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn315- (sL1 happy_var_1 $ HsFloatPrim noExtField $ getPRIMFLOAT happy_var_1- )}--happyReduce_803 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_803 = happySpecReduce_1 299# happyReduction_803-happyReduction_803 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn315- (sL1 happy_var_1 $ HsDoublePrim noExtField $ getPRIMDOUBLE happy_var_1- )}--happyReduce_804 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_804 = happySpecReduce_1 300# happyReduction_804-happyReduction_804 happy_x_1- = happyIn316- (()- )--happyReduce_805 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_805 = happyMonadReduce 1# 300# happyReduction_805-happyReduction_805 (happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((( popContext))- ) (\r -> happyReturn (happyIn316 r))--happyReduce_806 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_806 = happySpecReduce_1 301# happyReduction_806-happyReduction_806 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn317- (sL1a happy_var_1 $ mkModuleNameFS (getCONID happy_var_1)- )}--happyReduce_807 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_807 = happySpecReduce_1 301# happyReduction_807-happyReduction_807 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn317- (sL1a happy_var_1 $ let (mod,c) = getQCONID happy_var_1 in- mkModuleNameFS- (mkFastString- (unpackFS mod ++ '.':unpackFS c))- )}--happyReduce_808 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_808 = happySpecReduce_2 302# happyReduction_808-happyReduction_808 happy_x_2- happy_x_1- = case happyOut318 happy_x_1 of { (HappyWrap318 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - happyIn318- (((fst happy_var_1)++[gl happy_var_2],snd happy_var_1 + 1)- )}}--happyReduce_809 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_809 = happySpecReduce_1 302# happyReduction_809-happyReduction_809 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn318- (([gl happy_var_1],1)- )}--happyReduce_810 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_810 = happySpecReduce_1 303# happyReduction_810-happyReduction_810 happy_x_1- = case happyOut320 happy_x_1 of { (HappyWrap320 happy_var_1) -> - happyIn319- (happy_var_1- )}--happyReduce_811 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_811 = happySpecReduce_0 303# happyReduction_811-happyReduction_811 = happyIn319- (([], 0)- )--happyReduce_812 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_812 = happySpecReduce_2 304# happyReduction_812-happyReduction_812 happy_x_2- happy_x_1- = case happyOut320 happy_x_1 of { (HappyWrap320 happy_var_1) -> - case happyOutTok happy_x_2 of { happy_var_2 -> - happyIn320- (((fst happy_var_1)++[glAA happy_var_2],snd happy_var_1 + 1)- )}}--happyReduce_813 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_813 = happySpecReduce_1 304# happyReduction_813-happyReduction_813 happy_x_1- = case happyOutTok happy_x_1 of { happy_var_1 -> - happyIn320- (([glAA happy_var_1],1)- )}--happyReduce_814 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_814 = happyMonadReduce 2# 305# happyReduction_814-happyReduction_814 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut211 happy_x_1 of { (HappyWrap211 happy_var_1) -> - case happyOut206 happy_x_2 of { (HappyWrap206 happy_var_2) -> - ( runPV (unECP happy_var_2) >>= \ happy_var_2 ->- fmap ecpFromExp $- return $ (reLocA $ sLLlA happy_var_1 happy_var_2 $ HsPragE noExtField (unLoc happy_var_1) happy_var_2))}})- ) (\r -> happyReturn (happyIn321 r))--happyReduce_815 :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )-happyReduce_815 = happyMonadReduce 2# 306# happyReduction_815-happyReduction_815 (happy_x_2 `HappyStk`- happy_x_1 `HappyStk`- happyRest) tk- = happyThen ((case happyOut211 happy_x_1 of { (HappyWrap211 happy_var_1) -> - case happyOut208 happy_x_2 of { (HappyWrap208 happy_var_2) -> - ( runPV (unECP happy_var_2) >>= \ happy_var_2 ->- fmap ecpFromExp $- return $ (reLocA $ sLLlA happy_var_1 happy_var_2 $ HsPragE noExtField (unLoc happy_var_1) happy_var_2))}})- ) (\r -> happyReturn (happyIn322 r))--happyNewToken action sts stk- = (lexer True)(\tk -> - let cont i = happyDoAction i tk action sts stk in- case tk of {- L _ ITeof -> happyDoAction 148# tk action sts stk;- L _ ITunderscore -> cont 1#;- L _ ITas -> cont 2#;- L _ ITcase -> cont 3#;- L _ ITclass -> cont 4#;- L _ ITdata -> cont 5#;- L _ ITdefault -> cont 6#;- L _ ITderiving -> cont 7#;- L _ ITelse -> cont 8#;- L _ IThiding -> cont 9#;- L _ ITif -> cont 10#;- L _ ITimport -> cont 11#;- L _ ITin -> cont 12#;- L _ ITinfix -> cont 13#;- L _ ITinfixl -> cont 14#;- L _ ITinfixr -> cont 15#;- L _ ITinstance -> cont 16#;- L _ ITlet -> cont 17#;- L _ ITmodule -> cont 18#;- L _ ITnewtype -> cont 19#;- L _ ITof -> cont 20#;- L _ ITqualified -> cont 21#;- L _ ITthen -> cont 22#;- L _ ITtype -> cont 23#;- L _ ITwhere -> cont 24#;- L _ (ITforall _) -> cont 25#;- L _ ITforeign -> cont 26#;- L _ ITexport -> cont 27#;- L _ ITlabel -> cont 28#;- L _ ITdynamic -> cont 29#;- L _ ITsafe -> cont 30#;- L _ ITinterruptible -> cont 31#;- L _ ITunsafe -> cont 32#;- L _ ITfamily -> cont 33#;- L _ ITrole -> cont 34#;- L _ ITstdcallconv -> cont 35#;- L _ ITccallconv -> cont 36#;- L _ ITcapiconv -> cont 37#;- L _ ITprimcallconv -> cont 38#;- L _ ITjavascriptcallconv -> cont 39#;- L _ ITproc -> cont 40#;- L _ ITrec -> cont 41#;- L _ ITgroup -> cont 42#;- L _ ITby -> cont 43#;- L _ ITusing -> cont 44#;- L _ ITpattern -> cont 45#;- L _ ITstatic -> cont 46#;- L _ ITstock -> cont 47#;- L _ ITanyclass -> cont 48#;- L _ ITvia -> cont 49#;- L _ ITunit -> cont 50#;- L _ ITsignature -> cont 51#;- L _ ITdependency -> cont 52#;- L _ (ITinline_prag _ _ _) -> cont 53#;- L _ (ITspec_prag _) -> cont 54#;- L _ (ITspec_inline_prag _ _) -> cont 55#;- L _ (ITsource_prag _) -> cont 56#;- L _ (ITrules_prag _) -> cont 57#;- L _ (ITscc_prag _) -> cont 58#;- L _ (ITdeprecated_prag _) -> cont 59#;- L _ (ITwarning_prag _) -> cont 60#;- L _ (ITunpack_prag _) -> cont 61#;- L _ (ITnounpack_prag _) -> cont 62#;- L _ (ITann_prag _) -> cont 63#;- L _ (ITminimal_prag _) -> cont 64#;- L _ (ITctype _) -> cont 65#;- L _ (IToverlapping_prag _) -> cont 66#;- L _ (IToverlappable_prag _) -> cont 67#;- L _ (IToverlaps_prag _) -> cont 68#;- L _ (ITincoherent_prag _) -> cont 69#;- L _ (ITcomplete_prag _) -> cont 70#;- L _ ITclose_prag -> cont 71#;- L _ ITdotdot -> cont 72#;- L _ ITcolon -> cont 73#;- L _ (ITdcolon _) -> cont 74#;- L _ ITequal -> cont 75#;- L _ ITlam -> cont 76#;- L _ ITlcase -> cont 77#;- L _ ITvbar -> cont 78#;- L _ (ITlarrow _) -> cont 79#;- L _ (ITrarrow _) -> cont 80#;- L _ ITlolly -> cont 81#;- L _ ITat -> cont 82#;- L _ (ITdarrow _) -> cont 83#;- L _ ITminus -> cont 84#;- L _ ITtilde -> cont 85#;- L _ ITbang -> cont 86#;- L _ ITprefixminus -> cont 87#;- L _ (ITstar _) -> cont 88#;- L _ (ITlarrowtail _) -> cont 89#;- L _ (ITrarrowtail _) -> cont 90#;- L _ (ITLarrowtail _) -> cont 91#;- L _ (ITRarrowtail _) -> cont 92#;- L _ ITdot -> cont 93#;- L _ (ITproj True) -> cont 94#;- L _ (ITproj False) -> cont 95#;- L _ ITtypeApp -> cont 96#;- L _ ITpercent -> cont 97#;- L _ ITocurly -> cont 98#;- L _ ITccurly -> cont 99#;- L _ ITvocurly -> cont 100#;- L _ ITvccurly -> cont 101#;- L _ ITobrack -> cont 102#;- L _ ITcbrack -> cont 103#;- L _ IToparen -> cont 104#;- L _ ITcparen -> cont 105#;- L _ IToubxparen -> cont 106#;- L _ ITcubxparen -> cont 107#;- L _ (IToparenbar _) -> cont 108#;- L _ (ITcparenbar _) -> cont 109#;- L _ ITsemi -> cont 110#;- L _ ITcomma -> cont 111#;- L _ ITbackquote -> cont 112#;- L _ ITsimpleQuote -> cont 113#;- L _ (ITvarid _) -> cont 114#;- L _ (ITconid _) -> cont 115#;- L _ (ITvarsym _) -> cont 116#;- L _ (ITconsym _) -> cont 117#;- L _ (ITqvarid _) -> cont 118#;- L _ (ITqconid _) -> cont 119#;- L _ (ITqvarsym _) -> cont 120#;- L _ (ITqconsym _) -> cont 121#;- L _ (ITdo _) -> cont 122#;- L _ (ITmdo _) -> cont 123#;- L _ (ITdupipvarid _) -> cont 124#;- L _ (ITlabelvarid _) -> cont 125#;- L _ (ITchar _ _) -> cont 126#;- L _ (ITstring _ _) -> cont 127#;- L _ (ITinteger _) -> cont 128#;- L _ (ITrational _) -> cont 129#;- L _ (ITprimchar _ _) -> cont 130#;- L _ (ITprimstring _ _) -> cont 131#;- L _ (ITprimint _ _) -> cont 132#;- L _ (ITprimword _ _) -> cont 133#;- L _ (ITprimfloat _) -> cont 134#;- L _ (ITprimdouble _) -> cont 135#;- L _ (ITopenExpQuote _ _) -> cont 136#;- L _ ITopenPatQuote -> cont 137#;- L _ ITopenTypQuote -> cont 138#;- L _ ITopenDecQuote -> cont 139#;- L _ (ITcloseQuote _) -> cont 140#;- L _ (ITopenTExpQuote _) -> cont 141#;- L _ ITcloseTExpQuote -> cont 142#;- L _ ITdollar -> cont 143#;- L _ ITdollardollar -> cont 144#;- L _ ITtyQuote -> cont 145#;- L _ (ITquasiQuote _) -> cont 146#;- L _ (ITqQuasiQuote _) -> cont 147#;- _ -> happyError' (tk, [])- })--happyError_ explist 148# tk = happyError' (tk, explist)-happyError_ explist _ tk = happyError' (tk, explist)--happyThen :: () => P a -> (a -> P b) -> P b-happyThen = (>>=)-happyReturn :: () => a -> P a-happyReturn = (return)-happyParse :: () => Happy_GHC_Exts.Int# -> P (HappyAbsSyn )--happyNewToken :: () => Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )--happyDoAction :: () => Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn )--happyReduceArr :: () => Happy_Data_Array.Array Prelude.Int (Happy_GHC_Exts.Int# -> (Located Token) -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> P (HappyAbsSyn ))--happyThen1 :: () => P a -> (a -> P b) -> P b-happyThen1 = happyThen-happyReturn1 :: () => a -> P a-happyReturn1 = happyReturn-happyError' :: () => (((Located Token)), [Prelude.String]) -> P a-happyError' tk = (\(tokens, explist) -> happyError) tk-parseModuleNoHaddock = happySomeParser where- happySomeParser = happyThen (happyParse 0#) (\x -> happyReturn (let {(HappyWrap35 x') = happyOut35 x} in x'))--parseSignature = happySomeParser where- happySomeParser = happyThen (happyParse 1#) (\x -> happyReturn (let {(HappyWrap34 x') = happyOut34 x} in x'))--parseImport = happySomeParser where- happySomeParser = happyThen (happyParse 2#) (\x -> happyReturn (let {(HappyWrap62 x') = happyOut62 x} in x'))--parseStatement = happySomeParser where- happySomeParser = happyThen (happyParse 3#) (\x -> happyReturn (let {(HappyWrap252 x') = happyOut252 x} in x'))--parseDeclaration = happySomeParser where- happySomeParser = happyThen (happyParse 4#) (\x -> happyReturn (let {(HappyWrap78 x') = happyOut78 x} in x'))--parseExpression = happySomeParser where- happySomeParser = happyThen (happyParse 5#) (\x -> happyReturn (let {(HappyWrap206 x') = happyOut206 x} in x'))--parsePattern = happySomeParser where- happySomeParser = happyThen (happyParse 6#) (\x -> happyReturn (let {(HappyWrap245 x') = happyOut245 x} in x'))--parseTypeSignature = happySomeParser where- happySomeParser = happyThen (happyParse 7#) (\x -> happyReturn (let {(HappyWrap202 x') = happyOut202 x} in x'))--parseStmt = happySomeParser where- happySomeParser = happyThen (happyParse 8#) (\x -> happyReturn (let {(HappyWrap251 x') = happyOut251 x} in x'))--parseIdentifier = happySomeParser where- happySomeParser = happyThen (happyParse 9#) (\x -> happyReturn (let {(HappyWrap16 x') = happyOut16 x} in x'))--parseType = happySomeParser where- happySomeParser = happyThen (happyParse 10#) (\x -> happyReturn (let {(HappyWrap158 x') = happyOut158 x} in x'))--parseBackpack = happySomeParser where- happySomeParser = happyThen (happyParse 11#) (\x -> happyReturn (let {(HappyWrap17 x') = happyOut17 x} in x'))--parseHeader = happySomeParser where- happySomeParser = happyThen (happyParse 12#) (\x -> happyReturn (let {(HappyWrap43 x') = happyOut43 x} in x'))--happySeq = happyDoSeq---happyError :: P a-happyError = srcParseFail--getVARID (L _ (ITvarid x)) = x-getCONID (L _ (ITconid x)) = x-getVARSYM (L _ (ITvarsym x)) = x-getCONSYM (L _ (ITconsym x)) = x-getDO (L _ (ITdo x)) = x-getMDO (L _ (ITmdo x)) = x-getQVARID (L _ (ITqvarid x)) = x-getQCONID (L _ (ITqconid x)) = x-getQVARSYM (L _ (ITqvarsym x)) = x-getQCONSYM (L _ (ITqconsym x)) = x-getIPDUPVARID (L _ (ITdupipvarid x)) = x-getLABELVARID (L _ (ITlabelvarid x)) = x-getCHAR (L _ (ITchar _ x)) = x-getSTRING (L _ (ITstring _ x)) = x-getINTEGER (L _ (ITinteger x)) = x-getRATIONAL (L _ (ITrational x)) = x-getPRIMCHAR (L _ (ITprimchar _ x)) = x-getPRIMSTRING (L _ (ITprimstring _ x)) = x-getPRIMINTEGER (L _ (ITprimint _ x)) = x-getPRIMWORD (L _ (ITprimword _ x)) = x-getPRIMFLOAT (L _ (ITprimfloat x)) = x-getPRIMDOUBLE (L _ (ITprimdouble x)) = x-getINLINE (L _ (ITinline_prag _ inl conl)) = (inl,conl)-getSPEC_INLINE (L _ (ITspec_inline_prag _ True)) = (Inline, FunLike)-getSPEC_INLINE (L _ (ITspec_inline_prag _ False)) = (NoInline,FunLike)-getCOMPLETE_PRAGs (L _ (ITcomplete_prag x)) = x-getVOCURLY (L (RealSrcSpan l _) ITvocurly) = srcSpanStartCol l--getINTEGERs (L _ (ITinteger (IL src _ _))) = src-getCHARs (L _ (ITchar src _)) = src-getSTRINGs (L _ (ITstring src _)) = src-getPRIMCHARs (L _ (ITprimchar src _)) = src-getPRIMSTRINGs (L _ (ITprimstring src _)) = src-getPRIMINTEGERs (L _ (ITprimint src _)) = src-getPRIMWORDs (L _ (ITprimword src _)) = src---- See Note [Pragma source text] in "GHC.Types.Basic" for the following-getINLINE_PRAGs (L _ (ITinline_prag src _ _)) = src-getSPEC_PRAGs (L _ (ITspec_prag src)) = src-getSPEC_INLINE_PRAGs (L _ (ITspec_inline_prag src _)) = src-getSOURCE_PRAGs (L _ (ITsource_prag src)) = src-getRULES_PRAGs (L _ (ITrules_prag src)) = src-getWARNING_PRAGs (L _ (ITwarning_prag src)) = src-getDEPRECATED_PRAGs (L _ (ITdeprecated_prag src)) = src-getSCC_PRAGs (L _ (ITscc_prag src)) = src-getUNPACK_PRAGs (L _ (ITunpack_prag src)) = src-getNOUNPACK_PRAGs (L _ (ITnounpack_prag src)) = src-getANN_PRAGs (L _ (ITann_prag src)) = src-getMINIMAL_PRAGs (L _ (ITminimal_prag src)) = src-getOVERLAPPABLE_PRAGs (L _ (IToverlappable_prag src)) = src-getOVERLAPPING_PRAGs (L _ (IToverlapping_prag src)) = src-getOVERLAPS_PRAGs (L _ (IToverlaps_prag src)) = src-getINCOHERENT_PRAGs (L _ (ITincoherent_prag src)) = src-getCTYPEs (L _ (ITctype src)) = src--getStringLiteral l = StringLiteral (getSTRINGs l) (getSTRING l) Nothing--isUnicode :: Located Token -> Bool-isUnicode (L _ (ITforall iu)) = iu == UnicodeSyntax-isUnicode (L _ (ITdarrow iu)) = iu == UnicodeSyntax-isUnicode (L _ (ITdcolon iu)) = iu == UnicodeSyntax-isUnicode (L _ (ITlarrow iu)) = iu == UnicodeSyntax-isUnicode (L _ (ITrarrow iu)) = iu == UnicodeSyntax-isUnicode (L _ (ITlarrowtail iu)) = iu == UnicodeSyntax-isUnicode (L _ (ITrarrowtail iu)) = iu == UnicodeSyntax-isUnicode (L _ (ITLarrowtail iu)) = iu == UnicodeSyntax-isUnicode (L _ (ITRarrowtail iu)) = iu == UnicodeSyntax-isUnicode (L _ (IToparenbar iu)) = iu == UnicodeSyntax-isUnicode (L _ (ITcparenbar iu)) = iu == UnicodeSyntax-isUnicode (L _ (ITopenExpQuote _ iu)) = iu == UnicodeSyntax-isUnicode (L _ (ITcloseQuote iu)) = iu == UnicodeSyntax-isUnicode (L _ (ITstar iu)) = iu == UnicodeSyntax-isUnicode (L _ ITlolly) = True-isUnicode _ = False--hasE :: Located Token -> Bool-hasE (L _ (ITopenExpQuote HasE _)) = True-hasE (L _ (ITopenTExpQuote HasE)) = True-hasE _ = False--getSCC :: Located Token -> P FastString-getSCC lt = do let s = getSTRING lt- -- We probably actually want to be more restrictive than this- if ' ' `elem` unpackFS s- then addFatalError $ PsError PsErrSpaceInSCC [] (getLoc lt)- else return s---- Utilities for combining source spans-comb2 :: Located a -> Located b -> SrcSpan-comb2 a b = a `seq` b `seq` combineLocs a b---- Utilities for combining source spans-comb2A :: Located a -> LocatedAn t b -> SrcSpan-comb2A a b = a `seq` b `seq` combineLocs a (reLoc b)--comb2N :: Located a -> LocatedN b -> SrcSpan-comb2N a b = a `seq` b `seq` combineLocs a (reLocN b)--comb2Al :: LocatedAn t a -> Located b -> SrcSpan-comb2Al a b = a `seq` b `seq` combineLocs (reLoc a) b--comb3 :: Located a -> Located b -> Located c -> SrcSpan-comb3 a b c = a `seq` b `seq` c `seq`- combineSrcSpans (getLoc a) (combineSrcSpans (getLoc b) (getLoc c))--comb3A :: Located a -> Located b -> LocatedAn t c -> SrcSpan-comb3A a b c = a `seq` b `seq` c `seq`- combineSrcSpans (getLoc a) (combineSrcSpans (getLoc b) (getLocA c))--comb3N :: Located a -> Located b -> LocatedN c -> SrcSpan-comb3N a b c = a `seq` b `seq` c `seq`- combineSrcSpans (getLoc a) (combineSrcSpans (getLoc b) (getLocA c))--comb4 :: Located a -> Located b -> Located c -> Located d -> SrcSpan-comb4 a b c d = a `seq` b `seq` c `seq` d `seq`- (combineSrcSpans (getLoc a) $ combineSrcSpans (getLoc b) $- combineSrcSpans (getLoc c) (getLoc d))--comb5 :: Located a -> Located b -> Located c -> Located d -> Located e -> SrcSpan-comb5 a b c d e = a `seq` b `seq` c `seq` d `seq` e `seq`- (combineSrcSpans (getLoc a) $ combineSrcSpans (getLoc b) $- combineSrcSpans (getLoc c) $ combineSrcSpans (getLoc d) (getLoc e))---- strict constructor version:-{-# INLINE sL #-}-sL :: l -> a -> GenLocated l a-sL loc a = loc `seq` a `seq` L loc a---- See Note [Adding location info] for how these utility functions are used---- replaced last 3 CPP macros in this file-{-# INLINE sL0 #-}-sL0 :: a -> Located a-sL0 = L noSrcSpan -- #define L0 L noSrcSpan--{-# INLINE sL1 #-}-sL1 :: GenLocated l a -> b -> GenLocated l b-sL1 x = sL (getLoc x) -- #define sL1 sL (getLoc $1)--{-# INLINE sL1A #-}-sL1A :: LocatedAn t a -> b -> Located b-sL1A x = sL (getLocA x) -- #define sL1 sL (getLoc $1)--{-# INLINE sL1N #-}-sL1N :: LocatedN a -> b -> Located b-sL1N x = sL (getLocA x) -- #define sL1 sL (getLoc $1)--{-# INLINE sL1a #-}-sL1a :: Located a -> b -> LocatedAn t b-sL1a x = sL (noAnnSrcSpan $ getLoc x) -- #define sL1 sL (getLoc $1)--{-# INLINE sL1n #-}-sL1n :: Located a -> b -> LocatedN b-sL1n x = L (noAnnSrcSpan $ getLoc x) -- #define sL1 sL (getLoc $1)--{-# INLINE sLL #-}-sLL :: Located a -> Located b -> c -> Located c-sLL x y = sL (comb2 x y) -- #define LL sL (comb2 $1 $>)--{-# INLINE sLLa #-}-sLLa :: Located a -> Located b -> c -> LocatedAn t c-sLLa x y = sL (noAnnSrcSpan $ comb2 x y) -- #define LL sL (comb2 $1 $>)--{-# INLINE sLLlA #-}-sLLlA :: Located a -> LocatedAn t b -> c -> Located c-sLLlA x y = sL (comb2A x y) -- #define LL sL (comb2 $1 $>)--{-# INLINE sLLAl #-}-sLLAl :: LocatedAn t a -> Located b -> c -> Located c-sLLAl x y = sL (comb2A y x) -- #define LL sL (comb2 $1 $>)--{-# INLINE sLLAA #-}-sLLAA :: LocatedAn t a -> LocatedAn u b -> c -> Located c-sLLAA x y = sL (comb2 (reLoc y) (reLoc x)) -- #define LL sL (comb2 $1 $>)---{- Note [Adding location info]- ~~~~~~~~~~~~~~~~~~~~~~~~~~~--This is done using the three functions below, sL0, sL1-and sLL. Note that these functions were mechanically-converted from the three macros that used to exist before,-namely L0, L1 and LL.--They each add a SrcSpan to their argument.-- sL0 adds 'noSrcSpan', used for empty productions- -- This doesn't seem to work anymore -=chak-- sL1 for a production with a single token on the lhs. Grabs the SrcSpan- from that token.-- sLL for a production with >1 token on the lhs. Makes up a SrcSpan from- the first and last tokens.--These suffice for the majority of cases. However, we must be-especially careful with empty productions: sLL won't work if the first-or last token on the lhs can represent an empty span. In these cases,-we have to calculate the span using more of the tokens from the lhs, eg.-- | 'newtype' tycl_hdr '=' newconstr deriving- { L (comb3 $1 $4 $5)- (mkTyData NewType (unLoc $2) $4 (unLoc $5)) }--We provide comb3 and comb4 functions which are useful in such cases.--Be careful: there's no checking that you actually got this right, the-only symptom will be that the SrcSpans of your syntax will be-incorrect.---}---- Make a source location for the file. We're a bit lazy here and just--- make a point SrcSpan at line 1, column 0. Strictly speaking we should--- try to find the span of the whole file (ToDo).-fileSrcSpan :: P SrcSpan-fileSrcSpan = do- l <- getRealSrcLoc;- let loc = mkSrcLoc (srcLocFile l) 1 1;- return (mkSrcSpan loc loc)---- Hint about linear types-hintLinear :: MonadP m => SrcSpan -> m ()-hintLinear span = do- linearEnabled <- getBit LinearTypesBit- unless linearEnabled $ addError $ PsError PsErrLinearFunction [] span---- Does this look like (a %m)?-looksLikeMult :: LHsType GhcPs -> LocatedN RdrName -> LHsType GhcPs -> Bool-looksLikeMult ty1 l_op ty2- | Unqual op_name <- unLoc l_op- , occNameFS op_name == fsLit "%"- , Just ty1_pos <- getBufSpan (getLocA ty1)- , Just pct_pos <- getBufSpan (getLocA l_op)- , Just ty2_pos <- getBufSpan (getLocA ty2)- , bufSpanEnd ty1_pos /= bufSpanStart pct_pos- , bufSpanEnd pct_pos == bufSpanStart ty2_pos- = True- | otherwise = False---- Hint about the MultiWayIf extension-hintMultiWayIf :: SrcSpan -> P ()-hintMultiWayIf span = do- mwiEnabled <- getBit MultiWayIfBit- unless mwiEnabled $ addError $ PsError PsErrMultiWayIf [] span---- Hint about explicit-forall-hintExplicitForall :: Located Token -> P ()-hintExplicitForall tok = do- forall <- getBit ExplicitForallBit- rulePrag <- getBit InRulePragBit- unless (forall || rulePrag) $ addError $ PsError (PsErrExplicitForall (isUnicode tok)) [] (getLoc tok)---- Hint about qualified-do-hintQualifiedDo :: Located Token -> P ()-hintQualifiedDo tok = do- qualifiedDo <- getBit QualifiedDoBit- case maybeQDoDoc of- Just qdoDoc | not qualifiedDo ->- addError $ PsError (PsErrIllegalQualifiedDo qdoDoc) [] (getLoc tok)- _ -> return ()- where- maybeQDoDoc = case unLoc tok of- ITdo (Just m) -> Just $ ftext m <> text ".do"- ITmdo (Just m) -> Just $ ftext m <> text ".mdo"- t -> Nothing---- When two single quotes don't followed by tyvar or gtycon, we report the--- error as empty character literal, or TH quote that missing proper type--- variable or constructor. See #13450.-reportEmptyDoubleQuotes :: SrcSpan -> P a-reportEmptyDoubleQuotes span = do- thQuotes <- getBit ThQuotesBit- addFatalError $ PsError (PsErrEmptyDoubleQuotes thQuotes) [] span--{--%************************************************************************-%* *- Helper functions for generating annotations in the parser-%* *-%************************************************************************--For the general principles of the following routines, see Note [exact print annotations]-in GHC.Parser.Annotation---}---- |Construct an AddEpAnn from the annotation keyword and the location--- of the keyword itself-mj :: AnnKeywordId -> Located e -> AddEpAnn-mj a l = AddEpAnn a (EpaSpan $ rs $ gl l)--mjN :: AnnKeywordId -> LocatedN e -> AddEpAnn-mjN a l = AddEpAnn a (EpaSpan $ rs $ glN l)---- |Construct an AddEpAnn from the annotation keyword and the location--- of the keyword itself, provided the span is not zero width-mz :: AnnKeywordId -> Located e -> [AddEpAnn]-mz a l = if isZeroWidthSpan (gl l) then [] else [AddEpAnn a (EpaSpan $ rs $ gl l)]--msemi :: Located e -> [TrailingAnn]-msemi l = if isZeroWidthSpan (gl l) then [] else [AddSemiAnn (EpaSpan $ rs $ gl l)]--msemim :: Located e -> Maybe EpaLocation-msemim l = if isZeroWidthSpan (gl l) then Nothing else Just (EpaSpan $ rs $ gl l)---- |Construct an AddEpAnn from the annotation keyword and the Located Token. If--- the token has a unicode equivalent and this has been used, provide the--- unicode variant of the annotation.-mu :: AnnKeywordId -> Located Token -> AddEpAnn-mu a lt@(L l t) = AddEpAnn (toUnicodeAnn a lt) (EpaSpan $ rs l)--mau :: Located Token -> TrailingAnn-mau lt@(L l t) = if isUnicode lt then AddRarrowAnnU (EpaSpan $ rs l)- else AddRarrowAnn (EpaSpan $ rs l)--mlu :: Located Token -> TrailingAnn-mlu lt@(L l t) = AddLollyAnnU (EpaSpan $ rs l)---- | If the 'Token' is using its unicode variant return the unicode variant of--- the annotation-toUnicodeAnn :: AnnKeywordId -> Located Token -> AnnKeywordId-toUnicodeAnn a t = if isUnicode t then unicodeAnn a else a--toUnicode :: Located Token -> IsUnicodeSyntax-toUnicode t = if isUnicode t then UnicodeSyntax else NormalSyntax--gl :: GenLocated l a -> l-gl = getLoc--glA :: LocatedAn t a -> SrcSpan-glA = getLocA--glN :: LocatedN a -> SrcSpan-glN = getLocA--glR :: Located a -> Anchor-glR la = Anchor (realSrcSpan $ getLoc la) UnchangedAnchor--glAA :: Located a -> EpaLocation-glAA = EpaSpan <$> realSrcSpan . getLoc--glRR :: Located a -> RealSrcSpan-glRR = realSrcSpan . getLoc--glAR :: LocatedAn t a -> Anchor-glAR la = Anchor (realSrcSpan $ getLocA la) UnchangedAnchor--glNR :: LocatedN a -> Anchor-glNR ln = Anchor (realSrcSpan $ getLocA ln) UnchangedAnchor--glNRR :: LocatedN a -> EpaLocation-glNRR = EpaSpan <$> realSrcSpan . getLocA--anc :: RealSrcSpan -> Anchor-anc r = Anchor r UnchangedAnchor--acs :: MonadP m => (EpAnnComments -> Located a) -> m (Located a)-acs a = do- let (L l _) = a emptyComments- cs <- getCommentsFor l- return (a cs)---- Called at the very end to pick up the EOF position, as well as any comments not allocated yet.-acsFinal :: (EpAnnComments -> Located a) -> P (Located a)-acsFinal a = do- let (L l _) = a emptyComments- cs <- getCommentsFor l- csf <- getFinalCommentsFor l- meof <- getEofPos- let ce = case meof of- Nothing -> EpaComments []- Just (pos, gap) -> EpaCommentsBalanced [] [L (realSpanAsAnchor pos) (EpaComment EpaEofComment gap)]- return (a (cs Semi.<> csf Semi.<> ce))--acsa :: MonadP m => (EpAnnComments -> LocatedAn t a) -> m (LocatedAn t a)-acsa a = do- let (L l _) = a emptyComments- cs <- getCommentsFor (locA l)- return (a cs)--acsA :: MonadP m => (EpAnnComments -> Located a) -> m (LocatedAn t a)-acsA a = reLocA <$> acs a--acsExpr :: (EpAnnComments -> LHsExpr GhcPs) -> P ECP-acsExpr a = do { expr :: (LHsExpr GhcPs) <- runPV $ acsa a- ; return (ecpFromExp $ expr) }--amsA :: MonadP m => LocatedA a -> [TrailingAnn] -> m (LocatedA a)-amsA (L l a) bs = do- cs <- getCommentsFor (locA l)- return (L (addAnnsA l bs cs) a)--amsAl :: MonadP m => LocatedA a -> SrcSpan -> [TrailingAnn] -> m (LocatedA a)-amsAl (L l a) loc bs = do- cs <- getCommentsFor loc- return (L (addAnnsA l bs cs) a)--amsrc :: MonadP m => Located a -> AnnContext -> m (LocatedC a)-amsrc a@(L l _) bs = do- cs <- getCommentsFor l- return (reAnnC bs cs a)--amsrl :: MonadP m => Located a -> AnnList -> m (LocatedL a)-amsrl a@(L l _) bs = do- cs <- getCommentsFor l- return (reAnnL bs cs a)--amsrp :: MonadP m => Located a -> AnnPragma -> m (LocatedP a)-amsrp a@(L l _) bs = do- cs <- getCommentsFor l- return (reAnnL bs cs a)--amsrn :: MonadP m => Located a -> NameAnn -> m (LocatedN a)-amsrn (L l a) an = do- cs <- getCommentsFor l- let ann = (EpAnn (spanAsAnchor l) an cs)- return (L (SrcSpanAnn ann l) a)---- |Synonyms for AddEpAnn versions of AnnOpen and AnnClose-mo,mc :: Located Token -> AddEpAnn-mo ll = mj AnnOpen ll-mc ll = mj AnnClose ll--moc,mcc :: Located Token -> AddEpAnn-moc ll = mj AnnOpenC ll-mcc ll = mj AnnCloseC ll--mop,mcp :: Located Token -> AddEpAnn-mop ll = mj AnnOpenP ll-mcp ll = mj AnnCloseP ll--moh,mch :: Located Token -> AddEpAnn-moh ll = mj AnnOpenPH ll-mch ll = mj AnnClosePH ll--mos,mcs :: Located Token -> AddEpAnn-mos ll = mj AnnOpenS ll-mcs ll = mj AnnCloseS ll--pvA :: MonadP m => m (Located a) -> m (LocatedAn t a)-pvA a = do { av <- a- ; return (reLocA av) }--pvN :: MonadP m => m (Located a) -> m (LocatedN a)-pvN a = do { (L l av) <- a- ; return (L (noAnnSrcSpan l) av) }--pvL :: MonadP m => m (LocatedAn t a) -> m (Located a)-pvL a = do { av <- a- ; return (reLoc av) }---- | Parse a Haskell module with Haddock comments.--- This is done in two steps:------ * 'parseModuleNoHaddock' to build the AST--- * 'addHaddockToModule' to insert Haddock comments into it------ This is the only parser entry point that deals with Haddock comments.--- The other entry points ('parseDeclaration', 'parseExpression', etc) do--- not insert them into the AST.-parseModule :: P (Located HsModule)-parseModule = parseModuleNoHaddock >>= addHaddockToModule--commentsA :: (Monoid ann) => SrcSpan -> EpAnnComments -> SrcSpanAnn' (EpAnn ann)-commentsA loc cs = SrcSpanAnn (EpAnn (Anchor (rs loc) UnchangedAnchor) mempty cs) loc---- | Instead of getting the *enclosed* comments, this includes the--- *preceding* ones. It is used at the top level to get comments--- between top level declarations.-commentsPA :: (Monoid ann) => LocatedAn ann a -> P (LocatedAn ann a)-commentsPA la@(L l a) = do- cs <- getPriorCommentsFor (getLocA la)- return (L (addCommentsToSrcAnn l cs) a)--rs :: SrcSpan -> RealSrcSpan-rs (RealSrcSpan l _) = l-rs _ = panic "Parser should only have RealSrcSpan"--hsDoAnn :: Located a -> LocatedAn t b -> AnnKeywordId -> AnnList-hsDoAnn (L l _) (L ll _) kw- = AnnList (Just $ spanAsAnchor (locA ll)) Nothing Nothing [AddEpAnn kw (EpaSpan $ rs l)] []--listAsAnchor :: [LocatedAn t a] -> Anchor-listAsAnchor [] = spanAsAnchor noSrcSpan-listAsAnchor (L l _:_) = spanAsAnchor (locA l)---- ---------------------------------------addTrailingCommaFBind :: MonadP m => Fbind b -> SrcSpan -> m (Fbind b)-addTrailingCommaFBind (Left b) l = fmap Left (addTrailingCommaA b l)-addTrailingCommaFBind (Right b) l = fmap Right (addTrailingCommaA b l)--addTrailingVbarA :: MonadP m => LocatedA a -> SrcSpan -> m (LocatedA a)-addTrailingVbarA la span = addTrailingAnnA la span AddVbarAnn--addTrailingSemiA :: MonadP m => LocatedA a -> SrcSpan -> m (LocatedA a)-addTrailingSemiA la span = addTrailingAnnA la span AddSemiAnn--addTrailingCommaA :: MonadP m => LocatedA a -> SrcSpan -> m (LocatedA a)-addTrailingCommaA la span = addTrailingAnnA la span AddCommaAnn--addTrailingAnnA :: MonadP m => LocatedA a -> SrcSpan -> (EpaLocation -> TrailingAnn) -> m (LocatedA a)-addTrailingAnnA (L (SrcSpanAnn anns l) a) ss ta = do- -- cs <- getCommentsFor l- let cs = emptyComments- -- AZ:TODO: generalise updating comments into an annotation- let- anns' = if isZeroWidthSpan ss- then anns- else addTrailingAnnToA l (ta (EpaSpan $ rs ss)) cs anns- return (L (SrcSpanAnn anns' l) a)---- ---------------------------------------addTrailingVbarL :: MonadP m => LocatedL a -> SrcSpan -> m (LocatedL a)-addTrailingVbarL la span = addTrailingAnnL la (AddVbarAnn (EpaSpan $ rs span))--addTrailingCommaL :: MonadP m => LocatedL a -> SrcSpan -> m (LocatedL a)-addTrailingCommaL la span = addTrailingAnnL la (AddCommaAnn (EpaSpan $ rs span))--addTrailingAnnL :: MonadP m => LocatedL a -> TrailingAnn -> m (LocatedL a)-addTrailingAnnL (L (SrcSpanAnn anns l) a) ta = do- cs <- getCommentsFor l- let anns' = addTrailingAnnToL l ta cs anns- return (L (SrcSpanAnn anns' l) a)---- ----------------------------------------- Mostly use to add AnnComma, special case it to NOP if adding a zero-width annotation-addTrailingCommaN :: MonadP m => LocatedN a -> SrcSpan -> m (LocatedN a)-addTrailingCommaN (L (SrcSpanAnn anns l) a) span = do- -- cs <- getCommentsFor l- let cs = emptyComments- -- AZ:TODO: generalise updating comments into an annotation- let anns' = if isZeroWidthSpan span- then anns- else addTrailingCommaToN l anns (EpaSpan $ rs span)- return (L (SrcSpanAnn anns' l) a)--addTrailingCommaS :: Located StringLiteral -> EpaLocation -> Located StringLiteral-addTrailingCommaS (L l sl) span = L l (sl { sl_tc = Just (epaLocationRealSrcSpan span) })---- ---------------------------------------addTrailingDarrowC :: LocatedC a -> Located Token -> EpAnnComments -> LocatedC a-addTrailingDarrowC (L (SrcSpanAnn EpAnnNotUsed l) a) lt cs =- let- u = if (isUnicode lt) then UnicodeSyntax else NormalSyntax- in L (SrcSpanAnn (EpAnn (spanAsAnchor l) (AnnContext (Just (u,glAA lt)) [] []) cs) l) a-addTrailingDarrowC (L (SrcSpanAnn (EpAnn lr (AnnContext _ o c) csc) l) a) lt cs =- let- u = if (isUnicode lt) then UnicodeSyntax else NormalSyntax- in L (SrcSpanAnn (EpAnn lr (AnnContext (Just (u,glAA lt)) o c) (cs Semi.<> csc)) l) a---- ----------------------------------------- We need a location for the where binds, when computing the SrcSpan--- for the AST element using them. Where there is a span, we return--- it, else noLoc, which is ignored in the comb2 call.-adaptWhereBinds :: Maybe (Located (HsLocalBinds GhcPs, Maybe EpAnnComments))- -> Located (HsLocalBinds GhcPs, EpAnnComments)-adaptWhereBinds Nothing = noLoc (EmptyLocalBinds noExtField, emptyComments)-adaptWhereBinds (Just (L l (b, mc))) = L l (b, maybe emptyComments id mc)-{-# LINE 1 "templates/GenericTemplate.hs" #-}--- $Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp $---------------- Do not remove this comment. Required to fix CPP parsing when using GCC and a clang-compiled alex.-#if __GLASGOW_HASKELL__ > 706-#define LT(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.<# m)) :: Prelude.Bool)-#define GTE(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.>=# m)) :: Prelude.Bool)-#define EQ(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.==# m)) :: Prelude.Bool)-#else-#define LT(n,m) (n Happy_GHC_Exts.<# m)-#define GTE(n,m) (n Happy_GHC_Exts.>=# m)-#define EQ(n,m) (n Happy_GHC_Exts.==# m)-#endif--------------------data Happy_IntList = HappyCons Happy_GHC_Exts.Int# Happy_IntList-----------------------------------------infixr 9 `HappyStk`-data HappyStk a = HappyStk a (HappyStk a)---------------------------------------------------------------------------------- starting the parse--happyParse start_state = happyNewToken start_state notHappyAtAll notHappyAtAll---------------------------------------------------------------------------------- Accepting the parse---- If the current token is ERROR_TOK, it means we've just accepted a partial--- parse (a %partial parser). We must ignore the saved token on the top of--- the stack in this case.-happyAccept 0# tk st sts (_ `HappyStk` ans `HappyStk` _) =- happyReturn1 ans-happyAccept j tk st sts (HappyStk ans _) = - (happyTcHack j (happyTcHack st)) (happyReturn1 ans)---------------------------------------------------------------------------------- Arrays only: do the next action----happyDoAction i tk st- = {- nothing -}- case action of- 0# -> {- nothing -}- happyFail (happyExpListPerState ((Happy_GHC_Exts.I# (st)) :: Prelude.Int)) i tk st- -1# -> {- nothing -}- happyAccept i tk st- n | LT(n,(0# :: Happy_GHC_Exts.Int#)) -> {- nothing -}- (happyReduceArr Happy_Data_Array.! rule) i tk st- where rule = (Happy_GHC_Exts.I# ((Happy_GHC_Exts.negateInt# ((n Happy_GHC_Exts.+# (1# :: Happy_GHC_Exts.Int#))))))- n -> {- nothing -}- happyShift new_state i tk st- where new_state = (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#))- where off = happyAdjustOffset (indexShortOffAddr happyActOffsets st)- off_i = (off Happy_GHC_Exts.+# i)- check = if GTE(off_i,(0# :: Happy_GHC_Exts.Int#))- then EQ(indexShortOffAddr happyCheck off_i, i)- else Prelude.False- action- | check = indexShortOffAddr happyTable off_i- | Prelude.otherwise = indexShortOffAddr happyDefActions st-----indexShortOffAddr (HappyA# arr) off =- Happy_GHC_Exts.narrow16Int# i- where- i = Happy_GHC_Exts.word2Int# (Happy_GHC_Exts.or# (Happy_GHC_Exts.uncheckedShiftL# high 8#) low)- high = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr (off' Happy_GHC_Exts.+# 1#)))- low = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr off'))- off' = off Happy_GHC_Exts.*# 2#-----{-# INLINE happyLt #-}-happyLt x y = LT(x,y)---readArrayBit arr bit =- Bits.testBit (Happy_GHC_Exts.I# (indexShortOffAddr arr ((unbox_int bit) `Happy_GHC_Exts.iShiftRA#` 4#))) (bit `Prelude.mod` 16)- where unbox_int (Happy_GHC_Exts.I# x) = x-------data HappyAddr = HappyA# Happy_GHC_Exts.Addr#----------------------------------------------------------------------------------- HappyState data type (not arrays)---------------------------------------------------------------------------------------------- Shifting a token--happyShift new_state 0# tk st sts stk@(x `HappyStk` _) =- let i = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in--- trace "shifting the error token" $- happyDoAction i tk new_state (HappyCons (st) (sts)) (stk)--happyShift new_state i tk st sts stk =- happyNewToken new_state (HappyCons (st) (sts)) ((happyInTok (tk))`HappyStk`stk)---- happyReduce is specialised for the common cases.--happySpecReduce_0 i fn 0# tk st sts stk- = happyFail [] 0# tk st sts stk-happySpecReduce_0 nt fn j tk st@((action)) sts stk- = happyGoto nt j tk st (HappyCons (st) (sts)) (fn `HappyStk` stk)--happySpecReduce_1 i fn 0# tk st sts stk- = happyFail [] 0# tk st sts stk-happySpecReduce_1 nt fn j tk _ sts@((HappyCons (st@(action)) (_))) (v1`HappyStk`stk')- = let r = fn v1 in- happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))--happySpecReduce_2 i fn 0# tk st sts stk- = happyFail [] 0# tk st sts stk-happySpecReduce_2 nt fn j tk _ (HappyCons (_) (sts@((HappyCons (st@(action)) (_))))) (v1`HappyStk`v2`HappyStk`stk')- = let r = fn v1 v2 in- happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))--happySpecReduce_3 i fn 0# tk st sts stk- = happyFail [] 0# tk st sts stk-happySpecReduce_3 nt fn j tk _ (HappyCons (_) ((HappyCons (_) (sts@((HappyCons (st@(action)) (_))))))) (v1`HappyStk`v2`HappyStk`v3`HappyStk`stk')- = let r = fn v1 v2 v3 in- happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))--happyReduce k i fn 0# tk st sts stk- = happyFail [] 0# tk st sts stk-happyReduce k nt fn j tk st sts stk- = case happyDrop (k Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) sts of- sts1@((HappyCons (st1@(action)) (_))) ->- let r = fn stk in -- it doesn't hurt to always seq here...- happyDoSeq r (happyGoto nt j tk st1 sts1 r)--happyMonadReduce k nt fn 0# tk st sts stk- = happyFail [] 0# tk st sts stk-happyMonadReduce k nt fn j tk st sts stk =- case happyDrop k (HappyCons (st) (sts)) of- sts1@((HappyCons (st1@(action)) (_))) ->- let drop_stk = happyDropStk k stk in- happyThen1 (fn stk tk) (\r -> happyGoto nt j tk st1 sts1 (r `HappyStk` drop_stk))--happyMonad2Reduce k nt fn 0# tk st sts stk- = happyFail [] 0# tk st sts stk-happyMonad2Reduce k nt fn j tk st sts stk =- case happyDrop k (HappyCons (st) (sts)) of- sts1@((HappyCons (st1@(action)) (_))) ->- let drop_stk = happyDropStk k stk-- off = happyAdjustOffset (indexShortOffAddr happyGotoOffsets st1)- off_i = (off Happy_GHC_Exts.+# nt)- new_state = indexShortOffAddr happyTable off_i----- in- happyThen1 (fn stk tk) (\r -> happyNewToken new_state sts1 (r `HappyStk` drop_stk))--happyDrop 0# l = l-happyDrop n (HappyCons (_) (t)) = happyDrop (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) t--happyDropStk 0# l = l-happyDropStk n (x `HappyStk` xs) = happyDropStk (n Happy_GHC_Exts.-# (1#::Happy_GHC_Exts.Int#)) xs---------------------------------------------------------------------------------- Moving to a new state after a reduction---happyGoto nt j tk st = - {- nothing -}- happyDoAction j tk new_state- where off = happyAdjustOffset (indexShortOffAddr happyGotoOffsets st)- off_i = (off Happy_GHC_Exts.+# nt)- new_state = indexShortOffAddr happyTable off_i------------------------------------------------------------------------------------- Error recovery (ERROR_TOK is the error token)---- parse error if we are in recovery and we fail again-happyFail explist 0# tk old_st _ stk@(x `HappyStk` _) =- let i = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in--- trace "failing" $ - happyError_ explist i tk--{- We don't need state discarding for our restricted implementation of- "error". In fact, it can cause some bogus parses, so I've disabled it- for now --SDM---- discard a state-happyFail ERROR_TOK tk old_st CONS(HAPPYSTATE(action),sts) - (saved_tok `HappyStk` _ `HappyStk` stk) =--- trace ("discarding state, depth " ++ show (length stk)) $- DO_ACTION(action,ERROR_TOK,tk,sts,(saved_tok`HappyStk`stk))--}---- Enter error recovery: generate an error token,--- save the old token and carry on.-happyFail explist i tk (action) sts stk =--- trace "entering error recovery" $- happyDoAction 0# tk action sts ((Happy_GHC_Exts.unsafeCoerce# (Happy_GHC_Exts.I# (i))) `HappyStk` stk)---- Internal happy errors:--notHappyAtAll :: a-notHappyAtAll = Prelude.error "Internal Happy error\n"---------------------------------------------------------------------------------- Hack to get the typechecker to accept our action functions---happyTcHack :: Happy_GHC_Exts.Int# -> a -> a-happyTcHack x y = y-{-# INLINE happyTcHack #-}----------------------------------------------------------------------------------- Seq-ing. If the --strict flag is given, then Happy emits --- happySeq = happyDoSeq--- otherwise it emits--- happySeq = happyDontSeq--happyDoSeq, happyDontSeq :: a -> b -> b-happyDoSeq a b = a `Prelude.seq` b-happyDontSeq a b = b---------------------------------------------------------------------------------- Don't inline any functions from the template. GHC has a nasty habit--- of deciding to inline happyGoto everywhere, which increases the size of--- the generated parser quite a bit.---{-# NOINLINE happyDoAction #-}-{-# NOINLINE happyTable #-}-{-# NOINLINE happyCheck #-}-{-# NOINLINE happyActOffsets #-}-{-# NOINLINE happyGotoOffsets #-}-{-# NOINLINE happyDefActions #-}--{-# NOINLINE happyShift #-}-{-# NOINLINE happySpecReduce_0 #-}-{-# NOINLINE happySpecReduce_1 #-}-{-# NOINLINE happySpecReduce_2 #-}-{-# NOINLINE happySpecReduce_3 #-}-{-# NOINLINE happyReduce #-}-{-# NOINLINE happyMonadReduce #-}-{-# NOINLINE happyGoto #-}-{-# NOINLINE happyFail #-}---- end of Happy Template.
− ghc-lib/stage0/compiler/build/GHC/Parser/Lexer.hs
@@ -1,3800 +0,0 @@-{-# OPTIONS_GHC -fno-warn-unused-binds -fno-warn-missing-signatures #-}-{-# LANGUAGE CPP #-}-{-# LANGUAGE MagicHash #-}-{-# LINE 43 "compiler/GHC/Parser/Lexer.x" #-}-{-# LANGUAGE BangPatterns #-}-{-# LANGUAGE DeriveDataTypeable #-}-{-# LANGUAGE LambdaCase #-}-{-# LANGUAGE MultiWayIf #-}--{-# OPTIONS_GHC -funbox-strict-fields #-}-{-# OPTIONS_GHC -Wno-incomplete-uni-patterns #-}--module GHC.Parser.Lexer (- Token(..), lexer, lexerDbg,- ParserOpts(..), mkParserOpts,- PState (..), initParserState, initPragState,- P(..), ParseResult(..),- allocateComments, allocatePriorComments, allocateFinalComments,- MonadP(..),- getRealSrcLoc, getPState,- failMsgP, failLocMsgP, srcParseFail,- getErrorMessages, getMessages,- popContext, pushModuleContext, setLastToken, setSrcLoc,- activeContext, nextIsEOF,- getLexState, popLexState, pushLexState,- ExtBits(..),- xtest, xunset, xset,- lexTokenStream,- mkParensEpAnn,- getCommentsFor, getPriorCommentsFor, getFinalCommentsFor,- getEofPos,- commentToAnnotation,- HdkComment(..),- warnopt,- ) where--import GHC.Prelude---- base-import Control.Monad-import Data.Char-import Data.List (stripPrefix, isInfixOf, partition)-import Data.Maybe-import Data.Word--import GHC.Data.EnumSet as EnumSet---- ghc-boot-import qualified GHC.LanguageExtensions as LangExt---- bytestring-import Data.ByteString (ByteString)---- containers-import Data.Map (Map)-import qualified Data.Map as Map---- compiler-import GHC.Data.Bag-import GHC.Utils.Outputable-import GHC.Utils.Panic-import GHC.Data.StringBuffer-import GHC.Data.FastString-import GHC.Types.Unique.FM-import GHC.Data.Maybe-import GHC.Data.OrdList-import GHC.Utils.Misc ( readSignificandExponentPair, readHexSignificandExponentPair )--import GHC.Types.SrcLoc-import GHC.Types.SourceText-import GHC.Types.Basic ( InlineSpec(..), RuleMatchInfo(..))-import GHC.Hs.Doc--import GHC.Parser.CharClass--import GHC.Parser.Annotation-import GHC.Driver.Flags-import GHC.Parser.Errors-#if __GLASGOW_HASKELL__ >= 603-#include "ghcconfig.h"-#elif defined(__GLASGOW_HASKELL__)-#include "config.h"-#endif-#if __GLASGOW_HASKELL__ >= 503-import Data.Array-#else-import Array-#endif-#if __GLASGOW_HASKELL__ >= 503-import Data.Array.Base (unsafeAt)-import GHC.Exts-#else-import GlaExts-#endif-alex_tab_size :: Int-alex_tab_size = 8-alex_base :: AlexAddr-alex_base = AlexA#- "\x01\x00\x00\x00\x7b\x00\x00\x00\x84\x00\x00\x00\xa0\x00\x00\x00\xbc\x00\x00\x00\xc5\x00\x00\x00\xce\x00\x00\x00\xec\x00\x00\x00\x06\x01\x00\x00\x22\x01\x00\x00\x3f\x01\x00\x00\x7b\x01\x00\x00\x00\x00\x00\x00\xf8\x01\x00\x00\x32\x02\x00\x00\xac\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x03\x00\x00\x5a\x03\x00\x00\x85\xff\xff\xff\xb4\x03\x00\x00\x00\x00\x00\x00\xd9\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\xff\xff\xff\x6e\x00\x00\x00\x00\x00\x00\x00\x19\x04\x00\x00\xdb\xff\xff\xff\xe0\x00\x00\x00\x93\x04\x00\x00\xed\x04\x00\x00\x49\x05\x00\x00\xdc\xff\xff\xff\x92\xff\xff\xff\x00\x00\x00\x00\x89\x05\x00\x00\xe3\x05\x00\x00\x3d\x01\x00\x00\x86\x01\x00\x00\x59\x06\x00\x00\xe3\xff\xff\xff\x94\xff\xff\xff\x00\x00\x00\x00\xe5\xff\xff\xff\x96\xff\xff\xff\x61\x00\x00\x00\x00\x00\x00\x00\x99\x06\x00\x00\x17\x07\x00\x00\x91\x07\x00\x00\x0b\x08\x00\x00\x79\x00\x00\x00\x81\x00\x00\x00\x30\x01\x00\x00\x0a\x00\x00\x00\x0b\x00\x00\x00\x89\x08\x00\x00\x03\x09\x00\x00\x81\x09\x00\x00\xff\x09\x00\x00\x79\x0a\x00\x00\xf3\x0a\x00\x00\x6d\x0b\x00\x00\xe7\x0b\x00\x00\x1b\x04\x00\x00\x61\x0c\x00\x00\xbb\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe9\xff\xff\xff\x0d\x00\x00\x00\x00\x00\x00\x00\x15\x0d\x00\x00\xa6\xff\xff\xff\xb8\xff\xff\xff\xb3\xff\xff\xff\xae\xff\xff\xff\xbb\xff\xff\xff\x13\x00\x00\x00\x00\x00\x00\x00\xd3\x01\x00\x00\x7a\x01\x00\x00\x3f\x06\x00\x00\x87\x02\x00\x00\xf2\x06\x00\x00\xdd\x01\x00\x00\x6d\x0d\x00\x00\x6c\x07\x00\x00\x74\x00\x00\x00\xb5\xff\xff\xff\xb1\xff\xff\xff\x71\x04\x00\x00\x1c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x09\x05\x00\x00\x78\x00\x00\x00\x39\x01\x00\x00\xaa\x0d\x00\x00\xd2\x0d\x00\x00\x15\x0e\x00\x00\x3d\x0e\x00\x00\xf3\xff\xff\xff\x80\x0e\x00\x00\xa8\x0e\x00\x00\x80\x00\x00\x00\x82\x00\x00\x00\x89\x00\x00\x00\x8a\x00\x00\x00\x8c\x00\x00\x00\x8d\x00\x00\x00\x8f\x00\x00\x00\x6d\x00\x00\x00\x8b\x05\x00\x00\x00\x00\x00\x00\x09\x01\x00\x00\xe8\x0e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x00\x00\x00\x00\x7c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7d\x00\x00\x00\x7e\x00\x00\x00\x90\x00\x00\x00\x9b\x00\x00\x00\x69\x05\x00\x00\x35\x0f\x00\x00\x91\x02\x00\x00\x76\x0f\x00\x00\x1c\x03\x00\x00\xb7\x0f\x00\x00\xce\x0f\x00\x00\x67\x08\x00\x00\x0f\x10\x00\x00\x84\x04\x00\x00\x50\x10\x00\x00\xd9\x05\x00\x00\x91\x10\x00\x00\xa8\x10\x00\x00\xe0\x09\x00\x00\xfe\x04\x00\x00\x57\x0a\x00\x00\xc2\x0b\x00\x00\xd1\x0a\x00\x00\x8c\x0d\x00\x00\x75\x06\x00\x00\x4e\x0b\x00\x00\xfc\x06\x00\x00\x3f\x0c\x00\x00\xe5\x07\x00\x00\xec\x10\x00\x00\x2d\x11\x00\x00\x26\x0e\x00\x00\x07\x03\x00\x00\xcd\x00\x00\x00\xbb\x00\x00\x00\x46\x11\x00\x00\x67\x11\x00\x00\xb0\x11\x00\x00\xf1\x11\x00\x00\x91\x0e\x00\x00\xb5\x03\x00\x00\xd7\x00\x00\x00\xd1\x00\x00\x00\x0a\x12\x00\x00\x2b\x12\x00\x00\x6e\x12\x00\x00\x91\x12\x00\x00\xb4\x12\x00\x00\x10\x13\x00\x00\x38\x13\x00\x00\x9c\x00\x00\x00\x9f\x00\x00\x00\x3e\x00\x00\x00\x39\x00\x00\x00\x46\x00\x00\x00\x44\x00\x00\x00\xa1\x00\x00\x00\x59\x01\x00\x00\xf3\x12\x00\x00\x56\x0f\x00\x00\xa8\x00\x00\x00\xb1\x00\x00\x00\xb2\x00\x00\x00\x78\x13\x00\x00\xf2\x13\x00\x00\x6c\x14\x00\x00\xe6\x14\x00\x00\x60\x15\x00\x00\xda\x15\x00\x00\x54\x16\x00\x00\xce\x16\x00\x00\x48\x17\x00\x00\xc2\x17\x00\x00\xfc\x17\x00\x00\x15\x02\x00\x00\x72\x18\x00\x00\x97\x0f\x00\x00\x92\x18\x00\x00\x0c\x19\x00\x00\x86\x19\x00\x00\x00\x1a\x00\x00\x7a\x1a\x00\x00\xf4\x1a\x00\x00\x6e\x1b\x00\x00\xe8\x1b\x00\x00\x62\x1c\x00\x00\xdc\x1c\x00\x00\x56\x1d\x00\x00\xd0\x1d\x00\x00\x00\x00\x00\x00\xab\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x1e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\x00\x00\x86\x1e\x00\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7a\x1f\x00\x00\x00\x00\x00\x00\xf6\x1f\x00\x00\x00\x00\x00\x00\x72\x20\x00\x00"#--alex_table :: AlexAddr-alex_table = AlexA#- "\x00\x00\x11\x00\xc7\x00\x33\x00\x19\x00\xb9\x00\x78\x00\xf2\x00\x1f\x00\x24\x00\x77\x00\x46\x00\x78\x00\x78\x00\x78\x00\x25\x00\x2c\x00\x2d\x00\x2f\x00\x31\x00\xff\xff\xff\xff\x43\x00\x4c\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x5f\x00\x61\x00\x6c\x00\x78\x00\xb9\x00\x7a\x00\x21\x00\xb9\x00\xb9\x00\xb9\x00\x7b\x00\xed\x00\xe9\x00\xb9\x00\xb9\x00\xe5\x00\xb8\x00\xb9\x00\xb9\x00\xb4\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb5\x00\xe4\x00\xb9\x00\xb9\x00\xb9\x00\x12\x00\xb9\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xe7\x00\xb9\x00\xe6\x00\xb9\x00\xca\x00\xe3\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x1e\x00\x17\x00\xe1\x00\xb9\x00\x78\x00\x62\x00\xff\xff\xff\xff\x77\x00\x63\x00\x78\x00\x78\x00\x78\x00\x78\x00\xff\xff\xff\xff\xff\xff\x77\x00\x6c\x00\x78\x00\x78\x00\x78\x00\x1c\x00\xff\xff\xff\xff\x4b\x00\xff\xff\xff\xff\x1c\x00\xff\xff\x43\x00\x78\x00\x70\x00\x7c\x00\x5d\x00\x7e\x00\x80\x00\x81\x00\x70\x00\x48\x00\x78\x00\x78\x00\x74\x00\xbc\x00\x6b\x00\x77\x00\x49\x00\x78\x00\x78\x00\x78\x00\x69\x00\xbd\x00\xbe\x00\x6b\x00\x3b\x00\x82\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x83\x00\xba\x00\x78\x00\x78\x00\xc4\x00\xbf\x00\xbb\x00\x77\x00\x49\x00\x78\x00\x78\x00\x78\x00\x78\x00\xc4\x00\x1c\x00\x6b\x00\x77\x00\x49\x00\x78\x00\x78\x00\x78\x00\x78\x00\xc5\x00\xc6\x00\x70\x00\x77\x00\x76\x00\x78\x00\x78\x00\x78\x00\x78\x00\x00\x00\x31\x00\xbf\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x4e\x00\x78\x00\xec\x00\x00\x00\xbf\x00\x6b\x00\x1c\x00\xa9\x00\xa9\x00\x00\x00\x78\x00\x00\x00\x86\x00\x78\x00\x6b\x00\x00\x00\x70\x00\x77\x00\x75\x00\x78\x00\x78\x00\x78\x00\x8a\x00\x6b\x00\x00\x00\xa9\x00\xa9\x00\x75\x00\x1b\x00\xb1\x00\xb1\x00\x20\x00\x1c\x00\x00\x00\x00\x00\xb1\x00\xb1\x00\x00\x00\x1c\x00\x38\x00\x78\x00\x00\x00\x78\x00\x39\x00\xff\xff\x38\x00\x38\x00\x38\x00\x78\x00\x78\x00\x78\x00\x00\x00\x00\x00\x6b\x00\xaa\x00\x4a\x00\xc2\x00\xc2\x00\xc2\x00\xc2\x00\xc2\x00\xc2\x00\xc2\x00\xc2\x00\xc2\x00\xc2\x00\x38\x00\x78\x00\x00\x00\x78\x00\x00\x00\x77\x00\xaa\x00\x78\x00\x78\x00\x78\x00\xb2\x00\x00\x00\x00\x00\x37\x00\x00\x00\x38\x00\xb2\x00\x4a\x00\x00\x00\x00\x00\xff\xff\x38\x00\x38\x00\x38\x00\x1c\x00\xf1\x00\x4a\x00\x47\x00\x78\x00\xff\xff\x78\x00\x00\x00\x00\x00\x00\x00\x77\x00\x75\x00\x78\x00\x78\x00\x78\x00\x00\x00\x00\x00\x6b\x00\x38\x00\x00\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\x1c\x00\x6f\x00\xc1\x00\x78\x00\x00\x00\x00\x00\x2e\x00\x6f\x00\xc1\x00\xc1\x00\xc1\x00\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x00\x00\x00\x00\xc1\x00\x00\x00\x3c\x00\xc8\x00\xc9\x00\x00\x00\x00\x00\x78\x00\x36\x00\x00\x00\x00\x00\x77\x00\x46\x00\x78\x00\x78\x00\x78\x00\x00\x00\x00\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x29\x00\x29\x00\x29\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x00\x00\x00\x00\x00\x00\x78\x00\x28\x00\x75\x00\x23\x00\x00\x00\x00\x00\x00\x00\x00\x00\xea\x00\xe9\x00\x00\x00\x29\x00\xe5\x00\x6b\x00\x2b\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x00\x00\x6f\x00\xe4\x00\x00\x00\x00\x00\x00\x00\x75\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xe8\x00\x00\x00\xe6\x00\x00\x00\xc9\x00\xe3\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xe2\x00\x00\x00\xe1\x00\x0d\x00\x0d\x00\x0d\x00\x00\x00\x00\x00\x00\x00\x0d\x00\x00\x00\x00\x00\x00\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x00\x00\xa4\x00\x00\x00\xd2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0d\x00\xd2\x00\xd2\x00\xd2\x00\x00\x00\x00\x00\x00\x00\x0e\x00\x00\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x55\x00\x0d\x00\xf4\x00\xd2\x00\x00\x00\x32\x00\xa4\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0d\x00\x00\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf4\x00\x00\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf6\x00\xf6\x00\xf6\x00\x00\x00\x00\x00\x00\x00\xf6\x00\x00\x00\x00\x00\x00\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\x8c\x00\x8c\x00\x8c\x00\x8c\x00\x8c\x00\x8c\x00\x8c\x00\x8c\x00\x8c\x00\x8c\x00\x00\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\x00\x00\xef\x00\x00\x00\xb9\x00\xf6\x00\x00\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xb9\x00\x10\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\x00\x00\x00\x00\x00\x00\xb9\x00\xb9\x00\x00\x00\xb9\x00\xb9\x00\xb9\x00\x00\x00\xa7\x00\xa7\x00\xa7\x00\xa7\x00\xa7\x00\xa7\x00\xa7\x00\xa7\x00\x00\x00\xb9\x00\x00\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\x8e\x00\x00\x00\x8e\x00\x00\x00\x00\x00\x8c\x00\x8c\x00\x8c\x00\x8c\x00\x8c\x00\x8c\x00\x8c\x00\x8c\x00\x8c\x00\x8c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x00\xf6\x00\xf6\x00\x00\x00\x00\x00\x00\x00\xf6\x00\xb9\x00\x00\x00\xb9\x00\xef\x00\xa8\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xf6\x00\xb9\x00\x00\x00\xb9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\x00\x00\x00\x00\x00\x00\xb9\x00\xf6\x00\x00\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xb9\x00\x14\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\x00\x00\x00\x00\xb9\x00\xb9\x00\xb9\x00\x00\x00\xb9\x00\xb9\x00\xb9\x00\x00\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\x00\x00\xb9\x00\x00\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb9\x00\x00\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\x00\x00\x00\x00\xf0\x00\xb9\x00\xb9\x00\x00\x00\xb9\x00\xb9\x00\xb9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb9\x00\x16\x00\xb9\x00\xb9\x00\xb0\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\x41\x00\x41\x00\x41\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x40\x00\x40\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb9\x00\x00\x00\xb9\x00\x00\x00\x00\x00\xb9\x00\x18\x00\xb9\x00\x00\x00\x40\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x44\x00\x1c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x00\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x00\x00\x00\x00\x15\x00\x00\x00\xb9\x00\x00\x00\x00\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x1c\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x3f\x00\x3f\x00\x3f\x00\x1c\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x93\x00\x93\x00\x93\x00\x93\x00\x93\x00\x93\x00\x93\x00\x93\x00\x93\x00\x93\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x93\x00\x93\x00\x93\x00\x93\x00\x93\x00\x93\x00\x93\x00\x93\x00\x93\x00\x93\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x00\x00\xee\x00\x00\x00\xb9\x00\x3f\x00\x00\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\xb9\x00\x00\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\x00\x00\x00\x00\xeb\x00\xb9\x00\xb9\x00\x00\x00\x22\x00\xb9\x00\xb9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb9\x00\x00\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\x9a\x00\x9a\x00\x9a\x00\x9a\x00\x9a\x00\x9a\x00\x9a\x00\x9a\x00\x9a\x00\x9a\x00\x00\x00\x8c\x00\x8c\x00\x8c\x00\x8c\x00\x8c\x00\x8c\x00\x8c\x00\x8c\x00\x8c\x00\x8c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb9\x00\x00\x00\xb9\x00\xee\x00\xb9\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\x64\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\x00\x00\x00\x00\x00\x00\xb9\x00\xb9\x00\x00\x00\xb9\x00\xb9\x00\xb9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb9\x00\x00\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\x27\x00\x27\x00\x27\x00\x00\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x26\x00\x26\x00\x26\x00\x00\x00\x00\x00\x8c\x00\x8c\x00\x8c\x00\x8c\x00\x8c\x00\x8c\x00\x8c\x00\x8c\x00\x8c\x00\x8c\x00\x00\x00\x00\x00\xb9\x00\x00\x00\xb9\x00\x00\x00\x26\x00\x00\x00\x1b\x00\x00\x00\x00\x00\x1d\x00\x1c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x00\x00\x00\x00\x00\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x00\x00\x00\x00\xb9\x00\x25\x00\xb9\x00\x64\x00\x00\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x00\x00\x27\x00\x1c\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x95\x00\x00\x00\x95\x00\x1c\x00\x00\x00\x93\x00\x93\x00\x93\x00\x93\x00\x93\x00\x93\x00\x93\x00\x93\x00\x93\x00\x93\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x00\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x29\x00\x00\x00\x00\x00\x00\x00\x7f\x00\x29\x00\x29\x00\x29\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x57\x00\x29\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x32\x00\x32\x00\x32\x00\x32\x00\x55\x00\x32\x00\x9b\x00\x00\x00\x9b\x00\x00\x00\xa4\x00\x9a\x00\x9a\x00\x9a\x00\x9a\x00\x9a\x00\x9a\x00\x9a\x00\x9a\x00\x9a\x00\x9a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x32\x00\x32\x00\x35\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x33\x00\x33\x00\x33\x00\x00\x00\x00\x00\x00\x00\x33\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\x00\x00\xa0\x00\x00\x00\x00\x00\xc4\x00\x00\x00\x00\x00\x00\x00\x33\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x00\x00\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x00\x00\x00\x00\x00\x00\x33\x00\x00\x00\x00\x00\x00\x00\xab\x00\xab\x00\xab\x00\xab\x00\xab\x00\xab\x00\xab\x00\xab\x00\xab\x00\xab\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\xc4\x00\x00\x00\x00\x00\x00\x00\x33\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x33\x00\x33\x00\x33\x00\x33\x00\xce\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x00\x00\x00\x00\x00\x00\x00\x00\x34\x00\x00\x00\x33\x00\x33\x00\x33\x00\x33\x00\xce\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x32\x00\x32\x00\x32\x00\x32\x00\xa2\x00\x32\x00\xa2\x00\x00\x00\x00\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x32\x00\x32\x00\x35\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x32\x00\x42\x00\x42\x00\x42\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x3b\x00\x3b\x00\x3b\x00\x93\x00\x93\x00\x93\x00\x93\x00\x93\x00\x93\x00\x93\x00\x93\x00\x93\x00\x93\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x00\x00\x00\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3c\x00\x3d\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x00\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x3c\x00\x3d\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x3f\x00\x3f\x00\x3f\x00\x7d\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x3e\x00\x3e\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x9a\x00\x9a\x00\x9a\x00\x9a\x00\x9a\x00\x9a\x00\x9a\x00\x9a\x00\x9a\x00\x9a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x00\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x26\x00\x26\x00\x26\x00\x9a\x00\x9a\x00\x9a\x00\x9a\x00\x9a\x00\x9a\x00\x9a\x00\x9a\x00\x9a\x00\x9a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x00\x00\x00\x00\x00\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3f\x00\x00\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x3f\x00\x41\x00\x41\x00\x41\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x40\x00\x40\x00\x40\x00\x9d\x00\x9d\x00\x9d\x00\x9d\x00\x9d\x00\x9d\x00\x9d\x00\x9d\x00\x9d\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x7f\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x26\x00\x26\x00\x26\x00\x00\x00\x00\x00\x00\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x41\x00\x42\x00\x42\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\xff\xff\x9d\x00\x9d\x00\x9d\x00\x9d\x00\x9d\x00\x9d\x00\x9d\x00\x9d\x00\x9d\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x42\x00\x45\x00\x45\x00\x45\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x44\x00\x44\x00\x44\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\xa1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x00\x00\x00\x00\x00\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x00\x00\x45\x00\x00\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\xcf\x00\xd8\x00\x00\x00\xb7\x00\x45\x00\x00\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\x45\x00\xb7\x00\x00\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\x00\x00\x00\x00\x00\x00\xb7\x00\xb7\x00\x00\x00\xb7\x00\xb7\x00\xb7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x00\x00\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\x00\x00\xb7\x00\x00\x00\xb7\x00\xd8\x00\x00\x00\xd8\x00\xd8\x00\xd8\x00\xd9\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xda\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\x7d\x00\xb7\x00\x00\x00\xb7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb9\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9d\x00\x9d\x00\x9d\x00\x9d\x00\x9d\x00\x9d\x00\x9d\x00\x9d\x00\x9d\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x66\x00\xb9\x00\x59\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xa0\x00\xa0\x00\x00\x00\xb9\x00\xb9\x00\xb9\x00\x68\x00\xb9\x00\xb9\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb9\x00\x00\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x00\x00\x00\xb9\x00\x00\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\x00\x00\x00\x00\x00\x00\xb9\x00\xb9\x00\x00\x00\x68\x00\xb9\x00\xb9\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb9\x00\x00\x00\xb9\x00\x00\x00\x00\x00\x00\x00\xb9\x00\x00\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb9\x00\x00\x00\xb9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb9\x00\x00\x00\xb9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x3a\x00\x00\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x3a\x00\x3a\x00\x6a\x00\x3a\x00\x3a\x00\x00\x00\x00\x00\xff\xff\x00\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb9\x00\x3a\x00\xb9\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\xa7\x00\xa7\x00\xa7\x00\xa7\x00\xa7\x00\xa7\x00\xa7\x00\xa7\x00\x3a\x00\x00\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x3a\x00\x00\x00\x6a\x00\x3a\x00\x3a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xa8\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x66\x00\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\x6d\x00\xff\xff\xff\xff\x00\x00\x00\x00\xff\xff\x00\x00\x89\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\xff\xff\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xaf\x00\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\x00\x00\x6d\x00\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf6\x00\xf6\x00\xf6\x00\x00\x00\x00\x00\x00\x00\xf6\x00\xb0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\x00\x00\x00\x00\xff\xff\x00\x00\xff\xff\x00\x00\x00\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x00\x00\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\x00\x00\x0c\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x90\x00\xc2\x00\xc2\x00\xc2\x00\xc2\x00\xc2\x00\xc2\x00\xc2\x00\xc2\x00\xc2\x00\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x92\x00\x00\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x90\x00\xa5\x00\xa5\x00\xa5\x00\xa5\x00\xa5\x00\xa5\x00\xa5\x00\xa5\x00\xa5\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\x00\x00\xa5\x00\xa5\x00\xa5\x00\xa5\x00\xa5\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x90\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x00\x00\xa5\x00\xa5\x00\xa5\x00\xa5\x00\xa5\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x90\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x00\x00\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x90\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x92\x00\x00\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x8d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x90\x00\x94\x00\x94\x00\x94\x00\x94\x00\x94\x00\x94\x00\x94\x00\x94\x00\x94\x00\x94\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x94\x00\x94\x00\x94\x00\x94\x00\x94\x00\x94\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x99\x00\x00\x00\x94\x00\x94\x00\x94\x00\x94\x00\x94\x00\x94\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x97\x00\xad\x00\xad\x00\xad\x00\xad\x00\xad\x00\xad\x00\xad\x00\xad\x00\xad\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\xad\x00\xad\x00\xad\x00\xad\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x96\x00\x00\x00\xad\x00\xad\x00\xad\x00\xad\x00\xad\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x97\x00\x94\x00\x94\x00\x94\x00\x94\x00\x94\x00\x94\x00\x94\x00\x94\x00\x94\x00\x94\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x94\x00\x94\x00\x94\x00\x94\x00\x94\x00\x94\x00\x94\x00\x94\x00\x94\x00\x94\x00\x94\x00\x94\x00\x94\x00\x94\x00\x94\x00\x94\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x94\x00\x94\x00\x94\x00\x94\x00\x94\x00\x94\x00\x00\x00\x00\x00\x00\x00\x94\x00\x94\x00\x94\x00\x94\x00\x94\x00\x94\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x99\x00\x00\x00\x94\x00\x94\x00\x94\x00\x94\x00\x94\x00\x94\x00\x84\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x97\x00\x00\x00\x91\x00\x00\x00\xa5\x00\xa5\x00\xa5\x00\xa5\x00\xa5\x00\xa5\x00\xa5\x00\xa5\x00\xa5\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\xa5\x00\xa5\x00\xa5\x00\xa5\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x90\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8f\x00\x00\x00\xa5\x00\xa5\x00\xa5\x00\xa5\x00\xa5\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x90\x00\xa5\x00\xa5\x00\xa5\x00\xa5\x00\xa5\x00\xa5\x00\xa5\x00\xa5\x00\xa5\x00\xa5\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\xa5\x00\xa5\x00\xa5\x00\xa5\x00\xa5\x00\x5a\x00\x00\x00\xab\x00\xab\x00\xab\x00\xab\x00\xab\x00\xab\x00\xab\x00\xab\x00\xab\x00\xab\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\xa0\x00\xa6\x00\x00\x00\xa5\x00\xa5\x00\xa5\x00\xa5\x00\xa5\x00\xa5\x00\x00\x00\x5a\x00\x00\x00\xab\x00\xab\x00\xab\x00\xab\x00\xab\x00\xab\x00\xab\x00\xab\x00\xab\x00\xab\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x00\x00\xa0\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x00\x00\xaa\x00\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x00\x00\x00\x00\x00\xa8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\x00\xa6\x00\xad\x00\xad\x00\xad\x00\xad\x00\xad\x00\xad\x00\xad\x00\xad\x00\xad\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\xad\x00\xad\x00\xad\x00\xad\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x97\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x96\x00\x00\x00\xad\x00\xad\x00\xad\x00\xad\x00\xad\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x97\x00\xad\x00\xad\x00\xad\x00\xad\x00\xad\x00\xad\x00\xad\x00\xad\x00\xad\x00\xad\x00\x00\x00\x00\x00\x8b\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x00\xad\x00\xad\x00\xad\x00\xad\x00\xad\x00\x56\x00\x00\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8b\x00\xa4\x00\xae\x00\x00\x00\xad\x00\xad\x00\xad\x00\xad\x00\xad\x00\xad\x00\x00\x00\x56\x00\x00\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\xb3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xa4\x00\xa4\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x00\x00\xb2\x00\x00\x00\xb5\x00\xa4\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb6\x00\x00\x00\x00\x00\xb5\x00\xb5\x00\xb0\x00\xb5\x00\xb5\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\x00\x00\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\xb5\x00\x00\x00\x00\x00\x00\x00\xb6\x00\x00\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb7\x00\x00\x00\x00\x00\xb6\x00\xb6\x00\x00\x00\xb6\x00\xb6\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\x00\xb6\x00\xb5\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\xb6\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x00\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\x00\x00\x00\x00\x00\x00\xb7\x00\xb7\x00\x00\x00\xb7\x00\xb7\x00\xb7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\x00\x00\x00\xb5\x00\xb6\x00\xb7\x00\xb6\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\xb7\x00\x00\x00\x00\x00\x00\x00\xc1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\x00\xc1\x00\xc1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x00\x00\x00\xb6\x00\xb7\x00\x00\x00\xb7\x00\xc1\x00\xb9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc2\x00\xc2\x00\xc2\x00\xc2\x00\xc2\x00\xc2\x00\xc2\x00\xc2\x00\xc2\x00\xc2\x00\x00\x00\x00\x00\x00\x00\xb7\x00\xb9\x00\xb7\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\x00\x00\x00\x00\x00\x00\xb9\x00\xb9\x00\xb9\x00\x67\x00\xb9\x00\xb9\x00\xac\x00\xab\x00\xab\x00\xab\x00\xab\x00\xab\x00\xab\x00\xab\x00\xab\x00\xab\x00\xb9\x00\x00\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\x00\x00\xc3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb9\x00\x00\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\x00\x00\x00\x00\x00\x00\xb9\x00\xb9\x00\x00\x00\xb9\x00\xb9\x00\xb9\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb9\x00\x00\x00\xb9\x00\x9e\x00\x00\x00\x00\x00\xb9\x00\x00\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xb9\x00\xc7\x00\xc7\x00\xc7\x00\x00\x00\x00\x00\x00\x00\xc7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb9\x00\x00\x00\xb9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb9\x00\x00\x00\xb9\x00\x00\x00\x00\x00\x00\x00\x00\x00\xba\x00\x00\x00\x00\x00\x00\x00\xc7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\x00\x00\x00\x00\xb9\x00\x00\x00\xb9\x00\x00\x00\x00\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc7\x00\x00\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc7\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd1\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc8\x00\xc9\x00\xc9\x00\xc9\x00\x00\x00\x00\x00\x00\x00\xc9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc9\x00\x00\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\xc9\x00\x33\x00\x33\x00\x33\x00\x00\x00\x00\x00\x00\x00\x33\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc4\x00\x00\x00\x00\x00\x00\x00\x33\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x00\x00\x00\x00\x00\x00\x00\x00\xca\x00\x00\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x00\x00\x00\x00\x00\x00\x33\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x00\x00\x00\x00\x00\x00\x00\x33\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcb\x00\xcb\x00\xcb\x00\xcb\x00\xcb\x00\xcb\x00\xcb\x00\xcb\x00\xcb\x00\xcb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcc\x00\x00\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x00\x00\x00\x00\x00\x00\x33\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc4\x00\x00\x00\x00\x00\x00\x00\x33\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcb\x00\xcb\x00\xcb\x00\xcb\x00\xcb\x00\xcb\x00\xcb\x00\xcb\x00\xcb\x00\xcb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcc\x00\x00\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x00\x00\x00\x00\x00\x00\x33\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc4\x00\x00\x00\x00\x00\x00\x00\x33\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\xcd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x00\x33\x00\x33\x00\x33\x00\xce\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x00\x00\x00\x00\x00\x00\x00\x00\x34\x00\x00\x00\x33\x00\x33\x00\x33\x00\x33\x00\xce\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x00\x00\x00\x00\x00\x00\x33\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc4\x00\x00\x00\x00\x00\x00\x00\x33\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x00\x00\xa2\x00\x00\x00\x00\x00\xcb\x00\xcb\x00\xcb\x00\xcb\x00\xcb\x00\xcb\x00\xcb\x00\xcb\x00\xcb\x00\xcb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x00\x00\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\x33\x00\xcf\x00\xcf\x00\xcf\x00\x00\x00\x00\x00\x00\x00\xcf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc5\x00\x00\x00\x00\x00\x00\x00\xcf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcf\x00\x00\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xcf\x00\xd0\x00\xd0\x00\xd0\x00\x00\x00\x00\x00\x00\x00\xd0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd1\x00\x00\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\x00\x00\xd0\x00\xd5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd0\x00\x00\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\xd0\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\x00\x00\x00\xd5\x00\xd5\x00\xd5\x00\xd6\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd7\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd2\x00\xd2\x00\xd2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd2\x00\xd5\x00\xd5\x00\xd5\x00\x00\x00\x00\x00\x00\x00\xd5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x00\x00\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\x00\x00\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\x00\x00\x00\x00\x00\x00\xd5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\x00\x00\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xdf\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\x00\x00\x00\x00\x00\x00\xd5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\x00\x00\x00\xd5\x00\xd5\x00\xd5\x00\xdc\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd8\x00\xd8\x00\xd8\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc6\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x00\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc6\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x00\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xe0\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc6\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x00\x00\xd8\x00\xd8\x00\xd8\x00\xde\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd5\x00\xd5\x00\xd5\x00\x00\x00\x00\x00\x00\x00\xd5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\x00\x00\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\x00\x00\x00\x00\x00\x00\xd5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\x00\x00\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xdb\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd8\x00\xd8\x00\xd8\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc6\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x00\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc6\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x00\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xdd\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd5\x00\xd5\x00\xd5\x00\x00\x00\x00\x00\x00\x00\xd5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\x00\x00\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd5\x00\xd8\x00\xd8\x00\xd8\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc6\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\x00\x00\x0d\x00\xf6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\x00\x00\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\xd8\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x00\x00\x00\xf6\x00\xf6\x00\xf6\x00\x79\x00\x13\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\x0f\x00\xf6\x00\xf6\x00\xf6\x00\xf8\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\x00\x00\x1a\x00\xee\x00\xee\x00\xee\x00\x00\x00\x00\x00\x00\x00\xee\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xee\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\x00\x00\x00\x00\x00\x00\x00\x00\xee\x00\x00\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xee\x00\xef\x00\xef\x00\xef\x00\x00\x00\x00\x00\x00\x00\xef\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xef\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\x00\x00\x00\x00\x00\x00\x00\x00\xef\x00\x00\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xef\x00\xf4\x00\xf4\x00\xf4\x00\x00\x00\x00\x00\x00\x00\xf4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf4\x00\x00\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\xf4\x00\x00\x00\xf3\x00\xf6\x00\xf6\x00\xf6\x00\x00\x00\x00\x00\x00\x00\xf6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x00\x00\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\x00\x00\xf5\x00\xf6\x00\xf6\x00\xf6\x00\x00\x00\x00\x00\x00\x00\xf6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x00\x00\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\xf6\x00\x00\x00\xf7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#--alex_check :: AlexAddr-alex_check = AlexA#- "\xff\xff\x7c\x00\x01\x00\x02\x00\x7c\x00\x04\x00\x05\x00\x06\x00\x2d\x00\x2d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x7d\x00\x2d\x00\x7d\x00\x2d\x00\x7d\x00\x0a\x00\x0a\x00\x2d\x00\x0a\x00\x72\x00\x61\x00\x67\x00\x6d\x00\x61\x00\x0a\x00\x69\x00\x6e\x00\x2d\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x05\x00\x65\x00\x0a\x00\x0a\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x05\x00\x0a\x00\x0a\x00\x0a\x00\x09\x00\x2d\x00\x0b\x00\x0c\x00\x0d\x00\x24\x00\x0a\x00\x0a\x00\x21\x00\x0a\x00\x0a\x00\x2a\x00\x0a\x00\x2d\x00\x20\x00\x24\x00\x23\x00\x23\x00\x23\x00\x23\x00\x23\x00\x2a\x00\x65\x00\x20\x00\x05\x00\x2d\x00\x6e\x00\x2d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x2d\x00\x69\x00\x6c\x00\x2d\x00\x23\x00\x23\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x23\x00\x23\x00\x20\x00\x05\x00\x23\x00\x23\x00\x23\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x05\x00\x23\x00\x5e\x00\x2d\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x05\x00\x23\x00\x23\x00\x5e\x00\x09\x00\x2d\x00\x0b\x00\x0c\x00\x0d\x00\x20\x00\xff\xff\x7d\x00\x23\x00\x6c\x00\xff\xff\xff\xff\xff\xff\x70\x00\x20\x00\x23\x00\xff\xff\x23\x00\x2d\x00\x7c\x00\x30\x00\x31\x00\xff\xff\x20\x00\xff\xff\x23\x00\x05\x00\x2d\x00\xff\xff\x7c\x00\x09\x00\x7b\x00\x0b\x00\x0c\x00\x0d\x00\x23\x00\x2d\x00\xff\xff\x30\x00\x31\x00\x7b\x00\x20\x00\x30\x00\x31\x00\x23\x00\x24\x00\xff\xff\xff\xff\x30\x00\x31\x00\xff\xff\x2a\x00\x05\x00\x20\x00\xff\xff\x05\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x2d\x00\x5f\x00\x7b\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x20\x00\x05\x00\xff\xff\x20\x00\xff\xff\x09\x00\x5f\x00\x0b\x00\x0c\x00\x0d\x00\x5f\x00\xff\xff\xff\xff\x2d\x00\xff\xff\x05\x00\x5f\x00\x7b\x00\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x5e\x00\x7c\x00\x7b\x00\x7c\x00\x20\x00\x0a\x00\x05\x00\xff\xff\xff\xff\xff\xff\x09\x00\x7b\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x2d\x00\x20\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x7c\x00\x24\x00\x05\x00\x20\x00\xff\xff\xff\xff\x23\x00\x2a\x00\x0b\x00\x0c\x00\x0d\x00\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\x20\x00\xff\xff\x22\x00\x01\x00\x02\x00\xff\xff\xff\xff\x05\x00\x7b\x00\xff\xff\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\x20\x00\x5f\x00\x7b\x00\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\x29\x00\xff\xff\x20\x00\x2c\x00\x2d\x00\x23\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x7c\x00\x3b\x00\xff\xff\xff\xff\xff\xff\x7b\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\xff\xff\x7d\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x45\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x5f\x00\x01\x00\x02\x00\x20\x00\xff\xff\x22\x00\x65\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x02\x00\xff\xff\x04\x00\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x21\x00\x7c\x00\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x2b\x00\xff\xff\x2d\x00\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\x5c\x00\xff\xff\x5e\x00\x5f\x00\x5f\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x27\x00\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\x04\x00\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x21\x00\x7c\x00\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\x04\x00\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\x29\x00\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x3a\x00\x5f\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\xff\xff\x20\x00\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x5e\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\x7c\x00\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x02\x00\xff\xff\x04\x00\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\x29\x00\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\x04\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x5f\x00\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\x20\x00\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\x7c\x00\x7d\x00\x7e\x00\x5f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x01\x00\x02\x00\x03\x00\xff\xff\x5f\x00\x5e\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x2b\x00\xff\xff\x2d\x00\x7c\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x05\x00\xff\xff\xff\xff\xff\xff\x23\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\x5f\x00\x06\x00\x2b\x00\xff\xff\x2d\x00\xff\xff\x65\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x45\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\x04\x00\x2b\x00\x06\x00\x2d\x00\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x01\x00\x02\x00\x03\x00\x23\x00\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\x23\x00\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\x0a\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x01\x00\x02\x00\x03\x00\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x01\x00\x02\x00\xff\xff\x04\x00\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x23\x00\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x04\x00\xff\xff\xff\xff\xff\xff\x45\x00\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x5f\x00\x23\x00\x24\x00\x25\x00\x26\x00\x45\x00\x65\x00\xff\xff\x2a\x00\x2b\x00\x04\x00\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\x04\x00\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\x0a\x00\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\x3a\x00\x7e\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x04\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\x04\x00\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\x0a\x00\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\x3a\x00\x7e\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x45\x00\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\x42\x00\xff\xff\x65\x00\x45\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\x78\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x45\x00\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\x42\x00\xff\xff\x65\x00\x45\x00\xff\xff\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\x62\x00\xff\xff\x21\x00\x65\x00\x23\x00\x24\x00\x25\x00\x26\x00\x04\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x6f\x00\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x04\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\x3a\x00\x5e\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\x5c\x00\x3a\x00\x5e\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\x5c\x00\xff\xff\x5e\x00\x20\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\x04\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\x5f\x00\xff\xff\xff\xff\x3a\x00\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\x2b\x00\xff\xff\x2d\x00\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\x7c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#--alex_deflt :: AlexAddr-alex_deflt = AlexA#- "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x53\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x73\x00\x72\x00\x6e\x00\x72\x00\x6e\x00\xff\xff\x72\x00\x6e\x00\x6e\x00\x71\x00\x70\x00\x71\x00\x72\x00\x73\x00\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#--alex_accept = listArray (0 :: Int, 248)- [ AlexAccNone- , AlexAcc 209- , AlexAccNone- , AlexAcc 208- , AlexAcc 207- , AlexAcc 206- , AlexAcc 205- , AlexAcc 204- , AlexAcc 203- , AlexAccNone- , AlexAccNone- , AlexAccNone- , AlexAccPred 202 (ifExtension ThQuotesBit)(AlexAccPred 201 (ifExtension QqBit)(AlexAccNone))- , AlexAccNone- , AlexAccNone- , AlexAccNone- , AlexAccPred 200 (ifExtension ThQuotesBit)(AlexAccPred 199 (ifExtension QqBit)(AlexAccNone))- , AlexAccPred 198 (ifExtension ThQuotesBit)(AlexAccNone)- , AlexAccPred 197 (precededByClosingToken `alexAndPred` followedByOpeningToken)(AlexAccPred 196 (followedByOpeningToken)(AlexAccPred 195 (precededByClosingToken)(AlexAcc 194)))- , AlexAccNone- , AlexAccPred 193 (ifExtension ThQuotesBit)(AlexAccPred 192 (ifExtension QqBit)(AlexAccNone))- , AlexAccPred 191 (precededByClosingToken `alexAndPred` followedByOpeningToken)(AlexAccPred 190 (followedByOpeningToken)(AlexAccPred 189 (precededByClosingToken)(AlexAcc 188)))- , AlexAcc 187- , AlexAccPred 186 (precededByClosingToken `alexAndPred` followedByOpeningToken)(AlexAccPred 185 (followedByOpeningToken)(AlexAccPred 184 (precededByClosingToken)(AlexAcc 183)))- , AlexAcc 182- , AlexAcc 181- , AlexAcc 180- , AlexAccNone- , AlexAccPred 179 (ifExtension HaddockBit)(AlexAccNone)- , AlexAcc 178- , AlexAcc 177- , AlexAccPred 176 (isNormalComment)(AlexAccNone)- , AlexAcc 175- , AlexAccPred 174 (precededByClosingToken `alexAndPred` followedByOpeningToken)(AlexAccPred 173 (followedByOpeningToken)(AlexAccPred 172 (precededByClosingToken)(AlexAcc 171)))- , AlexAccPred 170 (precededByClosingToken `alexAndPred` followedByOpeningToken)(AlexAccPred 169 (followedByOpeningToken)(AlexAccPred 168 (precededByClosingToken)(AlexAcc 167)))- , AlexAccNone- , AlexAccNone- , AlexAcc 166- , AlexAccNone- , AlexAccPred 165 (known_pragma twoWordPrags)(AlexAccNone)- , AlexAccNone- , AlexAccNone- , AlexAccNone- , AlexAccNone- , AlexAccNone- , AlexAcc 164- , AlexAccNone- , AlexAccNone- , AlexAccNone- , AlexAcc 163- , AlexAccNone- , AlexAcc 162- , AlexAcc 161- , AlexAcc 160- , AlexAcc 159- , AlexAcc 158- , AlexAccSkip- , AlexAcc 157- , AlexAcc 156- , AlexAcc 155- , AlexAccNone- , AlexAcc 154- , AlexAccNone- , AlexAccPred 153 (known_pragma linePrags)(AlexAccPred 152 (known_pragma oneWordPrags)(AlexAccPred 151 (known_pragma ignoredPrags)(AlexAccPred 150 (known_pragma fileHeaderPrags)(AlexAccNone))))- , AlexAccNone- , AlexAccPred 149 (known_pragma linePrags)(AlexAccPred 148 (known_pragma oneWordPrags)(AlexAccPred 147 (known_pragma ignoredPrags)(AlexAccPred 146 (known_pragma fileHeaderPrags)(AlexAccNone))))- , AlexAccPred 145 (known_pragma linePrags)(AlexAcc 144)- , AlexAccPred 143 (isNormalComment)(AlexAccNone)- , AlexAccNone- , AlexAccPred 142 (known_pragma linePrags)(AlexAccNone)- , AlexAcc 141- , AlexAccPred 140 (notFollowedBySymbol)(AlexAccNone)- , AlexAccPred 139 (alexPrevCharMatches(\c -> c >= '\n' && c <= '\n' || False))(AlexAccNone)- , AlexAccSkip- , AlexAccPred 138 (notFollowedBy '-')(AlexAccNone)- , AlexAccNone- , AlexAccSkipPred (alexPrevCharMatches(\c -> c >= '\n' && c <= '\n' || False))(AlexAccNone)- , AlexAccNone- , AlexAccNone- , AlexAccNone- , AlexAccNone- , AlexAccNone- , AlexAccNone- , AlexAccNone- , AlexAccSkipPred (alexPrevCharMatches(\c -> c >= '\n' && c <= '\n' || False))(AlexAccNone)- , AlexAccNone- , AlexAccNone- , AlexAcc 137- , AlexAccNone- , AlexAccNone- , AlexAccNone- , AlexAccPred 136 (negLitPred)(AlexAccNone)- , AlexAccNone- , AlexAccPred 135 (alexPrevCharMatches(\c -> c >= '\n' && c <= '\n' || False) `alexAndPred` followedByDigit)(AlexAccNone)- , AlexAccNone- , AlexAccNone- , AlexAccNone- , AlexAccNone- , AlexAccPred 134 (alexPrevCharMatches(\c -> c >= '\n' && c <= '\n' || False))(AlexAccNone)- , AlexAccSkip- , AlexAccNone- , AlexAccPred 133 (atEOL)(AlexAcc 132)- , AlexAccPred 131 (atEOL)(AlexAccNone)- , AlexAccPred 130 (atEOL)(AlexAccPred 129 (precededByClosingToken `alexAndPred` followedByOpeningToken)(AlexAccPred 128 (followedByOpeningToken)(AlexAccPred 127 (precededByClosingToken)(AlexAcc 126))))- , AlexAccPred 125 (atEOL)(AlexAccPred 124 (precededByClosingToken `alexAndPred` followedByOpeningToken)(AlexAccPred 123 (followedByOpeningToken)(AlexAccPred 122 (precededByClosingToken)(AlexAcc 121))))- , AlexAccPred 120 (atEOL)(AlexAcc 119)- , AlexAccPred 118 (atEOL)(AlexAcc 117)- , AlexAccNone- , AlexAccPred 116 (atEOL)(AlexAccNone)- , AlexAccPred 115 (atEOL)(AlexAccNone)- , AlexAcc 114- , AlexAccPred 113 (alexNotPred (ifExtension HaddockBit))(AlexAccPred 112 (ifExtension HaddockBit)(AlexAccNone))- , AlexAccPred 111 (alexNotPred (ifExtension HaddockBit))(AlexAcc 110)- , AlexAccPred 109 (alexNotPred (ifExtension HaddockBit))(AlexAccNone)- , AlexAcc 108- , AlexAcc 107- , AlexAccPred 106 (isNormalComment)(AlexAcc 105)- , AlexAccNone- , AlexAccPred 104 (isNormalComment)(AlexAccNone)- , AlexAcc 103- , AlexAccSkip- , AlexAccNone- , AlexAcc 102- , AlexAcc 101- , AlexAccPred 100 (negHashLitPred)(AlexAccNone)- , AlexAccPred 99 (negHashLitPred)(AlexAccNone)- , AlexAccPred 98 (ifExtension MagicHashBit)(AlexAccNone)- , AlexAccPred 97 (ifExtension MagicHashBit)(AlexAccNone)- , AlexAccPred 96 (ifExtension MagicHashBit)(AlexAccNone)- , AlexAccPred 95 (ifExtension MagicHashBit)(AlexAccNone)- , AlexAccPred 94 (ifExtension MagicHashBit `alexAndPred`- ifExtension BinaryLiteralsBit)(AlexAccNone)- , AlexAccPred 93 (ifExtension MagicHashBit)(AlexAccNone)- , AlexAccPred 92 (negHashLitPred)(AlexAccNone)- , AlexAccPred 91 (negHashLitPred)(AlexAccNone)- , AlexAccPred 90 (negHashLitPred `alexAndPred`- ifExtension BinaryLiteralsBit)(AlexAccNone)- , AlexAccPred 89 (negHashLitPred)(AlexAccNone)- , AlexAccPred 88 (ifExtension MagicHashBit)(AlexAccNone)- , AlexAccPred 87 (ifExtension MagicHashBit)(AlexAccNone)- , AlexAccPred 86 (ifExtension MagicHashBit `alexAndPred`- ifExtension BinaryLiteralsBit)(AlexAccNone)- , AlexAccPred 85 (ifExtension MagicHashBit)(AlexAccNone)- , AlexAccPred 84 (ifExtension HexFloatLiteralsBit `alexAndPred`- negLitPred)(AlexAccNone)- , AlexAccPred 83 (ifExtension HexFloatLiteralsBit `alexAndPred`- negLitPred)(AlexAccNone)- , AlexAccNone- , AlexAccNone- , AlexAccNone- , AlexAccNone- , AlexAccNone- , AlexAccPred 82 (ifExtension HexFloatLiteralsBit)(AlexAccNone)- , AlexAccPred 81 (ifExtension HexFloatLiteralsBit)(AlexAccNone)- , AlexAccNone- , AlexAccNone- , AlexAccNone- , AlexAccNone- , AlexAccNone- , AlexAccPred 80 (negLitPred)(AlexAccNone)- , AlexAccNone- , AlexAccNone- , AlexAccNone- , AlexAccNone- , AlexAccNone- , AlexAccNone- , AlexAcc 79- , AlexAccNone- , AlexAccNone- , AlexAccNone- , AlexAccPred 78 (negLitPred)(AlexAccNone)- , AlexAccNone- , AlexAccPred 77 (negLitPred)(AlexAccNone)- , AlexAccNone- , AlexAccPred 76 (negLitPred `alexAndPred`- ifExtension BinaryLiteralsBit)(AlexAccNone)- , AlexAccNone- , AlexAccPred 75 (negLitPred)(AlexAccNone)- , AlexAccPred 74 (negLitPred)(AlexAccNone)- , AlexAcc 73- , AlexAccNone- , AlexAcc 72- , AlexAccNone- , AlexAccPred 71 (ifExtension BinaryLiteralsBit)(AlexAccNone)- , AlexAccNone- , AlexAcc 70- , AlexAcc 69- , AlexAcc 68- , AlexAcc 67- , AlexAcc 66- , AlexAccPred 65 (precededByClosingToken `alexAndPred` followedByOpeningToken)(AlexAccPred 64 (followedByOpeningToken)(AlexAccPred 63 (precededByClosingToken)(AlexAcc 62)))- , AlexAccPred 61 (precededByClosingToken `alexAndPred` followedByOpeningToken)(AlexAccPred 60 (followedByOpeningToken)(AlexAccPred 59 (precededByClosingToken)(AlexAcc 58)))- , AlexAccPred 57 (ifExtension MagicHashBit)(AlexAccNone)- , AlexAccPred 56 (ifExtension MagicHashBit)(AlexAccPred 55 (ifExtension MagicHashBit)(AlexAccNone))- , AlexAccNone- , AlexAccNone- , AlexAccNone- , AlexAccPred 54 (alexPrevCharMatches(\c -> c >= '\n' && c <= '\n' || False))(AlexAccNone)- , AlexAccPred 53 (ifExtension MagicHashBit)(AlexAccPred 52 (ifExtension MagicHashBit)(AlexAccNone))- , AlexAccNone- , AlexAccNone- , AlexAccNone- , AlexAccPred 51 (ifExtension MagicHashBit)(AlexAccNone)- , AlexAccPred 50 (ifExtension MagicHashBit)(AlexAccNone)- , AlexAccPred 49 (ifExtension MagicHashBit)(AlexAccNone)- , AlexAcc 48- , AlexAcc 47- , AlexAcc 46- , AlexAcc 45- , AlexAcc 44- , AlexAcc 43- , AlexAcc 42- , AlexAcc 41- , AlexAcc 40- , AlexAcc 39- , AlexAccNone- , AlexAccNone- , AlexAccNone- , AlexAccNone- , AlexAcc 38- , AlexAcc 37- , AlexAcc 36- , AlexAcc 35- , AlexAcc 34- , AlexAcc 33- , AlexAccPred 32 (ifExtension RecursiveDoBit)(AlexAcc 31)- , AlexAcc 30- , AlexAccPred 29 (ifExtension RecursiveDoBit)(AlexAcc 28)- , AlexAcc 27- , AlexAcc 26- , AlexAcc 25- , AlexAcc 24- , AlexAcc 23- , AlexAcc 22- , AlexAcc 21- , AlexAcc 20- , AlexAcc 19- , AlexAcc 18- , AlexAcc 17- , AlexAcc 16- , AlexAcc 15- , AlexAccPred 14 (ifExtension UnboxedTuplesBit `alexOrPred`- ifExtension UnboxedSumsBit)(AlexAccNone)- , AlexAccPred 13 (ifExtension UnboxedTuplesBit `alexOrPred`- ifExtension UnboxedSumsBit)(AlexAccNone)- , AlexAcc 12- , AlexAccPred 11 (ifExtension OverloadedLabelsBit)(AlexAccNone)- , AlexAccPred 10 (ifExtension IpBit)(AlexAccNone)- , AlexAccPred 9 (ifExtension ArrowsBit)(AlexAccNone)- , AlexAccPred 8 (ifExtension ArrowsBit `alexAndPred`- notFollowedBySymbol)(AlexAccNone)- , AlexAccPred 7 (ifCurrentChar '⟦' `alexAndPred`- ifExtension UnicodeSyntaxBit `alexAndPred`- ifExtension ThQuotesBit)(AlexAccPred 6 (ifCurrentChar '⟧' `alexAndPred`- ifExtension UnicodeSyntaxBit `alexAndPred`- ifExtension ThQuotesBit)(AlexAccPred 5 (ifCurrentChar '⦇' `alexAndPred`- ifExtension UnicodeSyntaxBit `alexAndPred`- ifExtension ArrowsBit)(AlexAccPred 4 (ifCurrentChar '⦈' `alexAndPred`- ifExtension UnicodeSyntaxBit `alexAndPred`- ifExtension ArrowsBit)(AlexAccNone))))- , AlexAccPred 3 (ifExtension QqBit)(AlexAccNone)- , AlexAccNone- , AlexAccPred 2 (ifExtension QqBit)(AlexAccNone)- , AlexAccNone- , AlexAccPred 1 (ifExtension ThQuotesBit)(AlexAccPred 0 (ifExtension QqBit)(AlexAccNone))- , AlexAccNone- ]--alex_actions = array (0 :: Int, 210)- [ (209,alex_action_14)- , (208,alex_action_20)- , (207,alex_action_21)- , (206,alex_action_19)- , (205,alex_action_22)- , (204,alex_action_26)- , (203,alex_action_27)- , (202,alex_action_47)- , (201,alex_action_49)- , (200,alex_action_46)- , (199,alex_action_49)- , (198,alex_action_45)- , (197,alex_action_80)- , (196,alex_action_81)- , (195,alex_action_82)- , (194,alex_action_83)- , (193,alex_action_44)- , (192,alex_action_49)- , (191,alex_action_80)- , (190,alex_action_81)- , (189,alex_action_82)- , (188,alex_action_83)- , (187,alex_action_43)- , (186,alex_action_80)- , (185,alex_action_81)- , (184,alex_action_82)- , (183,alex_action_83)- , (182,alex_action_42)- , (181,alex_action_41)- , (180,alex_action_40)- , (179,alex_action_39)- , (178,alex_action_37)- , (177,alex_action_68)- , (176,alex_action_2)- , (175,alex_action_37)- , (174,alex_action_80)- , (173,alex_action_81)- , (172,alex_action_82)- , (171,alex_action_83)- , (170,alex_action_80)- , (169,alex_action_81)- , (168,alex_action_82)- , (167,alex_action_83)- , (166,alex_action_34)- , (165,alex_action_31)- , (164,alex_action_30)- , (163,alex_action_29)- , (162,alex_action_74)- , (161,alex_action_74)- , (160,alex_action_28)- , (159,alex_action_27)- , (158,alex_action_27)- , (157,alex_action_1)- , (156,alex_action_27)- , (155,alex_action_27)- , (154,alex_action_25)- , (153,alex_action_24)- , (152,alex_action_32)- , (151,alex_action_33)- , (150,alex_action_36)- , (149,alex_action_24)- , (148,alex_action_32)- , (147,alex_action_33)- , (146,alex_action_35)- , (145,alex_action_24)- , (144,alex_action_27)- , (143,alex_action_2)- , (142,alex_action_24)- , (141,alex_action_23)- , (140,alex_action_18)- , (139,alex_action_17)- , (138,alex_action_15)- , (137,alex_action_95)- , (136,alex_action_96)- , (135,alex_action_11)- , (134,alex_action_10)- , (133,alex_action_8)- , (132,alex_action_27)- , (131,alex_action_8)- , (130,alex_action_7)- , (129,alex_action_80)- , (128,alex_action_81)- , (127,alex_action_82)- , (126,alex_action_83)- , (125,alex_action_7)- , (124,alex_action_80)- , (123,alex_action_81)- , (122,alex_action_82)- , (121,alex_action_83)- , (120,alex_action_7)- , (119,alex_action_27)- , (118,alex_action_7)- , (117,alex_action_27)- , (116,alex_action_7)- , (115,alex_action_7)- , (114,alex_action_6)- , (113,alex_action_5)- , (112,alex_action_38)- , (111,alex_action_5)- , (110,alex_action_27)- , (109,alex_action_5)- , (108,alex_action_4)- , (107,alex_action_3)- , (106,alex_action_2)- , (105,alex_action_27)- , (104,alex_action_2)- , (103,alex_action_1)- , (102,alex_action_116)- , (101,alex_action_115)- , (100,alex_action_114)- , (99,alex_action_113)- , (98,alex_action_112)- , (97,alex_action_111)- , (96,alex_action_110)- , (95,alex_action_109)- , (94,alex_action_108)- , (93,alex_action_107)- , (92,alex_action_106)- , (91,alex_action_105)- , (90,alex_action_104)- , (89,alex_action_103)- , (88,alex_action_102)- , (87,alex_action_101)- , (86,alex_action_100)- , (85,alex_action_99)- , (84,alex_action_98)- , (83,alex_action_98)- , (82,alex_action_97)- , (81,alex_action_97)- , (80,alex_action_96)- , (79,alex_action_95)- , (78,alex_action_94)- , (77,alex_action_93)- , (76,alex_action_92)- , (75,alex_action_91)- , (74,alex_action_91)- , (73,alex_action_90)- , (72,alex_action_89)- , (71,alex_action_88)- , (70,alex_action_87)- , (69,alex_action_87)- , (68,alex_action_86)- , (67,alex_action_85)- , (66,alex_action_84)- , (65,alex_action_80)- , (64,alex_action_81)- , (63,alex_action_82)- , (62,alex_action_83)- , (61,alex_action_80)- , (60,alex_action_81)- , (59,alex_action_82)- , (58,alex_action_83)- , (57,alex_action_79)- , (56,alex_action_78)- , (55,alex_action_112)- , (54,alex_action_17)- , (53,alex_action_78)- , (52,alex_action_111)- , (51,alex_action_78)- , (50,alex_action_77)- , (49,alex_action_76)- , (48,alex_action_75)- , (47,alex_action_75)- , (46,alex_action_74)- , (45,alex_action_74)- , (44,alex_action_74)- , (43,alex_action_74)- , (42,alex_action_74)- , (41,alex_action_74)- , (40,alex_action_73)- , (39,alex_action_73)- , (38,alex_action_72)- , (37,alex_action_72)- , (36,alex_action_72)- , (35,alex_action_72)- , (34,alex_action_72)- , (33,alex_action_72)- , (32,alex_action_71)- , (31,alex_action_72)- , (30,alex_action_72)- , (29,alex_action_71)- , (28,alex_action_72)- , (27,alex_action_72)- , (26,alex_action_70)- , (25,alex_action_70)- , (24,alex_action_69)- , (23,alex_action_68)- , (22,alex_action_67)- , (21,alex_action_66)- , (20,alex_action_65)- , (19,alex_action_64)- , (18,alex_action_63)- , (17,alex_action_63)- , (16,alex_action_62)- , (15,alex_action_61)- , (14,alex_action_60)- , (13,alex_action_59)- , (12,alex_action_61)- , (11,alex_action_58)- , (10,alex_action_57)- , (9,alex_action_54)- , (8,alex_action_53)- , (7,alex_action_51)- , (6,alex_action_52)- , (5,alex_action_55)- , (4,alex_action_56)- , (3,alex_action_50)- , (2,alex_action_49)- , (1,alex_action_48)- , (0,alex_action_49)- ]--{-# LINE 686 "compiler/GHC/Parser/Lexer.x" #-}--- -------------------------------------------------------------------------------- The token type--data Token- = ITas -- Haskell keywords- | ITcase- | ITclass- | ITdata- | ITdefault- | ITderiving- | ITdo (Maybe FastString)- | ITelse- | IThiding- | ITforeign- | ITif- | ITimport- | ITin- | ITinfix- | ITinfixl- | ITinfixr- | ITinstance- | ITlet- | ITmodule- | ITnewtype- | ITof- | ITqualified- | ITthen- | ITtype- | ITwhere-- | ITforall IsUnicodeSyntax -- GHC extension keywords- | ITexport- | ITlabel- | ITdynamic- | ITsafe- | ITinterruptible- | ITunsafe- | ITstdcallconv- | ITccallconv- | ITcapiconv- | ITprimcallconv- | ITjavascriptcallconv- | ITmdo (Maybe FastString)- | ITfamily- | ITrole- | ITgroup- | ITby- | ITusing- | ITpattern- | ITstatic- | ITstock- | ITanyclass- | ITvia-- -- Backpack tokens- | ITunit- | ITsignature- | ITdependency- | ITrequires-- -- Pragmas, see note [Pragma source text] in "GHC.Types.Basic"- | ITinline_prag SourceText InlineSpec RuleMatchInfo- | ITspec_prag SourceText -- SPECIALISE- | ITspec_inline_prag SourceText Bool -- SPECIALISE INLINE (or NOINLINE)- | ITsource_prag SourceText- | ITrules_prag SourceText- | ITwarning_prag SourceText- | ITdeprecated_prag SourceText- | ITline_prag SourceText -- not usually produced, see 'UsePosPragsBit'- | ITcolumn_prag SourceText -- not usually produced, see 'UsePosPragsBit'- | ITscc_prag SourceText- | ITunpack_prag SourceText- | ITnounpack_prag SourceText- | ITann_prag SourceText- | ITcomplete_prag SourceText- | ITclose_prag- | IToptions_prag String- | ITinclude_prag String- | ITlanguage_prag- | ITminimal_prag SourceText- | IToverlappable_prag SourceText -- instance overlap mode- | IToverlapping_prag SourceText -- instance overlap mode- | IToverlaps_prag SourceText -- instance overlap mode- | ITincoherent_prag SourceText -- instance overlap mode- | ITctype SourceText- | ITcomment_line_prag -- See Note [Nested comment line pragmas]-- | ITdotdot -- reserved symbols- | ITcolon- | ITdcolon IsUnicodeSyntax- | ITequal- | ITlam- | ITlcase- | ITvbar- | ITlarrow IsUnicodeSyntax- | ITrarrow IsUnicodeSyntax- | ITdarrow IsUnicodeSyntax- | ITlolly -- The (⊸) arrow (for LinearTypes)- | ITminus -- See Note [Minus tokens]- | ITprefixminus -- See Note [Minus tokens]- | ITbang -- Prefix (!) only, e.g. f !x = rhs- | ITtilde -- Prefix (~) only, e.g. f ~x = rhs- | ITat -- Tight infix (@) only, e.g. f x@pat = rhs- | ITtypeApp -- Prefix (@) only, e.g. f @t- | ITpercent -- Prefix (%) only, e.g. a %1 -> b- | ITstar IsUnicodeSyntax- | ITdot- | ITproj Bool -- Extension: OverloadedRecordDotBit-- | ITbiglam -- GHC-extension symbols-- | ITocurly -- special symbols- | ITccurly- | ITvocurly- | ITvccurly- | ITobrack- | ITopabrack -- [:, for parallel arrays with -XParallelArrays- | ITcpabrack -- :], for parallel arrays with -XParallelArrays- | ITcbrack- | IToparen- | ITcparen- | IToubxparen- | ITcubxparen- | ITsemi- | ITcomma- | ITunderscore- | ITbackquote- | ITsimpleQuote -- '-- | ITvarid FastString -- identifiers- | ITconid FastString- | ITvarsym FastString- | ITconsym FastString- | ITqvarid (FastString,FastString)- | ITqconid (FastString,FastString)- | ITqvarsym (FastString,FastString)- | ITqconsym (FastString,FastString)-- | ITdupipvarid FastString -- GHC extension: implicit param: ?x- | ITlabelvarid FastString -- Overloaded label: #x-- | ITchar SourceText Char -- Note [Literal source text] in "GHC.Types.Basic"- | ITstring SourceText FastString -- Note [Literal source text] in "GHC.Types.Basic"- | ITinteger IntegralLit -- Note [Literal source text] in "GHC.Types.Basic"- | ITrational FractionalLit-- | ITprimchar SourceText Char -- Note [Literal source text] in "GHC.Types.Basic"- | ITprimstring SourceText ByteString -- Note [Literal source text] in "GHC.Types.Basic"- | ITprimint SourceText Integer -- Note [Literal source text] in "GHC.Types.Basic"- | ITprimword SourceText Integer -- Note [Literal source text] in "GHC.Types.Basic"- | ITprimfloat FractionalLit- | ITprimdouble FractionalLit-- -- Template Haskell extension tokens- | ITopenExpQuote HasE IsUnicodeSyntax -- [| or [e|- | ITopenPatQuote -- [p|- | ITopenDecQuote -- [d|- | ITopenTypQuote -- [t|- | ITcloseQuote IsUnicodeSyntax -- |]- | ITopenTExpQuote HasE -- [|| or [e||- | ITcloseTExpQuote -- ||]- | ITdollar -- prefix $- | ITdollardollar -- prefix $$- | ITtyQuote -- ''- | ITquasiQuote (FastString,FastString,PsSpan)- -- ITquasiQuote(quoter, quote, loc)- -- represents a quasi-quote of the form- -- [quoter| quote |]- | ITqQuasiQuote (FastString,FastString,FastString,PsSpan)- -- ITqQuasiQuote(Qual, quoter, quote, loc)- -- represents a qualified quasi-quote of the form- -- [Qual.quoter| quote |]-- -- Arrow notation extension- | ITproc- | ITrec- | IToparenbar IsUnicodeSyntax -- ^ @(|@- | ITcparenbar IsUnicodeSyntax -- ^ @|)@- | ITlarrowtail IsUnicodeSyntax -- ^ @-<@- | ITrarrowtail IsUnicodeSyntax -- ^ @>-@- | ITLarrowtail IsUnicodeSyntax -- ^ @-<<@- | ITRarrowtail IsUnicodeSyntax -- ^ @>>-@-- | ITunknown String -- ^ Used when the lexer can't make sense of it- | ITeof -- ^ end of file token-- -- Documentation annotations. See Note [PsSpan in Comments]- | ITdocCommentNext String PsSpan -- ^ something beginning @-- |@- | ITdocCommentPrev String PsSpan -- ^ something beginning @-- ^@- | ITdocCommentNamed String PsSpan -- ^ something beginning @-- $@- | ITdocSection Int String PsSpan -- ^ a section heading- | ITdocOptions String PsSpan -- ^ doc options (prune, ignore-exports, etc)- | ITlineComment String PsSpan -- ^ comment starting by "--"- | ITblockComment String PsSpan -- ^ comment in {- -}-- deriving Show--instance Outputable Token where- ppr x = text (show x)--{- Note [PsSpan in Comments]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~-When using the Api Annotations to exact print a modified AST, managing-the space before a comment is important. The PsSpan in the comment-token allows this to happen.--We also need to track the space before the end of file. The normal-mechanism of using the previous token does not work, as the ITeof is-synthesised to come at the same location of the last token, and the-normal previous token updating has by then updated the required-location.--We track this using a 2-back location, prev_loc2. This adds extra-processing to every single token, which is a performance hit for-something needed only at the end of the file. This needs-improving. Perhaps a backward scan on eof?--}--{- Note [Minus tokens]-~~~~~~~~~~~~~~~~~~~~~~-A minus sign can be used in prefix form (-x) and infix form (a - b).--When LexicalNegation is on:- * ITprefixminus represents the prefix form- * ITvarsym "-" represents the infix form- * ITminus is not used--When LexicalNegation is off:- * ITminus represents all forms- * ITprefixminus is not used- * ITvarsym "-" is not used--}--{- Note [Why not LexicalNegationBit]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-One might wonder why we define NoLexicalNegationBit instead of-LexicalNegationBit. The problem lies in the following line in reservedSymsFM:-- ,("-", ITminus, NormalSyntax, xbit NoLexicalNegationBit)--We want to generate ITminus only when LexicalNegation is off. How would one-do it if we had LexicalNegationBit? I (int-index) tried to use bitwise-complement:-- ,("-", ITminus, NormalSyntax, complement (xbit LexicalNegationBit))--This did not work, so I opted for NoLexicalNegationBit instead.--}----- the bitmap provided as the third component indicates whether the--- corresponding extension keyword is valid under the extension options--- provided to the compiler; if the extension corresponding to *any* of the--- bits set in the bitmap is enabled, the keyword is valid (this setup--- facilitates using a keyword in two different extensions that can be--- activated independently)----reservedWordsFM :: UniqFM FastString (Token, ExtsBitmap)-reservedWordsFM = listToUFM $- map (\(x, y, z) -> (mkFastString x, (y, z)))- [( "_", ITunderscore, 0 ),- ( "as", ITas, 0 ),- ( "case", ITcase, 0 ),- ( "class", ITclass, 0 ),- ( "data", ITdata, 0 ),- ( "default", ITdefault, 0 ),- ( "deriving", ITderiving, 0 ),- ( "do", ITdo Nothing, 0 ),- ( "else", ITelse, 0 ),- ( "hiding", IThiding, 0 ),- ( "if", ITif, 0 ),- ( "import", ITimport, 0 ),- ( "in", ITin, 0 ),- ( "infix", ITinfix, 0 ),- ( "infixl", ITinfixl, 0 ),- ( "infixr", ITinfixr, 0 ),- ( "instance", ITinstance, 0 ),- ( "let", ITlet, 0 ),- ( "module", ITmodule, 0 ),- ( "newtype", ITnewtype, 0 ),- ( "of", ITof, 0 ),- ( "qualified", ITqualified, 0 ),- ( "then", ITthen, 0 ),- ( "type", ITtype, 0 ),- ( "where", ITwhere, 0 ),-- ( "forall", ITforall NormalSyntax, 0),- ( "mdo", ITmdo Nothing, xbit RecursiveDoBit),- -- See Note [Lexing type pseudo-keywords]- ( "family", ITfamily, 0 ),- ( "role", ITrole, 0 ),- ( "pattern", ITpattern, xbit PatternSynonymsBit),- ( "static", ITstatic, xbit StaticPointersBit ),- ( "stock", ITstock, 0 ),- ( "anyclass", ITanyclass, 0 ),- ( "via", ITvia, 0 ),- ( "group", ITgroup, xbit TransformComprehensionsBit),- ( "by", ITby, xbit TransformComprehensionsBit),- ( "using", ITusing, xbit TransformComprehensionsBit),-- ( "foreign", ITforeign, xbit FfiBit),- ( "export", ITexport, xbit FfiBit),- ( "label", ITlabel, xbit FfiBit),- ( "dynamic", ITdynamic, xbit FfiBit),- ( "safe", ITsafe, xbit FfiBit .|.- xbit SafeHaskellBit),- ( "interruptible", ITinterruptible, xbit InterruptibleFfiBit),- ( "unsafe", ITunsafe, xbit FfiBit),- ( "stdcall", ITstdcallconv, xbit FfiBit),- ( "ccall", ITccallconv, xbit FfiBit),- ( "capi", ITcapiconv, xbit CApiFfiBit),- ( "prim", ITprimcallconv, xbit FfiBit),- ( "javascript", ITjavascriptcallconv, xbit FfiBit),-- ( "unit", ITunit, 0 ),- ( "dependency", ITdependency, 0 ),- ( "signature", ITsignature, 0 ),-- ( "rec", ITrec, xbit ArrowsBit .|.- xbit RecursiveDoBit),- ( "proc", ITproc, xbit ArrowsBit)- ]--{------------------------------------Note [Lexing type pseudo-keywords]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~--One might think that we wish to treat 'family' and 'role' as regular old-varids whenever -XTypeFamilies and -XRoleAnnotations are off, respectively.-But, there is no need to do so. These pseudo-keywords are not stolen syntax:-they are only used after the keyword 'type' at the top-level, where varids are-not allowed. Furthermore, checks further downstream (GHC.Tc.TyCl) ensure that-type families and role annotations are never declared without their extensions-on. In fact, by unconditionally lexing these pseudo-keywords as special, we-can get better error messages.--Also, note that these are included in the `varid` production in the parser ---a key detail to make all this work.--------------------------------------}--reservedSymsFM :: UniqFM FastString (Token, IsUnicodeSyntax, ExtsBitmap)-reservedSymsFM = listToUFM $- map (\ (x,w,y,z) -> (mkFastString x,(w,y,z)))- [ ("..", ITdotdot, NormalSyntax, 0 )- -- (:) is a reserved op, meaning only list cons- ,(":", ITcolon, NormalSyntax, 0 )- ,("::", ITdcolon NormalSyntax, NormalSyntax, 0 )- ,("=", ITequal, NormalSyntax, 0 )- ,("\\", ITlam, NormalSyntax, 0 )- ,("|", ITvbar, NormalSyntax, 0 )- ,("<-", ITlarrow NormalSyntax, NormalSyntax, 0 )- ,("->", ITrarrow NormalSyntax, NormalSyntax, 0 )- ,("=>", ITdarrow NormalSyntax, NormalSyntax, 0 )- ,("-", ITminus, NormalSyntax, xbit NoLexicalNegationBit)-- ,("*", ITstar NormalSyntax, NormalSyntax, xbit StarIsTypeBit)-- -- For 'forall a . t'- ,(".", ITdot, NormalSyntax, 0 )-- ,("-<", ITlarrowtail NormalSyntax, NormalSyntax, xbit ArrowsBit)- ,(">-", ITrarrowtail NormalSyntax, NormalSyntax, xbit ArrowsBit)- ,("-<<", ITLarrowtail NormalSyntax, NormalSyntax, xbit ArrowsBit)- ,(">>-", ITRarrowtail NormalSyntax, NormalSyntax, xbit ArrowsBit)-- ,("∷", ITdcolon UnicodeSyntax, UnicodeSyntax, 0 )- ,("⇒", ITdarrow UnicodeSyntax, UnicodeSyntax, 0 )- ,("∀", ITforall UnicodeSyntax, UnicodeSyntax, 0 )- ,("→", ITrarrow UnicodeSyntax, UnicodeSyntax, 0 )- ,("←", ITlarrow UnicodeSyntax, UnicodeSyntax, 0 )-- ,("⊸", ITlolly, UnicodeSyntax, 0)-- ,("⤙", ITlarrowtail UnicodeSyntax, UnicodeSyntax, xbit ArrowsBit)- ,("⤚", ITrarrowtail UnicodeSyntax, UnicodeSyntax, xbit ArrowsBit)- ,("⤛", ITLarrowtail UnicodeSyntax, UnicodeSyntax, xbit ArrowsBit)- ,("⤜", ITRarrowtail UnicodeSyntax, UnicodeSyntax, xbit ArrowsBit)-- ,("★", ITstar UnicodeSyntax, UnicodeSyntax, xbit StarIsTypeBit)-- -- ToDo: ideally, → and ∷ should be "specials", so that they cannot- -- form part of a large operator. This would let us have a better- -- syntax for kinds: ɑ∷*→* would be a legal kind signature. (maybe).- ]---- -------------------------------------------------------------------------------- Lexer actions--type Action = PsSpan -> StringBuffer -> Int -> P (PsLocated Token)--special :: Token -> Action-special tok span _buf _len = return (L span tok)--token, layout_token :: Token -> Action-token t span _buf _len = return (L span t)-layout_token t span _buf _len = pushLexState layout >> return (L span t)--idtoken :: (StringBuffer -> Int -> Token) -> Action-idtoken f span buf len = return (L span $! (f buf len))--qdo_token :: (Maybe FastString -> Token) -> Action-qdo_token con span buf len = do- maybe_layout token- return (L span $! token)- where- !token = con $! Just $! fst $! splitQualName buf len False--skip_one_varid :: (FastString -> Token) -> Action-skip_one_varid f span buf len- = return (L span $! f (lexemeToFastString (stepOn buf) (len-1)))--skip_two_varid :: (FastString -> Token) -> Action-skip_two_varid f span buf len- = return (L span $! f (lexemeToFastString (stepOn (stepOn buf)) (len-2)))--strtoken :: (String -> Token) -> Action-strtoken f span buf len =- return (L span $! (f $! lexemeToString buf len))--begin :: Int -> Action-begin code _span _str _len = do pushLexState code; lexToken--pop :: Action-pop _span _buf _len = do _ <- popLexState- lexToken--- See Note [Nested comment line pragmas]-failLinePrag1 :: Action-failLinePrag1 span _buf _len = do- b <- getBit InNestedCommentBit- if b then return (L span ITcomment_line_prag)- else lexError LexErrorInPragma---- See Note [Nested comment line pragmas]-popLinePrag1 :: Action-popLinePrag1 span _buf _len = do- b <- getBit InNestedCommentBit- if b then return (L span ITcomment_line_prag) else do- _ <- popLexState- lexToken--hopefully_open_brace :: Action-hopefully_open_brace span buf len- = do relaxed <- getBit RelaxedLayoutBit- ctx <- getContext- (AI l _) <- getInput- let offset = srcLocCol (psRealLoc l)- isOK = relaxed ||- case ctx of- Layout prev_off _ : _ -> prev_off < offset- _ -> True- if isOK then pop_and open_brace span buf len- else addFatalError $ PsError PsErrMissingBlock [] (mkSrcSpanPs span)--pop_and :: Action -> Action-pop_and act span buf len = do _ <- popLexState- act span buf len---- See Note [Whitespace-sensitive operator parsing]-followedByOpeningToken :: AlexAccPred ExtsBitmap-followedByOpeningToken _ _ _ (AI _ buf)- | atEnd buf = False- | otherwise =- case nextChar buf of- ('{', buf') -> nextCharIsNot buf' (== '-')- ('(', _) -> True- ('[', _) -> True- ('\"', _) -> True- ('\'', _) -> True- ('_', _) -> True- ('⟦', _) -> True- ('⦇', _) -> True- (c, _) -> isAlphaNum c---- See Note [Whitespace-sensitive operator parsing]-precededByClosingToken :: AlexAccPred ExtsBitmap-precededByClosingToken _ (AI _ buf) _ _ =- case prevChar buf '\n' of- '}' -> decodePrevNChars 1 buf /= "-"- ')' -> True- ']' -> True- '\"' -> True- '\'' -> True- '_' -> True- '⟧' -> True- '⦈' -> True- c -> isAlphaNum c--{-# INLINE nextCharIs #-}-nextCharIs :: StringBuffer -> (Char -> Bool) -> Bool-nextCharIs buf p = not (atEnd buf) && p (currentChar buf)--{-# INLINE nextCharIsNot #-}-nextCharIsNot :: StringBuffer -> (Char -> Bool) -> Bool-nextCharIsNot buf p = not (nextCharIs buf p)--notFollowedBy :: Char -> AlexAccPred ExtsBitmap-notFollowedBy char _ _ _ (AI _ buf)- = nextCharIsNot buf (== char)--notFollowedBySymbol :: AlexAccPred ExtsBitmap-notFollowedBySymbol _ _ _ (AI _ buf)- = nextCharIsNot buf (`elem` "!#$%&*+./<=>?@\\^|-~")--followedByDigit :: AlexAccPred ExtsBitmap-followedByDigit _ _ _ (AI _ buf)- = afterOptionalSpace buf (\b -> nextCharIs b (`elem` ['0'..'9']))--ifCurrentChar :: Char -> AlexAccPred ExtsBitmap-ifCurrentChar char _ (AI _ buf) _ _- = nextCharIs buf (== char)---- We must reject doc comments as being ordinary comments everywhere.--- In some cases the doc comment will be selected as the lexeme due to--- maximal munch, but not always, because the nested comment rule is--- valid in all states, but the doc-comment rules are only valid in--- the non-layout states.-isNormalComment :: AlexAccPred ExtsBitmap-isNormalComment bits _ _ (AI _ buf)- | HaddockBit `xtest` bits = notFollowedByDocOrPragma- | otherwise = nextCharIsNot buf (== '#')- where- notFollowedByDocOrPragma- = afterOptionalSpace buf (\b -> nextCharIsNot b (`elem` "|^*$#"))--afterOptionalSpace :: StringBuffer -> (StringBuffer -> Bool) -> Bool-afterOptionalSpace buf p- = if nextCharIs buf (== ' ')- then p (snd (nextChar buf))- else p buf--atEOL :: AlexAccPred ExtsBitmap-atEOL _ _ _ (AI _ buf) = atEnd buf || currentChar buf == '\n'---- Check if we should parse a negative literal (e.g. -123) as a single token.-negLitPred :: AlexAccPred ExtsBitmap-negLitPred =- prefix_minus `alexAndPred`- (negative_literals `alexOrPred` lexical_negation)- where- negative_literals = ifExtension NegativeLiteralsBit-- lexical_negation =- -- See Note [Why not LexicalNegationBit]- alexNotPred (ifExtension NoLexicalNegationBit)-- prefix_minus =- -- Note [prefix_minus in negLitPred and negHashLitPred]- alexNotPred precededByClosingToken---- Check if we should parse an unboxed negative literal (e.g. -123#) as a single token.-negHashLitPred :: AlexAccPred ExtsBitmap-negHashLitPred = prefix_minus `alexAndPred` magic_hash- where- magic_hash = ifExtension MagicHashBit- prefix_minus =- -- Note [prefix_minus in negLitPred and negHashLitPred]- alexNotPred precededByClosingToken--{- Note [prefix_minus in negLitPred and negHashLitPred]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-We want to parse -1 as a single token, but x-1 as three tokens.-So in negLitPred (and negHashLitPred) we require that we have a prefix-occurrence of the minus sign. See Note [Whitespace-sensitive operator parsing]-for a detailed definition of a prefix occurrence.--The condition for a prefix occurrence of an operator is:-- not precededByClosingToken && followedByOpeningToken--but we don't check followedByOpeningToken when parsing a negative literal.-It holds simply because we immediately lex a literal after the minus.--}--ifExtension :: ExtBits -> AlexAccPred ExtsBitmap-ifExtension extBits bits _ _ _ = extBits `xtest` bits--alexNotPred p userState in1 len in2- = not (p userState in1 len in2)--alexOrPred p1 p2 userState in1 len in2- = p1 userState in1 len in2 || p2 userState in1 len in2--multiline_doc_comment :: Action-multiline_doc_comment span buf _len = withLexedDocType (worker "")- where- worker commentAcc input docType checkNextLine = case alexGetChar' input of- Just ('\n', input')- | checkNextLine -> case checkIfCommentLine input' of- Just input -> worker ('\n':commentAcc) input docType checkNextLine- Nothing -> docCommentEnd input commentAcc docType buf span- | otherwise -> docCommentEnd input commentAcc docType buf span- Just (c, input) -> worker (c:commentAcc) input docType checkNextLine- Nothing -> docCommentEnd input commentAcc docType buf span-- -- Check if the next line of input belongs to this doc comment as well.- -- A doc comment continues onto the next line when the following- -- conditions are met:- -- * The line starts with "--"- -- * The line doesn't start with "---".- -- * The line doesn't start with "-- $", because that would be the- -- start of a /new/ named haddock chunk (#10398).- checkIfCommentLine :: AlexInput -> Maybe AlexInput- checkIfCommentLine input = check (dropNonNewlineSpace input)- where- check input = do- ('-', input) <- alexGetChar' input- ('-', input) <- alexGetChar' input- (c, after_c) <- alexGetChar' input- case c of- '-' -> Nothing- ' ' -> case alexGetChar' after_c of- Just ('$', _) -> Nothing- _ -> Just input- _ -> Just input-- dropNonNewlineSpace input = case alexGetChar' input of- Just (c, input')- | isSpace c && c /= '\n' -> dropNonNewlineSpace input'- | otherwise -> input- Nothing -> input--lineCommentToken :: Action-lineCommentToken span buf len = do- b <- getBit RawTokenStreamBit- if b then do- lt <- getLastLocComment- strtoken (\s -> ITlineComment s lt) span buf len- else lexToken---{-- nested comments require traversing by hand, they can't be parsed- using regular expressions.--}-nested_comment :: P (PsLocated Token) -> Action-nested_comment cont span buf len = do- input <- getInput- go (reverse $ lexemeToString buf len) (1::Int) input- where- go commentAcc 0 input = do- l <- getLastLocComment- let finalizeComment str = (Nothing, ITblockComment str l)- commentEnd cont input commentAcc finalizeComment buf span- go commentAcc n input = case alexGetChar' input of- Nothing -> errBrace input (psRealSpan span)- Just ('-',input) -> case alexGetChar' input of- Nothing -> errBrace input (psRealSpan span)- Just ('\125',input) -> go ('\125':'-':commentAcc) (n-1) input -- '}'- Just (_,_) -> go ('-':commentAcc) n input- Just ('\123',input) -> case alexGetChar' input of -- '{' char- Nothing -> errBrace input (psRealSpan span)- Just ('-',input) -> go ('-':'\123':commentAcc) (n+1) input- Just (_,_) -> go ('\123':commentAcc) n input- -- See Note [Nested comment line pragmas]- Just ('\n',input) -> case alexGetChar' input of- Nothing -> errBrace input (psRealSpan span)- Just ('#',_) -> do (parsedAcc,input) <- parseNestedPragma input- go (parsedAcc ++ '\n':commentAcc) n input- Just (_,_) -> go ('\n':commentAcc) n input- Just (c,input) -> go (c:commentAcc) n input--nested_doc_comment :: Action-nested_doc_comment span buf _len = withLexedDocType (go "")- where- go commentAcc input docType _ = case alexGetChar' input of- Nothing -> errBrace input (psRealSpan span)- Just ('-',input) -> case alexGetChar' input of- Nothing -> errBrace input (psRealSpan span)- Just ('\125',input) ->- docCommentEnd input commentAcc docType buf span- Just (_,_) -> go ('-':commentAcc) input docType False- Just ('\123', input) -> case alexGetChar' input of- Nothing -> errBrace input (psRealSpan span)- Just ('-',input) -> do- setInput input- let cont = do input <- getInput; go commentAcc input docType False- nested_comment cont span buf _len- Just (_,_) -> go ('\123':commentAcc) input docType False- -- See Note [Nested comment line pragmas]- Just ('\n',input) -> case alexGetChar' input of- Nothing -> errBrace input (psRealSpan span)- Just ('#',_) -> do (parsedAcc,input) <- parseNestedPragma input- go (parsedAcc ++ '\n':commentAcc) input docType False- Just (_,_) -> go ('\n':commentAcc) input docType False- Just (c,input) -> go (c:commentAcc) input docType False---- See Note [Nested comment line pragmas]-parseNestedPragma :: AlexInput -> P (String,AlexInput)-parseNestedPragma input@(AI _ buf) = do- origInput <- getInput- setInput input- setExts (.|. xbit InNestedCommentBit)- pushLexState bol- lt <- lexToken- _ <- popLexState- setExts (.&. complement (xbit InNestedCommentBit))- postInput@(AI _ postBuf) <- getInput- setInput origInput- case unLoc lt of- ITcomment_line_prag -> do- let bytes = byteDiff buf postBuf- diff = lexemeToString buf bytes- return (reverse diff, postInput)- lt' -> panic ("parseNestedPragma: unexpected token" ++ (show lt'))--{--Note [Nested comment line pragmas]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-We used to ignore cpp-preprocessor-generated #line pragmas if they were inside-nested comments.--Now, when parsing a nested comment, if we encounter a line starting with '#' we-call parseNestedPragma, which executes the following:-1. Save the current lexer input (loc, buf) for later-2. Set the current lexer input to the beginning of the line starting with '#'-3. Turn the 'InNestedComment' extension on-4. Push the 'bol' lexer state-5. Lex a token. Due to (2), (3), and (4), this should always lex a single line- or less and return the ITcomment_line_prag token. This may set source line- and file location if a #line pragma is successfully parsed-6. Restore lexer input and state to what they were before we did all this-7. Return control to the function parsing a nested comment, informing it of- what the lexer parsed--Regarding (5) above:-Every exit from the 'bol' lexer state (do_bol, popLinePrag1, failLinePrag1)-checks if the 'InNestedComment' extension is set. If it is, that function will-return control to parseNestedPragma by returning the ITcomment_line_prag token.--See #314 for more background on the bug this fixes.--}--withLexedDocType :: (AlexInput -> (String -> (HdkComment, Token)) -> Bool -> P (PsLocated Token))- -> P (PsLocated Token)-withLexedDocType lexDocComment = do- input@(AI _ buf) <- getInput- l <- getLastLocComment- case prevChar buf ' ' of- -- The `Bool` argument to lexDocComment signals whether or not the next- -- line of input might also belong to this doc comment.- '|' -> lexDocComment input (mkHdkCommentNext l) True- '^' -> lexDocComment input (mkHdkCommentPrev l) True- '$' -> lexDocComment input (mkHdkCommentNamed l) True- '*' -> lexDocSection l 1 input- _ -> panic "withLexedDocType: Bad doc type"- where- lexDocSection l n input = case alexGetChar' input of- Just ('*', input) -> lexDocSection l (n+1) input- Just (_, _) -> lexDocComment input (mkHdkCommentSection l n) False- Nothing -> do setInput input; lexToken -- eof reached, lex it normally--mkHdkCommentNext, mkHdkCommentPrev :: PsSpan -> String -> (HdkComment, Token)-mkHdkCommentNext loc str = (HdkCommentNext (mkHsDocString str), ITdocCommentNext str loc)-mkHdkCommentPrev loc str = (HdkCommentPrev (mkHsDocString str), ITdocCommentPrev str loc)--mkHdkCommentNamed :: PsSpan -> String -> (HdkComment, Token)-mkHdkCommentNamed loc str =- let (name, rest) = break isSpace str- in (HdkCommentNamed name (mkHsDocString rest), ITdocCommentNamed str loc)--mkHdkCommentSection :: PsSpan -> Int -> String -> (HdkComment, Token)-mkHdkCommentSection loc n str =- (HdkCommentSection n (mkHsDocString str), ITdocSection n str loc)---- RULES pragmas turn on the forall and '.' keywords, and we turn them--- off again at the end of the pragma.-rulePrag :: Action-rulePrag span buf len = do- setExts (.|. xbit InRulePragBit)- let !src = lexemeToString buf len- return (L span (ITrules_prag (SourceText src)))---- When 'UsePosPragsBit' is not set, it is expected that we emit a token instead--- of updating the position in 'PState'-linePrag :: Action-linePrag span buf len = do- usePosPrags <- getBit UsePosPragsBit- if usePosPrags- then begin line_prag2 span buf len- else let !src = lexemeToString buf len- in return (L span (ITline_prag (SourceText src)))---- When 'UsePosPragsBit' is not set, it is expected that we emit a token instead--- of updating the position in 'PState'-columnPrag :: Action-columnPrag span buf len = do- usePosPrags <- getBit UsePosPragsBit- let !src = lexemeToString buf len- if usePosPrags- then begin column_prag span buf len- else let !src = lexemeToString buf len- in return (L span (ITcolumn_prag (SourceText src)))--endPrag :: Action-endPrag span _buf _len = do- setExts (.&. complement (xbit InRulePragBit))- return (L span ITclose_prag)---- docCommentEnd----------------------------------------------------------------------------------- This function is quite tricky. We can't just return a new token, we also--- need to update the state of the parser. Why? Because the token is longer--- than what was lexed by Alex, and the lexToken function doesn't know this, so--- it writes the wrong token length to the parser state. This function is--- called afterwards, so it can just update the state.--commentEnd :: P (PsLocated Token)- -> AlexInput- -> String- -> (String -> (Maybe HdkComment, Token))- -> StringBuffer- -> PsSpan- -> P (PsLocated Token)-commentEnd cont input commentAcc finalizeComment buf span = do- setInput input- let (AI loc nextBuf) = input- comment = reverse commentAcc- span' = mkPsSpan (psSpanStart span) loc- last_len = byteDiff buf nextBuf- span `seq` setLastToken span' last_len- let (m_hdk_comment, hdk_token) = finalizeComment comment- whenIsJust m_hdk_comment $ \hdk_comment ->- P $ \s -> POk (s {hdk_comments = hdk_comments s `snocOL` L span' hdk_comment}) ()- b <- getBit RawTokenStreamBit- if b then return (L span' hdk_token)- else cont--docCommentEnd :: AlexInput -> String -> (String -> (HdkComment, Token)) -> StringBuffer ->- PsSpan -> P (PsLocated Token)-docCommentEnd input commentAcc docType buf span = do- let finalizeComment str =- let (hdk_comment, token) = docType str- in (Just hdk_comment, token)- commentEnd lexToken input commentAcc finalizeComment buf span--errBrace :: AlexInput -> RealSrcSpan -> P a-errBrace (AI end _) span = failLocMsgP (realSrcSpanStart span) (psRealLoc end) (PsError (PsErrLexer LexUnterminatedComment LexErrKind_EOF) [])--open_brace, close_brace :: Action-open_brace span _str _len = do- ctx <- getContext- setContext (NoLayout:ctx)- return (L span ITocurly)-close_brace span _str _len = do- popContext- return (L span ITccurly)--qvarid, qconid :: StringBuffer -> Int -> Token-qvarid buf len = ITqvarid $! splitQualName buf len False-qconid buf len = ITqconid $! splitQualName buf len False--splitQualName :: StringBuffer -> Int -> Bool -> (FastString,FastString)--- takes a StringBuffer and a length, and returns the module name--- and identifier parts of a qualified name. Splits at the *last* dot,--- because of hierarchical module names.------ Throws an error if the name is not qualified.-splitQualName orig_buf len parens = split orig_buf orig_buf- where- split buf dot_buf- | orig_buf `byteDiff` buf >= len = done dot_buf- | c == '.' = found_dot buf'- | otherwise = split buf' dot_buf- where- (c,buf') = nextChar buf-- -- careful, we might get names like M....- -- so, if the character after the dot is not upper-case, this is- -- the end of the qualifier part.- found_dot buf -- buf points after the '.'- | isUpper c = split buf' buf- | otherwise = done buf- where- (c,buf') = nextChar buf-- done dot_buf- | qual_size < 1 = error "splitQualName got an unqualified named"- | otherwise =- (lexemeToFastString orig_buf (qual_size - 1),- if parens -- Prelude.(+)- then lexemeToFastString (stepOn dot_buf) (len - qual_size - 2)- else lexemeToFastString dot_buf (len - qual_size))- where- qual_size = orig_buf `byteDiff` dot_buf--varid :: Action-varid span buf len =- case lookupUFM reservedWordsFM fs of- Just (ITcase, _) -> do- lastTk <- getLastTk- keyword <- case lastTk of- Just (L _ ITlam) -> do- lambdaCase <- getBit LambdaCaseBit- unless lambdaCase $ do- pState <- getPState- addError $ PsError PsErrLambdaCase [] (mkSrcSpanPs (last_loc pState))- return ITlcase- _ -> return ITcase- maybe_layout keyword- return $ L span keyword- Just (keyword, 0) -> do- maybe_layout keyword- return $ L span keyword- Just (keyword, i) -> do- exts <- getExts- if exts .&. i /= 0- then do- maybe_layout keyword- return $ L span keyword- else- return $ L span $ ITvarid fs- Nothing ->- return $ L span $ ITvarid fs- where- !fs = lexemeToFastString buf len--conid :: StringBuffer -> Int -> Token-conid buf len = ITconid $! lexemeToFastString buf len--qvarsym, qconsym :: StringBuffer -> Int -> Token-qvarsym buf len = ITqvarsym $! splitQualName buf len False-qconsym buf len = ITqconsym $! splitQualName buf len False---- See Note [Whitespace-sensitive operator parsing]-varsym_prefix :: Action-varsym_prefix = sym $ \span exts s ->- let warnExtConflict errtok =- do { addWarning Opt_WarnOperatorWhitespaceExtConflict $- PsWarnOperatorWhitespaceExtConflict (mkSrcSpanPs span) errtok- ; return (ITvarsym s) }- in- if | s == fsLit "@" ->- return ITtypeApp -- regardless of TypeApplications for better error messages- | s == fsLit "%" ->- if xtest LinearTypesBit exts- then return ITpercent- else warnExtConflict OperatorWhitespaceSymbol_PrefixPercent- | s == fsLit "$" ->- if xtest ThQuotesBit exts- then return ITdollar- else warnExtConflict OperatorWhitespaceSymbol_PrefixDollar- | s == fsLit "$$" ->- if xtest ThQuotesBit exts- then return ITdollardollar- else warnExtConflict OperatorWhitespaceSymbol_PrefixDollarDollar- | s == fsLit "-" ->- return ITprefixminus -- Only when LexicalNegation is on, otherwise we get ITminus- -- and don't hit this code path. See Note [Minus tokens]- | s == fsLit ".", OverloadedRecordDotBit `xtest` exts ->- return (ITproj True) -- e.g. '(.x)'- | s == fsLit "." -> return ITdot- | s == fsLit "!" -> return ITbang- | s == fsLit "~" -> return ITtilde- | otherwise ->- do { addWarning Opt_WarnOperatorWhitespace $- PsWarnOperatorWhitespace (mkSrcSpanPs span) s- OperatorWhitespaceOccurrence_Prefix- ; return (ITvarsym s) }---- See Note [Whitespace-sensitive operator parsing]-varsym_suffix :: Action-varsym_suffix = sym $ \span _ s ->- if | s == fsLit "@" -> failMsgP (PsError PsErrSuffixAT [])- | s == fsLit "." -> return ITdot- | otherwise ->- do { addWarning Opt_WarnOperatorWhitespace $- PsWarnOperatorWhitespace (mkSrcSpanPs span) s- OperatorWhitespaceOccurrence_Suffix- ; return (ITvarsym s) }---- See Note [Whitespace-sensitive operator parsing]-varsym_tight_infix :: Action-varsym_tight_infix = sym $ \span exts s ->- if | s == fsLit "@" -> return ITat- | s == fsLit ".", OverloadedRecordDotBit `xtest` exts -> return (ITproj False)- | s == fsLit "." -> return ITdot- | otherwise ->- do { addWarning Opt_WarnOperatorWhitespace $- PsWarnOperatorWhitespace (mkSrcSpanPs span) s- OperatorWhitespaceOccurrence_TightInfix- ; return (ITvarsym s) }---- See Note [Whitespace-sensitive operator parsing]-varsym_loose_infix :: Action-varsym_loose_infix = sym $ \_ _ s ->- if | s == fsLit "."- -> return ITdot- | otherwise- -> return $ ITvarsym s--consym :: Action-consym = sym (\_span _exts s -> return $ ITconsym s)--sym :: (PsSpan -> ExtsBitmap -> FastString -> P Token) -> Action-sym con span buf len =- case lookupUFM reservedSymsFM fs of- Just (keyword, NormalSyntax, 0) -> do- exts <- getExts- if fs == fsLit "." &&- exts .&. (xbit OverloadedRecordDotBit) /= 0 &&- xtest OverloadedRecordDotBit exts- then L span <$!> con span exts fs -- Process by varsym_*.- else return $ L span keyword- Just (keyword, NormalSyntax, i) -> do- exts <- getExts- if exts .&. i /= 0- then return $ L span keyword- else L span <$!> con span exts fs- Just (keyword, UnicodeSyntax, 0) -> do- exts <- getExts- if xtest UnicodeSyntaxBit exts- then return $ L span keyword- else L span <$!> con span exts fs- Just (keyword, UnicodeSyntax, i) -> do- exts <- getExts- if exts .&. i /= 0 && xtest UnicodeSyntaxBit exts- then return $ L span keyword- else L span <$!> con span exts fs- Nothing -> do- exts <- getExts- L span <$!> con span exts fs- where- !fs = lexemeToFastString buf len---- Variations on the integral numeric literal.-tok_integral :: (SourceText -> Integer -> Token)- -> (Integer -> Integer)- -> Int -> Int- -> (Integer, (Char -> Int))- -> Action-tok_integral itint transint transbuf translen (radix,char_to_int) span buf len = do- numericUnderscores <- getBit NumericUnderscoresBit -- #14473- let src = lexemeToString buf len- when ((not numericUnderscores) && ('_' `elem` src)) $ do- pState <- getPState- addError $ PsError (PsErrNumUnderscores NumUnderscore_Integral) [] (mkSrcSpanPs (last_loc pState))- return $ L span $ itint (SourceText src)- $! transint $ parseUnsignedInteger- (offsetBytes transbuf buf) (subtract translen len) radix char_to_int--tok_num :: (Integer -> Integer)- -> Int -> Int- -> (Integer, (Char->Int)) -> Action-tok_num = tok_integral $ \case- st@(SourceText ('-':_)) -> itint st (const True)- st@(SourceText _) -> itint st (const False)- st@NoSourceText -> itint st (< 0)- where- itint :: SourceText -> (Integer -> Bool) -> Integer -> Token- itint !st is_negative !val = ITinteger ((IL st $! is_negative val) val)--tok_primint :: (Integer -> Integer)- -> Int -> Int- -> (Integer, (Char->Int)) -> Action-tok_primint = tok_integral ITprimint---tok_primword :: Int -> Int- -> (Integer, (Char->Int)) -> Action-tok_primword = tok_integral ITprimword positive-positive, negative :: (Integer -> Integer)-positive = id-negative = negate-decimal, octal, hexadecimal :: (Integer, Char -> Int)-decimal = (10,octDecDigit)-binary = (2,octDecDigit)-octal = (8,octDecDigit)-hexadecimal = (16,hexDigit)---- readSignificandExponentPair can understand negative rationals, exponents, everything.-tok_frac :: Int -> (String -> Token) -> Action-tok_frac drop f span buf len = do- numericUnderscores <- getBit NumericUnderscoresBit -- #14473- let src = lexemeToString buf (len-drop)- when ((not numericUnderscores) && ('_' `elem` src)) $ do- pState <- getPState- addError $ PsError (PsErrNumUnderscores NumUnderscore_Float) [] (mkSrcSpanPs (last_loc pState))- return (L span $! (f $! src))--tok_float, tok_primfloat, tok_primdouble :: String -> Token-tok_float str = ITrational $! readFractionalLit str-tok_hex_float str = ITrational $! readHexFractionalLit str-tok_primfloat str = ITprimfloat $! readFractionalLit str-tok_primdouble str = ITprimdouble $! readFractionalLit str--readFractionalLit, readHexFractionalLit :: String -> FractionalLit-readHexFractionalLit = readFractionalLitX readHexSignificandExponentPair Base2-readFractionalLit = readFractionalLitX readSignificandExponentPair Base10--readFractionalLitX :: (String -> (Integer, Integer))- -> FractionalExponentBase- -> String -> FractionalLit-readFractionalLitX readStr b str =- mkSourceFractionalLit str is_neg i e b- where- is_neg = case str of- '-' : _ -> True- _ -> False- (i, e) = readStr str---- -------------------------------------------------------------------------------- Layout processing---- we're at the first token on a line, insert layout tokens if necessary-do_bol :: Action-do_bol span _str _len = do- -- See Note [Nested comment line pragmas]- b <- getBit InNestedCommentBit- if b then return (L span ITcomment_line_prag) else do- (pos, gen_semic) <- getOffside- case pos of- LT -> do- --trace "layout: inserting '}'" $ do- popContext- -- do NOT pop the lex state, we might have a ';' to insert- return (L span ITvccurly)- EQ | gen_semic -> do- --trace "layout: inserting ';'" $ do- _ <- popLexState- return (L span ITsemi)- _ -> do- _ <- popLexState- lexToken---- certain keywords put us in the "layout" state, where we might--- add an opening curly brace.-maybe_layout :: Token -> P ()-maybe_layout t = do -- If the alternative layout rule is enabled then- -- we never create an implicit layout context here.- -- Layout is handled XXX instead.- -- The code for closing implicit contexts, or- -- inserting implicit semi-colons, is therefore- -- irrelevant as it only applies in an implicit- -- context.- alr <- getBit AlternativeLayoutRuleBit- unless alr $ f t- where f (ITdo _) = pushLexState layout_do- f (ITmdo _) = pushLexState layout_do- f ITof = pushLexState layout- f ITlcase = pushLexState layout- f ITlet = pushLexState layout- f ITwhere = pushLexState layout- f ITrec = pushLexState layout- f ITif = pushLexState layout_if- f _ = return ()---- Pushing a new implicit layout context. If the indentation of the--- next token is not greater than the previous layout context, then--- Haskell 98 says that the new layout context should be empty; that is--- the lexer must generate {}.------ We are slightly more lenient than this: when the new context is started--- by a 'do', then we allow the new context to be at the same indentation as--- the previous context. This is what the 'strict' argument is for.-new_layout_context :: Bool -> Bool -> Token -> Action-new_layout_context strict gen_semic tok span _buf len = do- _ <- popLexState- (AI l _) <- getInput- let offset = srcLocCol (psRealLoc l) - len- ctx <- getContext- nondecreasing <- getBit NondecreasingIndentationBit- let strict' = strict || not nondecreasing- case ctx of- Layout prev_off _ : _ |- (strict' && prev_off >= offset ||- not strict' && prev_off > offset) -> do- -- token is indented to the left of the previous context.- -- we must generate a {} sequence now.- pushLexState layout_left- return (L span tok)- _ -> do setContext (Layout offset gen_semic : ctx)- return (L span tok)--do_layout_left :: Action-do_layout_left span _buf _len = do- _ <- popLexState- pushLexState bol -- we must be at the start of a line- return (L span ITvccurly)---- -------------------------------------------------------------------------------- LINE pragmas--setLineAndFile :: Int -> Action-setLineAndFile code (PsSpan span _) buf len = do- let src = lexemeToString buf (len - 1) -- drop trailing quotation mark- linenumLen = length $ head $ words src- linenum = parseUnsignedInteger buf linenumLen 10 octDecDigit- file = mkFastString $ go $ drop 1 $ dropWhile (/= '"') src- -- skip everything through first quotation mark to get to the filename- where go ('\\':c:cs) = c : go cs- go (c:cs) = c : go cs- go [] = []- -- decode escapes in the filename. e.g. on Windows- -- when our filenames have backslashes in, gcc seems to- -- escape the backslashes. One symptom of not doing this- -- is that filenames in error messages look a bit strange:- -- C:\\foo\bar.hs- -- only the first backslash is doubled, because we apply- -- System.FilePath.normalise before printing out- -- filenames and it does not remove duplicate- -- backslashes after the drive letter (should it?).- resetAlrLastLoc file- setSrcLoc (mkRealSrcLoc file (fromIntegral linenum - 1) (srcSpanEndCol span))- -- subtract one: the line number refers to the *following* line- addSrcFile file- _ <- popLexState- pushLexState code- lexToken--setColumn :: Action-setColumn (PsSpan span _) buf len = do- let column =- case reads (lexemeToString buf len) of- [(column, _)] -> column- _ -> error "setColumn: expected integer" -- shouldn't happen- setSrcLoc (mkRealSrcLoc (srcSpanFile span) (srcSpanEndLine span)- (fromIntegral (column :: Integer)))- _ <- popLexState- lexToken--alrInitialLoc :: FastString -> RealSrcSpan-alrInitialLoc file = mkRealSrcSpan loc loc- where -- This is a hack to ensure that the first line in a file- -- looks like it is after the initial location:- loc = mkRealSrcLoc file (-1) (-1)---- -------------------------------------------------------------------------------- Options, includes and language pragmas.---lex_string_prag :: (String -> Token) -> Action-lex_string_prag mkTok = lex_string_prag_comment mkTok'- where- mkTok' s _ = mkTok s--lex_string_prag_comment :: (String -> PsSpan -> Token) -> Action-lex_string_prag_comment mkTok span _buf _len- = do input <- getInput- start <- getParsedLoc- l <- getLastLocComment- tok <- go l [] input- end <- getParsedLoc- return (L (mkPsSpan start end) tok)- where go l acc input- = if isString input "#-}"- then do setInput input- return (mkTok (reverse acc) l)- else case alexGetChar input of- Just (c,i) -> go l (c:acc) i- Nothing -> err input- isString _ [] = True- isString i (x:xs)- = case alexGetChar i of- Just (c,i') | c == x -> isString i' xs- _other -> False- err (AI end _) = failLocMsgP (realSrcSpanStart (psRealSpan span)) (psRealLoc end) (PsError (PsErrLexer LexUnterminatedOptions LexErrKind_EOF) [])---- -------------------------------------------------------------------------------- Strings & Chars---- This stuff is horrible. I hates it.--lex_string_tok :: Action-lex_string_tok span buf _len = do- tok <- lex_string ""- (AI end bufEnd) <- getInput- let- tok' = case tok of- ITprimstring _ bs -> ITprimstring (SourceText src) bs- ITstring _ s -> ITstring (SourceText src) s- _ -> panic "lex_string_tok"- src = lexemeToString buf (cur bufEnd - cur buf)- return (L (mkPsSpan (psSpanStart span) end) tok')--lex_string :: String -> P Token-lex_string s = do- i <- getInput- case alexGetChar' i of- Nothing -> lit_error i-- Just ('"',i) -> do- setInput i- let s' = reverse s- magicHash <- getBit MagicHashBit- if magicHash- then do- i <- getInput- case alexGetChar' i of- Just ('#',i) -> do- setInput i- when (any (> '\xFF') s') $ do- pState <- getPState- let err = PsError PsErrPrimStringInvalidChar [] (mkSrcSpanPs (last_loc pState))- addError err- return (ITprimstring (SourceText s') (unsafeMkByteString s'))- _other ->- return (ITstring (SourceText s') (mkFastString s'))- else- return (ITstring (SourceText s') (mkFastString s'))-- Just ('\\',i)- | Just ('&',i) <- next -> do- setInput i; lex_string s- | Just (c,i) <- next, c <= '\x7f' && is_space c -> do- -- is_space only works for <= '\x7f' (#3751, #5425)- setInput i; lex_stringgap s- where next = alexGetChar' i-- Just (c, i1) -> do- case c of- '\\' -> do setInput i1; c' <- lex_escape; lex_string (c':s)- c | isAny c -> do setInput i1; lex_string (c:s)- _other -> lit_error i--lex_stringgap :: String -> P Token-lex_stringgap s = do- i <- getInput- c <- getCharOrFail i- case c of- '\\' -> lex_string s- c | c <= '\x7f' && is_space c -> lex_stringgap s- -- is_space only works for <= '\x7f' (#3751, #5425)- _other -> lit_error i---lex_char_tok :: Action--- Here we are basically parsing character literals, such as 'x' or '\n'--- but we additionally spot 'x and ''T, returning ITsimpleQuote and--- ITtyQuote respectively, but WITHOUT CONSUMING the x or T part--- (the parser does that).--- So we have to do two characters of lookahead: when we see 'x we need to--- see if there's a trailing quote-lex_char_tok span buf _len = do -- We've seen '- i1 <- getInput -- Look ahead to first character- let loc = psSpanStart span- case alexGetChar' i1 of- Nothing -> lit_error i1-- Just ('\'', i2@(AI end2 _)) -> do -- We've seen ''- setInput i2- return (L (mkPsSpan loc end2) ITtyQuote)-- Just ('\\', i2@(AI _end2 _)) -> do -- We've seen 'backslash- setInput i2- lit_ch <- lex_escape- i3 <- getInput- mc <- getCharOrFail i3 -- Trailing quote- if mc == '\'' then finish_char_tok buf loc lit_ch- else lit_error i3-- Just (c, i2@(AI _end2 _))- | not (isAny c) -> lit_error i1- | otherwise ->-- -- We've seen 'x, where x is a valid character- -- (i.e. not newline etc) but not a quote or backslash- case alexGetChar' i2 of -- Look ahead one more character- Just ('\'', i3) -> do -- We've seen 'x'- setInput i3- finish_char_tok buf loc c- _other -> do -- We've seen 'x not followed by quote- -- (including the possibility of EOF)- -- Just parse the quote only- let (AI end _) = i1- return (L (mkPsSpan loc end) ITsimpleQuote)--finish_char_tok :: StringBuffer -> PsLoc -> Char -> P (PsLocated Token)-finish_char_tok buf loc ch -- We've already seen the closing quote- -- Just need to check for trailing #- = do magicHash <- getBit MagicHashBit- i@(AI end bufEnd) <- getInput- let src = lexemeToString buf (cur bufEnd - cur buf)- if magicHash then do- case alexGetChar' i of- Just ('#',i@(AI end _)) -> do- setInput i- return (L (mkPsSpan loc end)- (ITprimchar (SourceText src) ch))- _other ->- return (L (mkPsSpan loc end)- (ITchar (SourceText src) ch))- else do- return (L (mkPsSpan loc end) (ITchar (SourceText src) ch))--isAny :: Char -> Bool-isAny c | c > '\x7f' = isPrint c- | otherwise = is_any c--lex_escape :: P Char-lex_escape = do- i0 <- getInput- c <- getCharOrFail i0- case c of- 'a' -> return '\a'- 'b' -> return '\b'- 'f' -> return '\f'- 'n' -> return '\n'- 'r' -> return '\r'- 't' -> return '\t'- 'v' -> return '\v'- '\\' -> return '\\'- '"' -> return '\"'- '\'' -> return '\''- '^' -> do i1 <- getInput- c <- getCharOrFail i1- if c >= '@' && c <= '_'- then return (chr (ord c - ord '@'))- else lit_error i1-- 'x' -> readNum is_hexdigit 16 hexDigit- 'o' -> readNum is_octdigit 8 octDecDigit- x | is_decdigit x -> readNum2 is_decdigit 10 octDecDigit (octDecDigit x)-- c1 -> do- i <- getInput- case alexGetChar' i of- Nothing -> lit_error i0- Just (c2,i2) ->- case alexGetChar' i2 of- Nothing -> do lit_error i0- Just (c3,i3) ->- let str = [c1,c2,c3] in- case [ (c,rest) | (p,c) <- silly_escape_chars,- Just rest <- [stripPrefix p str] ] of- (escape_char,[]):_ -> do- setInput i3- return escape_char- (escape_char,_:_):_ -> do- setInput i2- return escape_char- [] -> lit_error i0--readNum :: (Char -> Bool) -> Int -> (Char -> Int) -> P Char-readNum is_digit base conv = do- i <- getInput- c <- getCharOrFail i- if is_digit c- then readNum2 is_digit base conv (conv c)- else lit_error i--readNum2 :: (Char -> Bool) -> Int -> (Char -> Int) -> Int -> P Char-readNum2 is_digit base conv i = do- input <- getInput- read i input- where read i input = do- case alexGetChar' input of- Just (c,input') | is_digit c -> do- let i' = i*base + conv c- if i' > 0x10ffff- then setInput input >> lexError LexNumEscapeRange- else read i' input'- _other -> do- setInput input; return (chr i)---silly_escape_chars :: [(String, Char)]-silly_escape_chars = [- ("NUL", '\NUL'),- ("SOH", '\SOH'),- ("STX", '\STX'),- ("ETX", '\ETX'),- ("EOT", '\EOT'),- ("ENQ", '\ENQ'),- ("ACK", '\ACK'),- ("BEL", '\BEL'),- ("BS", '\BS'),- ("HT", '\HT'),- ("LF", '\LF'),- ("VT", '\VT'),- ("FF", '\FF'),- ("CR", '\CR'),- ("SO", '\SO'),- ("SI", '\SI'),- ("DLE", '\DLE'),- ("DC1", '\DC1'),- ("DC2", '\DC2'),- ("DC3", '\DC3'),- ("DC4", '\DC4'),- ("NAK", '\NAK'),- ("SYN", '\SYN'),- ("ETB", '\ETB'),- ("CAN", '\CAN'),- ("EM", '\EM'),- ("SUB", '\SUB'),- ("ESC", '\ESC'),- ("FS", '\FS'),- ("GS", '\GS'),- ("RS", '\RS'),- ("US", '\US'),- ("SP", '\SP'),- ("DEL", '\DEL')- ]---- before calling lit_error, ensure that the current input is pointing to--- the position of the error in the buffer. This is so that we can report--- a correct location to the user, but also so we can detect UTF-8 decoding--- errors if they occur.-lit_error :: AlexInput -> P a-lit_error i = do setInput i; lexError LexStringCharLit--getCharOrFail :: AlexInput -> P Char-getCharOrFail i = do- case alexGetChar' i of- Nothing -> lexError LexStringCharLitEOF- Just (c,i) -> do setInput i; return c---- -------------------------------------------------------------------------------- QuasiQuote--lex_qquasiquote_tok :: Action-lex_qquasiquote_tok span buf len = do- let (qual, quoter) = splitQualName (stepOn buf) (len - 2) False- quoteStart <- getParsedLoc- quote <- lex_quasiquote (psRealLoc quoteStart) ""- end <- getParsedLoc- return (L (mkPsSpan (psSpanStart span) end)- (ITqQuasiQuote (qual,- quoter,- mkFastString (reverse quote),- mkPsSpan quoteStart end)))--lex_quasiquote_tok :: Action-lex_quasiquote_tok span buf len = do- let quoter = tail (lexemeToString buf (len - 1))- -- 'tail' drops the initial '[',- -- while the -1 drops the trailing '|'- quoteStart <- getParsedLoc- quote <- lex_quasiquote (psRealLoc quoteStart) ""- end <- getParsedLoc- return (L (mkPsSpan (psSpanStart span) end)- (ITquasiQuote (mkFastString quoter,- mkFastString (reverse quote),- mkPsSpan quoteStart end)))--lex_quasiquote :: RealSrcLoc -> String -> P String-lex_quasiquote start s = do- i <- getInput- case alexGetChar' i of- Nothing -> quasiquote_error start-- -- NB: The string "|]" terminates the quasiquote,- -- with absolutely no escaping. See the extensive- -- discussion on #5348 for why there is no- -- escape handling.- Just ('|',i)- | Just (']',i) <- alexGetChar' i- -> do { setInput i; return s }-- Just (c, i) -> do- setInput i; lex_quasiquote start (c : s)--quasiquote_error :: RealSrcLoc -> P a-quasiquote_error start = do- (AI end buf) <- getInput- reportLexError start (psRealLoc end) buf- (\k -> PsError (PsErrLexer LexUnterminatedQQ k) [])---- -------------------------------------------------------------------------------- Warnings--warnTab :: Action-warnTab srcspan _buf _len = do- addTabWarning (psRealSpan srcspan)- lexToken--warnThen :: WarningFlag -> (SrcSpan -> PsWarning) -> Action -> Action-warnThen flag warning action srcspan buf len = do- addWarning flag (warning (RealSrcSpan (psRealSpan srcspan) Nothing))- action srcspan buf len---- -------------------------------------------------------------------------------- The Parse Monad---- | Do we want to generate ';' layout tokens? In some cases we just want to--- generate '}', e.g. in MultiWayIf we don't need ';'s because '|' separates--- alternatives (unlike a `case` expression where we need ';' to as a separator--- between alternatives).-type GenSemic = Bool--generateSemic, dontGenerateSemic :: GenSemic-generateSemic = True-dontGenerateSemic = False--data LayoutContext- = NoLayout- | Layout !Int !GenSemic- deriving Show---- | The result of running a parser.-data ParseResult a- = POk -- ^ The parser has consumed a (possibly empty) prefix- -- of the input and produced a result. Use 'getMessages'- -- to check for accumulated warnings and non-fatal errors.- PState -- ^ The resulting parsing state. Can be used to resume parsing.- a -- ^ The resulting value.- | PFailed -- ^ The parser has consumed a (possibly empty) prefix- -- of the input and failed.- PState -- ^ The parsing state right before failure, including the fatal- -- parse error. 'getMessages' and 'getErrorMessages' must return- -- a non-empty bag of errors.---- | Test whether a 'WarningFlag' is set-warnopt :: WarningFlag -> ParserOpts -> Bool-warnopt f options = f `EnumSet.member` pWarningFlags options---- | Parser options.------ See 'mkParserOpts' to construct this.-data ParserOpts = ParserOpts- { pWarningFlags :: EnumSet WarningFlag -- ^ enabled warning flags- , pExtsBitmap :: !ExtsBitmap -- ^ bitmap of permitted extensions- }---- | Haddock comment as produced by the lexer. These are accumulated in--- 'PState' and then processed in "GHC.Parser.PostProcess.Haddock".-data HdkComment- = HdkCommentNext HsDocString- | HdkCommentPrev HsDocString- | HdkCommentNamed String HsDocString- | HdkCommentSection Int HsDocString- deriving Show--data PState = PState {- buffer :: StringBuffer,- options :: ParserOpts,- warnings :: Bag PsWarning,- errors :: Bag PsError,- tab_first :: Maybe RealSrcSpan, -- pos of first tab warning in the file- tab_count :: !Word, -- number of tab warnings in the file- last_tk :: Maybe (PsLocated Token), -- last non-comment token- prev_loc :: PsSpan, -- pos of previous token, including comments,- prev_loc2 :: PsSpan, -- pos of two back token, including comments,- -- see Note [PsSpan in Comments]- last_loc :: PsSpan, -- pos of current token- last_len :: !Int, -- len of current token- loc :: PsLoc, -- current loc (end of prev token + 1)- context :: [LayoutContext],- lex_state :: [Int],- srcfiles :: [FastString],- -- Used in the alternative layout rule:- -- These tokens are the next ones to be sent out. They are- -- just blindly emitted, without the rule looking at them again:- alr_pending_implicit_tokens :: [PsLocated Token],- -- This is the next token to be considered or, if it is Nothing,- -- we need to get the next token from the input stream:- alr_next_token :: Maybe (PsLocated Token),- -- This is what we consider to be the location of the last token- -- emitted:- alr_last_loc :: PsSpan,- -- The stack of layout contexts:- alr_context :: [ALRContext],- -- Are we expecting a '{'? If it's Just, then the ALRLayout tells- -- us what sort of layout the '{' will open:- alr_expecting_ocurly :: Maybe ALRLayout,- -- Have we just had the '}' for a let block? If so, than an 'in'- -- token doesn't need to close anything:- alr_justClosedExplicitLetBlock :: Bool,-- -- The next three are used to implement Annotations giving the- -- locations of 'noise' tokens in the source, so that users of- -- the GHC API can do source to source conversions.- -- See note [exact print annotations] in GHC.Parser.Annotation- eof_pos :: Maybe (RealSrcSpan, RealSrcSpan), -- pos, gap to prior token- header_comments :: Maybe [LEpaComment],- comment_q :: [LEpaComment],-- -- Haddock comments accumulated in ascending order of their location- -- (BufPos). We use OrdList to get O(1) snoc.- --- -- See Note [Adding Haddock comments to the syntax tree] in GHC.Parser.PostProcess.Haddock- hdk_comments :: OrdList (PsLocated HdkComment)- }- -- last_loc and last_len are used when generating error messages,- -- and in pushCurrentContext only. Sigh, if only Happy passed the- -- current token to happyError, we could at least get rid of last_len.- -- Getting rid of last_loc would require finding another way to- -- implement pushCurrentContext (which is only called from one place).-- -- AZ question: setLastToken which sets last_loc and last_len- -- is called whan processing AlexToken, immediately prior to- -- calling the action in the token. So from the perspective- -- of the action, it is the *current* token. Do I understand- -- correctly?--data ALRContext = ALRNoLayout Bool{- does it contain commas? -}- Bool{- is it a 'let' block? -}- | ALRLayout ALRLayout Int-data ALRLayout = ALRLayoutLet- | ALRLayoutWhere- | ALRLayoutOf- | ALRLayoutDo---- | The parsing monad, isomorphic to @StateT PState Maybe@.-newtype P a = P { unP :: PState -> ParseResult a }--instance Functor P where- fmap = liftM--instance Applicative P where- pure = returnP- (<*>) = ap--instance Monad P where- (>>=) = thenP--returnP :: a -> P a-returnP a = a `seq` (P $ \s -> POk s a)--thenP :: P a -> (a -> P b) -> P b-(P m) `thenP` k = P $ \ s ->- case m s of- POk s1 a -> (unP (k a)) s1- PFailed s1 -> PFailed s1--failMsgP :: (SrcSpan -> PsError) -> P a-failMsgP f = do- pState <- getPState- addFatalError (f (mkSrcSpanPs (last_loc pState)))--failLocMsgP :: RealSrcLoc -> RealSrcLoc -> (SrcSpan -> PsError) -> P a-failLocMsgP loc1 loc2 f =- addFatalError (f (RealSrcSpan (mkRealSrcSpan loc1 loc2) Nothing))--getPState :: P PState-getPState = P $ \s -> POk s s--getExts :: P ExtsBitmap-getExts = P $ \s -> POk s (pExtsBitmap . options $ s)--setExts :: (ExtsBitmap -> ExtsBitmap) -> P ()-setExts f = P $ \s -> POk s {- options =- let p = options s- in p { pExtsBitmap = f (pExtsBitmap p) }- } ()--setSrcLoc :: RealSrcLoc -> P ()-setSrcLoc new_loc =- P $ \s@(PState{ loc = PsLoc _ buf_loc }) ->- POk s{ loc = PsLoc new_loc buf_loc } ()--getRealSrcLoc :: P RealSrcLoc-getRealSrcLoc = P $ \s@(PState{ loc=loc }) -> POk s (psRealLoc loc)--getParsedLoc :: P PsLoc-getParsedLoc = P $ \s@(PState{ loc=loc }) -> POk s loc--addSrcFile :: FastString -> P ()-addSrcFile f = P $ \s -> POk s{ srcfiles = f : srcfiles s } ()--setEofPos :: RealSrcSpan -> RealSrcSpan -> P ()-setEofPos span gap = P $ \s -> POk s{ eof_pos = Just (span, gap) } ()--setLastToken :: PsSpan -> Int -> P ()-setLastToken loc len = P $ \s -> POk s {- last_loc=loc,- last_len=len- } ()--setLastTk :: PsLocated Token -> P ()-setLastTk tk@(L l _) = P $ \s -> POk s { last_tk = Just tk- , prev_loc = l- , prev_loc2 = prev_loc s} ()--setLastComment :: PsLocated Token -> P ()-setLastComment (L l _) = P $ \s -> POk s { prev_loc = l- , prev_loc2 = prev_loc s} ()--getLastTk :: P (Maybe (PsLocated Token))-getLastTk = P $ \s@(PState { last_tk = last_tk }) -> POk s last_tk---- see Note [PsSpan in Comments]-getLastLocComment :: P PsSpan-getLastLocComment = P $ \s@(PState { prev_loc = prev_loc }) -> POk s prev_loc---- see Note [PsSpan in Comments]-getLastLocEof :: P PsSpan-getLastLocEof = P $ \s@(PState { prev_loc2 = prev_loc2 }) -> POk s prev_loc2--getLastLoc :: P PsSpan-getLastLoc = P $ \s@(PState { last_loc = last_loc }) -> POk s last_loc--data AlexInput = AI !PsLoc !StringBuffer--{--Note [Unicode in Alex]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Although newer versions of Alex support unicode, this grammar is processed with-the old style '--latin1' behaviour. This means that when implementing the-functions-- alexGetByte :: AlexInput -> Maybe (Word8,AlexInput)- alexInputPrevChar :: AlexInput -> Char--which Alex uses to take apart our 'AlexInput', we must-- * return a latin1 character in the 'Word8' that 'alexGetByte' expects- * return a latin1 character in 'alexInputPrevChar'.--We handle this in 'adjustChar' by squishing entire classes of unicode-characters into single bytes.--}--{-# INLINE adjustChar #-}-adjustChar :: Char -> Word8-adjustChar c = fromIntegral $ ord adj_c- where non_graphic = '\x00'- upper = '\x01'- lower = '\x02'- digit = '\x03'- symbol = '\x04'- space = '\x05'- other_graphic = '\x06'- uniidchar = '\x07'-- adj_c- | c <= '\x07' = non_graphic- | c <= '\x7f' = c- -- Alex doesn't handle Unicode, so when Unicode- -- character is encountered we output these values- -- with the actual character value hidden in the state.- | otherwise =- -- NB: The logic behind these definitions is also reflected- -- in "GHC.Utils.Lexeme"- -- Any changes here should likely be reflected there.-- case generalCategory c of- UppercaseLetter -> upper- LowercaseLetter -> lower- TitlecaseLetter -> upper- ModifierLetter -> uniidchar -- see #10196- OtherLetter -> lower -- see #1103- NonSpacingMark -> uniidchar -- see #7650- SpacingCombiningMark -> other_graphic- EnclosingMark -> other_graphic- DecimalNumber -> digit- LetterNumber -> other_graphic- OtherNumber -> digit -- see #4373- ConnectorPunctuation -> symbol- DashPunctuation -> symbol- OpenPunctuation -> other_graphic- ClosePunctuation -> other_graphic- InitialQuote -> other_graphic- FinalQuote -> other_graphic- OtherPunctuation -> symbol- MathSymbol -> symbol- CurrencySymbol -> symbol- ModifierSymbol -> symbol- OtherSymbol -> symbol- Space -> space- _other -> non_graphic---- Getting the previous 'Char' isn't enough here - we need to convert it into--- the same format that 'alexGetByte' would have produced.------ See Note [Unicode in Alex] and #13986.-alexInputPrevChar :: AlexInput -> Char-alexInputPrevChar (AI _ buf) = chr (fromIntegral (adjustChar pc))- where pc = prevChar buf '\n'---- backwards compatibility for Alex 2.x-alexGetChar :: AlexInput -> Maybe (Char,AlexInput)-alexGetChar inp = case alexGetByte inp of- Nothing -> Nothing- Just (b,i) -> c `seq` Just (c,i)- where c = chr $ fromIntegral b---- See Note [Unicode in Alex]-alexGetByte :: AlexInput -> Maybe (Word8,AlexInput)-alexGetByte (AI loc s)- | atEnd s = Nothing- | otherwise = byte `seq` loc' `seq` s' `seq`- --trace (show (ord c)) $- Just (byte, (AI loc' s'))- where (c,s') = nextChar s- loc' = advancePsLoc loc c- byte = adjustChar c---- This version does not squash unicode characters, it is used when--- lexing strings.-alexGetChar' :: AlexInput -> Maybe (Char,AlexInput)-alexGetChar' (AI loc s)- | atEnd s = Nothing- | otherwise = c `seq` loc' `seq` s' `seq`- --trace (show (ord c)) $- Just (c, (AI loc' s'))- where (c,s') = nextChar s- loc' = advancePsLoc loc c--getInput :: P AlexInput-getInput = P $ \s@PState{ loc=l, buffer=b } -> POk s (AI l b)--setInput :: AlexInput -> P ()-setInput (AI l b) = P $ \s -> POk s{ loc=l, buffer=b } ()--nextIsEOF :: P Bool-nextIsEOF = do- AI _ s <- getInput- return $ atEnd s--pushLexState :: Int -> P ()-pushLexState ls = P $ \s@PState{ lex_state=l } -> POk s{lex_state=ls:l} ()--popLexState :: P Int-popLexState = P $ \s@PState{ lex_state=ls:l } -> POk s{ lex_state=l } ls--getLexState :: P Int-getLexState = P $ \s@PState{ lex_state=ls:_ } -> POk s ls--popNextToken :: P (Maybe (PsLocated Token))-popNextToken- = P $ \s@PState{ alr_next_token = m } ->- POk (s {alr_next_token = Nothing}) m--activeContext :: P Bool-activeContext = do- ctxt <- getALRContext- expc <- getAlrExpectingOCurly- impt <- implicitTokenPending- case (ctxt,expc) of- ([],Nothing) -> return impt- _other -> return True--resetAlrLastLoc :: FastString -> P ()-resetAlrLastLoc file =- P $ \s@(PState {alr_last_loc = PsSpan _ buf_span}) ->- POk s{ alr_last_loc = PsSpan (alrInitialLoc file) buf_span } ()--setAlrLastLoc :: PsSpan -> P ()-setAlrLastLoc l = P $ \s -> POk (s {alr_last_loc = l}) ()--getAlrLastLoc :: P PsSpan-getAlrLastLoc = P $ \s@(PState {alr_last_loc = l}) -> POk s l--getALRContext :: P [ALRContext]-getALRContext = P $ \s@(PState {alr_context = cs}) -> POk s cs--setALRContext :: [ALRContext] -> P ()-setALRContext cs = P $ \s -> POk (s {alr_context = cs}) ()--getJustClosedExplicitLetBlock :: P Bool-getJustClosedExplicitLetBlock- = P $ \s@(PState {alr_justClosedExplicitLetBlock = b}) -> POk s b--setJustClosedExplicitLetBlock :: Bool -> P ()-setJustClosedExplicitLetBlock b- = P $ \s -> POk (s {alr_justClosedExplicitLetBlock = b}) ()--setNextToken :: PsLocated Token -> P ()-setNextToken t = P $ \s -> POk (s {alr_next_token = Just t}) ()--implicitTokenPending :: P Bool-implicitTokenPending- = P $ \s@PState{ alr_pending_implicit_tokens = ts } ->- case ts of- [] -> POk s False- _ -> POk s True--popPendingImplicitToken :: P (Maybe (PsLocated Token))-popPendingImplicitToken- = P $ \s@PState{ alr_pending_implicit_tokens = ts } ->- case ts of- [] -> POk s Nothing- (t : ts') -> POk (s {alr_pending_implicit_tokens = ts'}) (Just t)--setPendingImplicitTokens :: [PsLocated Token] -> P ()-setPendingImplicitTokens ts = P $ \s -> POk (s {alr_pending_implicit_tokens = ts}) ()--getAlrExpectingOCurly :: P (Maybe ALRLayout)-getAlrExpectingOCurly = P $ \s@(PState {alr_expecting_ocurly = b}) -> POk s b--setAlrExpectingOCurly :: Maybe ALRLayout -> P ()-setAlrExpectingOCurly b = P $ \s -> POk (s {alr_expecting_ocurly = b}) ()---- | For reasons of efficiency, boolean parsing flags (eg, language extensions--- or whether we are currently in a @RULE@ pragma) are represented by a bitmap--- stored in a @Word64@.-type ExtsBitmap = Word64--xbit :: ExtBits -> ExtsBitmap-xbit = bit . fromEnum--xtest :: ExtBits -> ExtsBitmap -> Bool-xtest ext xmap = testBit xmap (fromEnum ext)--xset :: ExtBits -> ExtsBitmap -> ExtsBitmap-xset ext xmap = setBit xmap (fromEnum ext)--xunset :: ExtBits -> ExtsBitmap -> ExtsBitmap-xunset ext xmap = clearBit xmap (fromEnum ext)---- | Various boolean flags, mostly language extensions, that impact lexing and--- parsing. Note that a handful of these can change during lexing/parsing.-data ExtBits- -- Flags that are constant once parsing starts- = FfiBit- | InterruptibleFfiBit- | CApiFfiBit- | ArrowsBit- | ThBit- | ThQuotesBit- | IpBit- | OverloadedLabelsBit -- #x overloaded labels- | ExplicitForallBit -- the 'forall' keyword- | BangPatBit -- Tells the parser to understand bang-patterns- -- (doesn't affect the lexer)- | PatternSynonymsBit -- pattern synonyms- | HaddockBit-- Lex and parse Haddock comments- | MagicHashBit -- "#" in both functions and operators- | RecursiveDoBit -- mdo- | QualifiedDoBit -- .do and .mdo- | UnicodeSyntaxBit -- the forall symbol, arrow symbols, etc- | UnboxedTuplesBit -- (# and #)- | UnboxedSumsBit -- (# and #)- | DatatypeContextsBit- | MonadComprehensionsBit- | TransformComprehensionsBit- | QqBit -- enable quasiquoting- | RawTokenStreamBit -- producing a token stream with all comments included- | AlternativeLayoutRuleBit- | ALRTransitionalBit- | RelaxedLayoutBit- | NondecreasingIndentationBit- | SafeHaskellBit- | TraditionalRecordSyntaxBit- | ExplicitNamespacesBit- | LambdaCaseBit- | BinaryLiteralsBit- | NegativeLiteralsBit- | HexFloatLiteralsBit- | StaticPointersBit- | NumericUnderscoresBit- | StarIsTypeBit- | BlockArgumentsBit- | NPlusKPatternsBit- | DoAndIfThenElseBit- | MultiWayIfBit- | GadtSyntaxBit- | ImportQualifiedPostBit- | LinearTypesBit- | NoLexicalNegationBit -- See Note [Why not LexicalNegationBit]- | OverloadedRecordDotBit- | OverloadedRecordUpdateBit-- -- Flags that are updated once parsing starts- | InRulePragBit- | InNestedCommentBit -- See Note [Nested comment line pragmas]- | UsePosPragsBit- -- ^ If this is enabled, '{-# LINE ... -#}' and '{-# COLUMN ... #-}'- -- update the internal position. Otherwise, those pragmas are lexed as- -- tokens of their own.- deriving Enum--{-# INLINE mkParserOpts #-}-mkParserOpts- :: EnumSet WarningFlag -- ^ warnings flags enabled- -> EnumSet LangExt.Extension -- ^ permitted language extensions enabled- -> Bool -- ^ are safe imports on?- -> Bool -- ^ keeping Haddock comment tokens- -> Bool -- ^ keep regular comment tokens-- -> Bool- -- ^ If this is enabled, '{-# LINE ... -#}' and '{-# COLUMN ... #-}' update- -- the internal position kept by the parser. Otherwise, those pragmas are- -- lexed as 'ITline_prag' and 'ITcolumn_prag' tokens.-- -> ParserOpts--- ^ Given exactly the information needed, set up the 'ParserOpts'-mkParserOpts warningFlags extensionFlags- safeImports isHaddock rawTokStream usePosPrags =- ParserOpts {- pWarningFlags = warningFlags- , pExtsBitmap = safeHaskellBit .|. langExtBits .|. optBits- }- where- safeHaskellBit = SafeHaskellBit `setBitIf` safeImports- langExtBits =- FfiBit `xoptBit` LangExt.ForeignFunctionInterface- .|. InterruptibleFfiBit `xoptBit` LangExt.InterruptibleFFI- .|. CApiFfiBit `xoptBit` LangExt.CApiFFI- .|. ArrowsBit `xoptBit` LangExt.Arrows- .|. ThBit `xoptBit` LangExt.TemplateHaskell- .|. ThQuotesBit `xoptBit` LangExt.TemplateHaskellQuotes- .|. QqBit `xoptBit` LangExt.QuasiQuotes- .|. IpBit `xoptBit` LangExt.ImplicitParams- .|. OverloadedLabelsBit `xoptBit` LangExt.OverloadedLabels- .|. ExplicitForallBit `xoptBit` LangExt.ExplicitForAll- .|. BangPatBit `xoptBit` LangExt.BangPatterns- .|. MagicHashBit `xoptBit` LangExt.MagicHash- .|. RecursiveDoBit `xoptBit` LangExt.RecursiveDo- .|. QualifiedDoBit `xoptBit` LangExt.QualifiedDo- .|. UnicodeSyntaxBit `xoptBit` LangExt.UnicodeSyntax- .|. UnboxedTuplesBit `xoptBit` LangExt.UnboxedTuples- .|. UnboxedSumsBit `xoptBit` LangExt.UnboxedSums- .|. DatatypeContextsBit `xoptBit` LangExt.DatatypeContexts- .|. TransformComprehensionsBit `xoptBit` LangExt.TransformListComp- .|. MonadComprehensionsBit `xoptBit` LangExt.MonadComprehensions- .|. AlternativeLayoutRuleBit `xoptBit` LangExt.AlternativeLayoutRule- .|. ALRTransitionalBit `xoptBit` LangExt.AlternativeLayoutRuleTransitional- .|. RelaxedLayoutBit `xoptBit` LangExt.RelaxedLayout- .|. NondecreasingIndentationBit `xoptBit` LangExt.NondecreasingIndentation- .|. TraditionalRecordSyntaxBit `xoptBit` LangExt.TraditionalRecordSyntax- .|. ExplicitNamespacesBit `xoptBit` LangExt.ExplicitNamespaces- .|. LambdaCaseBit `xoptBit` LangExt.LambdaCase- .|. BinaryLiteralsBit `xoptBit` LangExt.BinaryLiterals- .|. NegativeLiteralsBit `xoptBit` LangExt.NegativeLiterals- .|. HexFloatLiteralsBit `xoptBit` LangExt.HexFloatLiterals- .|. PatternSynonymsBit `xoptBit` LangExt.PatternSynonyms- .|. StaticPointersBit `xoptBit` LangExt.StaticPointers- .|. NumericUnderscoresBit `xoptBit` LangExt.NumericUnderscores- .|. StarIsTypeBit `xoptBit` LangExt.StarIsType- .|. BlockArgumentsBit `xoptBit` LangExt.BlockArguments- .|. NPlusKPatternsBit `xoptBit` LangExt.NPlusKPatterns- .|. DoAndIfThenElseBit `xoptBit` LangExt.DoAndIfThenElse- .|. MultiWayIfBit `xoptBit` LangExt.MultiWayIf- .|. GadtSyntaxBit `xoptBit` LangExt.GADTSyntax- .|. ImportQualifiedPostBit `xoptBit` LangExt.ImportQualifiedPost- .|. LinearTypesBit `xoptBit` LangExt.LinearTypes- .|. NoLexicalNegationBit `xoptNotBit` LangExt.LexicalNegation -- See Note [Why not LexicalNegationBit]- .|. OverloadedRecordDotBit `xoptBit` LangExt.OverloadedRecordDot- .|. OverloadedRecordUpdateBit `xoptBit` LangExt.OverloadedRecordUpdate -- Enable testing via 'getBit OverloadedRecordUpdateBit' in the parser (RecordDotSyntax parsing uses that information).- optBits =- HaddockBit `setBitIf` isHaddock- .|. RawTokenStreamBit `setBitIf` rawTokStream- .|. UsePosPragsBit `setBitIf` usePosPrags-- xoptBit bit ext = bit `setBitIf` EnumSet.member ext extensionFlags- xoptNotBit bit ext = bit `setBitIf` not (EnumSet.member ext extensionFlags)-- setBitIf :: ExtBits -> Bool -> ExtsBitmap- b `setBitIf` cond | cond = xbit b- | otherwise = 0---- | Set parser options for parsing OPTIONS pragmas-initPragState :: ParserOpts -> StringBuffer -> RealSrcLoc -> PState-initPragState options buf loc = (initParserState options buf loc)- { lex_state = [bol, option_prags, 0]- }---- | Creates a parse state from a 'ParserOpts' value-initParserState :: ParserOpts -> StringBuffer -> RealSrcLoc -> PState-initParserState options buf loc =- PState {- buffer = buf,- options = options,- errors = emptyBag,- warnings = emptyBag,- tab_first = Nothing,- tab_count = 0,- last_tk = Nothing,- prev_loc = mkPsSpan init_loc init_loc,- prev_loc2 = mkPsSpan init_loc init_loc,- last_loc = mkPsSpan init_loc init_loc,- last_len = 0,- loc = init_loc,- context = [],- lex_state = [bol, 0],- srcfiles = [],- alr_pending_implicit_tokens = [],- alr_next_token = Nothing,- alr_last_loc = PsSpan (alrInitialLoc (fsLit "<no file>")) (BufSpan (BufPos 0) (BufPos 0)),- alr_context = [],- alr_expecting_ocurly = Nothing,- alr_justClosedExplicitLetBlock = False,- eof_pos = Nothing,- header_comments = Nothing,- comment_q = [],- hdk_comments = nilOL- }- where init_loc = PsLoc loc (BufPos 0)---- | An mtl-style class for monads that support parsing-related operations.--- For example, sometimes we make a second pass over the parsing results to validate,--- disambiguate, or rearrange them, and we do so in the PV monad which cannot consume--- input but can report parsing errors, check for extension bits, and accumulate--- parsing annotations. Both P and PV are instances of MonadP.------ MonadP grants us convenient overloading. The other option is to have separate operations--- for each monad: addErrorP vs addErrorPV, getBitP vs getBitPV, and so on.----class Monad m => MonadP m where- -- | Add a non-fatal error. Use this when the parser can produce a result- -- despite the error.- --- -- For example, when GHC encounters a @forall@ in a type,- -- but @-XExplicitForAll@ is disabled, the parser constructs @ForAllTy@- -- as if @-XExplicitForAll@ was enabled, adding a non-fatal error to- -- the accumulator.- --- -- Control flow wise, non-fatal errors act like warnings: they are added- -- to the accumulator and parsing continues. This allows GHC to report- -- more than one parse error per file.- --- addError :: PsError -> m ()-- -- | Add a warning to the accumulator.- -- Use 'getMessages' to get the accumulated warnings.- addWarning :: WarningFlag -> PsWarning -> m ()-- -- | Add a fatal error. This will be the last error reported by the parser, and- -- the parser will not produce any result, ending in a 'PFailed' state.- addFatalError :: PsError -> m a-- -- | Check if a given flag is currently set in the bitmap.- getBit :: ExtBits -> m Bool- -- | Go through the @comment_q@ in @PState@ and remove all comments- -- that belong within the given span- allocateCommentsP :: RealSrcSpan -> m EpAnnComments- -- | Go through the @comment_q@ in @PState@ and remove all comments- -- that come before or within the given span- allocatePriorCommentsP :: RealSrcSpan -> m EpAnnComments- -- | Go through the @comment_q@ in @PState@ and remove all comments- -- that come after the given span- allocateFinalCommentsP :: RealSrcSpan -> m EpAnnComments--instance MonadP P where- addError err- = P $ \s -> POk s { errors = err `consBag` errors s} ()-- addWarning option w- = P $ \s -> if warnopt option (options s)- then POk (s { warnings = w `consBag` warnings s }) ()- else POk s ()-- addFatalError err =- addError err >> P PFailed-- getBit ext = P $ \s -> let b = ext `xtest` pExtsBitmap (options s)- in b `seq` POk s b- allocateCommentsP ss = P $ \s ->- let (comment_q', newAnns) = allocateComments ss (comment_q s) in- POk s {- comment_q = comment_q'- } (EpaComments newAnns)- allocatePriorCommentsP ss = P $ \s ->- let (header_comments', comment_q', newAnns)- = allocatePriorComments ss (comment_q s) (header_comments s) in- POk s {- header_comments = header_comments',- comment_q = comment_q'- } (EpaComments newAnns)- allocateFinalCommentsP ss = P $ \s ->- let (header_comments', comment_q', newAnns)- = allocateFinalComments ss (comment_q s) (header_comments s) in- POk s {- header_comments = header_comments',- comment_q = comment_q'- } (EpaCommentsBalanced (fromMaybe [] header_comments') (reverse newAnns))--getCommentsFor :: (MonadP m) => SrcSpan -> m EpAnnComments-getCommentsFor (RealSrcSpan l _) = allocateCommentsP l-getCommentsFor _ = return emptyComments--getPriorCommentsFor :: (MonadP m) => SrcSpan -> m EpAnnComments-getPriorCommentsFor (RealSrcSpan l _) = allocatePriorCommentsP l-getPriorCommentsFor _ = return emptyComments--getFinalCommentsFor :: (MonadP m) => SrcSpan -> m EpAnnComments-getFinalCommentsFor (RealSrcSpan l _) = allocateFinalCommentsP l-getFinalCommentsFor _ = return emptyComments--getEofPos :: P (Maybe (RealSrcSpan, RealSrcSpan))-getEofPos = P $ \s@(PState { eof_pos = pos }) -> POk s pos--addTabWarning :: RealSrcSpan -> P ()-addTabWarning srcspan- = P $ \s@PState{tab_first=tf, tab_count=tc, options=o} ->- let tf' = if isJust tf then tf else Just srcspan- tc' = tc + 1- s' = if warnopt Opt_WarnTabs o- then s{tab_first = tf', tab_count = tc'}- else s- in POk s' ()---- | Get a bag of the errors that have been accumulated so far.--- Does not take -Werror into account.-getErrorMessages :: PState -> Bag PsError-getErrorMessages p = errors p---- | Get the warnings and errors accumulated so far.--- Does not take -Werror into account.-getMessages :: PState -> (Bag PsWarning, Bag PsError)-getMessages p =- let ws = warnings p- -- we add the tabulation warning on the fly because- -- we count the number of occurrences of tab characters- ws' = case tab_first p of- Nothing -> ws- Just tf -> PsWarnTab (RealSrcSpan tf Nothing) (tab_count p)- `consBag` ws- in (ws', errors p)--getContext :: P [LayoutContext]-getContext = P $ \s@PState{context=ctx} -> POk s ctx--setContext :: [LayoutContext] -> P ()-setContext ctx = P $ \s -> POk s{context=ctx} ()--popContext :: P ()-popContext = P $ \ s@(PState{ buffer = buf, options = o, context = ctx,- last_len = len, last_loc = last_loc }) ->- case ctx of- (_:tl) ->- POk s{ context = tl } ()- [] ->- unP (addFatalError $ srcParseErr o buf len (mkSrcSpanPs last_loc)) s---- Push a new layout context at the indentation of the last token read.-pushCurrentContext :: GenSemic -> P ()-pushCurrentContext gen_semic = P $ \ s@PState{ last_loc=loc, context=ctx } ->- POk s{context = Layout (srcSpanStartCol (psRealSpan loc)) gen_semic : ctx} ()---- This is only used at the outer level of a module when the 'module' keyword is--- missing.-pushModuleContext :: P ()-pushModuleContext = pushCurrentContext generateSemic--getOffside :: P (Ordering, Bool)-getOffside = P $ \s@PState{last_loc=loc, context=stk} ->- let offs = srcSpanStartCol (psRealSpan loc) in- let ord = case stk of- Layout n gen_semic : _ ->- --trace ("layout: " ++ show n ++ ", offs: " ++ show offs) $- (compare offs n, gen_semic)- _ ->- (GT, dontGenerateSemic)- in POk s ord---- ------------------------------------------------------------------------------ Construct a parse error--srcParseErr- :: ParserOpts- -> StringBuffer -- current buffer (placed just after the last token)- -> Int -- length of the previous token- -> SrcSpan- -> PsError-srcParseErr options buf len loc = PsError (PsErrParse token) suggests loc- where- token = lexemeToString (offsetBytes (-len) buf) len- pattern = decodePrevNChars 8 buf- last100 = decodePrevNChars 100 buf- doInLast100 = "do" `isInfixOf` last100- mdoInLast100 = "mdo" `isInfixOf` last100- th_enabled = ThQuotesBit `xtest` pExtsBitmap options- ps_enabled = PatternSynonymsBit `xtest` pExtsBitmap options-- sug c s = if c then Just s else Nothing- sug_th = sug (not th_enabled && token == "$") SuggestTH -- #7396- sug_rdo = sug (token == "<-" && mdoInLast100) SuggestRecursiveDo- sug_do = sug (token == "<-" && not mdoInLast100) SuggestDo- sug_let = sug (token == "=" && doInLast100) SuggestLetInDo -- #15849- sug_pat = sug (not ps_enabled && pattern == "pattern ") SuggestPatternSynonyms -- #12429- suggests- | null token = []- | otherwise = catMaybes [sug_th, sug_rdo, sug_do, sug_let, sug_pat]---- Report a parse failure, giving the span of the previous token as--- the location of the error. This is the entry point for errors--- detected during parsing.-srcParseFail :: P a-srcParseFail = P $ \s@PState{ buffer = buf, options = o, last_len = len,- last_loc = last_loc } ->- unP (addFatalError $ srcParseErr o buf len (mkSrcSpanPs last_loc)) s---- A lexical error is reported at a particular position in the source file,--- not over a token range.-lexError :: LexErr -> P a-lexError e = do- loc <- getRealSrcLoc- (AI end buf) <- getInput- reportLexError loc (psRealLoc end) buf- (\k -> PsError (PsErrLexer e k) [])---- -------------------------------------------------------------------------------- This is the top-level function: called from the parser each time a--- new token is to be read from the input.--lexer, lexerDbg :: Bool -> (Located Token -> P a) -> P a--lexer queueComments cont = do- alr <- getBit AlternativeLayoutRuleBit- let lexTokenFun = if alr then lexTokenAlr else lexToken- (L span tok) <- lexTokenFun- --trace ("token: " ++ show tok) $ do-- if (queueComments && isComment tok)- then queueComment (L (psRealSpan span) tok) >> lexer queueComments cont- else cont (L (mkSrcSpanPs span) tok)---- Use this instead of 'lexer' in GHC.Parser to dump the tokens for debugging.-lexerDbg queueComments cont = lexer queueComments contDbg- where- contDbg tok = trace ("token: " ++ show (unLoc tok)) (cont tok)--lexTokenAlr :: P (PsLocated Token)-lexTokenAlr = do mPending <- popPendingImplicitToken- t <- case mPending of- Nothing ->- do mNext <- popNextToken- t <- case mNext of- Nothing -> lexToken- Just next -> return next- alternativeLayoutRuleToken t- Just t ->- return t- setAlrLastLoc (getLoc t)- case unLoc t of- ITwhere -> setAlrExpectingOCurly (Just ALRLayoutWhere)- ITlet -> setAlrExpectingOCurly (Just ALRLayoutLet)- ITof -> setAlrExpectingOCurly (Just ALRLayoutOf)- ITlcase -> setAlrExpectingOCurly (Just ALRLayoutOf)- ITdo _ -> setAlrExpectingOCurly (Just ALRLayoutDo)- ITmdo _ -> setAlrExpectingOCurly (Just ALRLayoutDo)- ITrec -> setAlrExpectingOCurly (Just ALRLayoutDo)- _ -> return ()- return t--alternativeLayoutRuleToken :: PsLocated Token -> P (PsLocated Token)-alternativeLayoutRuleToken t- = do context <- getALRContext- lastLoc <- getAlrLastLoc- mExpectingOCurly <- getAlrExpectingOCurly- transitional <- getBit ALRTransitionalBit- justClosedExplicitLetBlock <- getJustClosedExplicitLetBlock- setJustClosedExplicitLetBlock False- let thisLoc = getLoc t- thisCol = srcSpanStartCol (psRealSpan thisLoc)- newLine = srcSpanStartLine (psRealSpan thisLoc) > srcSpanEndLine (psRealSpan lastLoc)- case (unLoc t, context, mExpectingOCurly) of- -- This case handles a GHC extension to the original H98- -- layout rule...- (ITocurly, _, Just alrLayout) ->- do setAlrExpectingOCurly Nothing- let isLet = case alrLayout of- ALRLayoutLet -> True- _ -> False- setALRContext (ALRNoLayout (containsCommas ITocurly) isLet : context)- return t- -- ...and makes this case unnecessary- {-- -- I think our implicit open-curly handling is slightly- -- different to John's, in how it interacts with newlines- -- and "in"- (ITocurly, _, Just _) ->- do setAlrExpectingOCurly Nothing- setNextToken t- lexTokenAlr- -}- (_, ALRLayout _ col : _ls, Just expectingOCurly)- | (thisCol > col) ||- (thisCol == col &&- isNonDecreasingIndentation expectingOCurly) ->- do setAlrExpectingOCurly Nothing- setALRContext (ALRLayout expectingOCurly thisCol : context)- setNextToken t- return (L thisLoc ITvocurly)- | otherwise ->- do setAlrExpectingOCurly Nothing- setPendingImplicitTokens [L lastLoc ITvccurly]- setNextToken t- return (L lastLoc ITvocurly)- (_, _, Just expectingOCurly) ->- do setAlrExpectingOCurly Nothing- setALRContext (ALRLayout expectingOCurly thisCol : context)- setNextToken t- return (L thisLoc ITvocurly)- -- We do the [] cases earlier than in the spec, as we- -- have an actual EOF token- (ITeof, ALRLayout _ _ : ls, _) ->- do setALRContext ls- setNextToken t- return (L thisLoc ITvccurly)- (ITeof, _, _) ->- return t- -- the other ITeof case omitted; general case below covers it- (ITin, _, _)- | justClosedExplicitLetBlock ->- return t- (ITin, ALRLayout ALRLayoutLet _ : ls, _)- | newLine ->- do setPendingImplicitTokens [t]- setALRContext ls- return (L thisLoc ITvccurly)- -- This next case is to handle a transitional issue:- (ITwhere, ALRLayout _ col : ls, _)- | newLine && thisCol == col && transitional ->- do addWarning Opt_WarnAlternativeLayoutRuleTransitional- $ PsWarnTransitionalLayout (mkSrcSpanPs thisLoc) TransLayout_Where- setALRContext ls- setNextToken t- -- Note that we use lastLoc, as we may need to close- -- more layouts, or give a semicolon- return (L lastLoc ITvccurly)- -- This next case is to handle a transitional issue:- (ITvbar, ALRLayout _ col : ls, _)- | newLine && thisCol == col && transitional ->- do addWarning Opt_WarnAlternativeLayoutRuleTransitional- $ PsWarnTransitionalLayout (mkSrcSpanPs thisLoc) TransLayout_Pipe- setALRContext ls- setNextToken t- -- Note that we use lastLoc, as we may need to close- -- more layouts, or give a semicolon- return (L lastLoc ITvccurly)- (_, ALRLayout _ col : ls, _)- | newLine && thisCol == col ->- do setNextToken t- let loc = psSpanStart thisLoc- zeroWidthLoc = mkPsSpan loc loc- return (L zeroWidthLoc ITsemi)- | newLine && thisCol < col ->- do setALRContext ls- setNextToken t- -- Note that we use lastLoc, as we may need to close- -- more layouts, or give a semicolon- return (L lastLoc ITvccurly)- -- We need to handle close before open, as 'then' is both- -- an open and a close- (u, _, _)- | isALRclose u ->- case context of- ALRLayout _ _ : ls ->- do setALRContext ls- setNextToken t- return (L thisLoc ITvccurly)- ALRNoLayout _ isLet : ls ->- do let ls' = if isALRopen u- then ALRNoLayout (containsCommas u) False : ls- else ls- setALRContext ls'- when isLet $ setJustClosedExplicitLetBlock True- return t- [] ->- do let ls = if isALRopen u- then [ALRNoLayout (containsCommas u) False]- else []- setALRContext ls- -- XXX This is an error in John's code, but- -- it looks reachable to me at first glance- return t- (u, _, _)- | isALRopen u ->- do setALRContext (ALRNoLayout (containsCommas u) False : context)- return t- (ITin, ALRLayout ALRLayoutLet _ : ls, _) ->- do setALRContext ls- setPendingImplicitTokens [t]- return (L thisLoc ITvccurly)- (ITin, ALRLayout _ _ : ls, _) ->- do setALRContext ls- setNextToken t- return (L thisLoc ITvccurly)- -- the other ITin case omitted; general case below covers it- (ITcomma, ALRLayout _ _ : ls, _)- | topNoLayoutContainsCommas ls ->- do setALRContext ls- setNextToken t- return (L thisLoc ITvccurly)- (ITwhere, ALRLayout ALRLayoutDo _ : ls, _) ->- do setALRContext ls- setPendingImplicitTokens [t]- return (L thisLoc ITvccurly)- -- the other ITwhere case omitted; general case below covers it- (_, _, _) -> return t--isALRopen :: Token -> Bool-isALRopen ITcase = True-isALRopen ITif = True-isALRopen ITthen = True-isALRopen IToparen = True-isALRopen ITobrack = True-isALRopen ITocurly = True--- GHC Extensions:-isALRopen IToubxparen = True-isALRopen _ = False--isALRclose :: Token -> Bool-isALRclose ITof = True-isALRclose ITthen = True-isALRclose ITelse = True-isALRclose ITcparen = True-isALRclose ITcbrack = True-isALRclose ITccurly = True--- GHC Extensions:-isALRclose ITcubxparen = True-isALRclose _ = False--isNonDecreasingIndentation :: ALRLayout -> Bool-isNonDecreasingIndentation ALRLayoutDo = True-isNonDecreasingIndentation _ = False--containsCommas :: Token -> Bool-containsCommas IToparen = True-containsCommas ITobrack = True--- John doesn't have {} as containing commas, but records contain them,--- which caused a problem parsing Cabal's Distribution.Simple.InstallDirs--- (defaultInstallDirs).-containsCommas ITocurly = True--- GHC Extensions:-containsCommas IToubxparen = True-containsCommas _ = False--topNoLayoutContainsCommas :: [ALRContext] -> Bool-topNoLayoutContainsCommas [] = False-topNoLayoutContainsCommas (ALRLayout _ _ : ls) = topNoLayoutContainsCommas ls-topNoLayoutContainsCommas (ALRNoLayout b _ : _) = b--lexToken :: P (PsLocated Token)-lexToken = do- inp@(AI loc1 buf) <- getInput- sc <- getLexState- exts <- getExts- case alexScanUser exts inp sc of- AlexEOF -> do- let span = mkPsSpan loc1 loc1- lt <- getLastLocEof- setEofPos (psRealSpan span) (psRealSpan lt)- setLastToken span 0- return (L span ITeof)- AlexError (AI loc2 buf) ->- reportLexError (psRealLoc loc1) (psRealLoc loc2) buf- (\k -> PsError (PsErrLexer LexError k) [])- AlexSkip inp2 _ -> do- setInput inp2- lexToken- AlexToken inp2@(AI end buf2) _ t -> do- setInput inp2- let span = mkPsSpan loc1 end- let bytes = byteDiff buf buf2- span `seq` setLastToken span bytes- lt <- t span buf bytes- let lt' = unLoc lt- if (isComment lt') then setLastComment lt else setLastTk lt- return lt--reportLexError :: RealSrcLoc -> RealSrcLoc -> StringBuffer -> (LexErrKind -> SrcSpan -> PsError) -> P a-reportLexError loc1 loc2 buf f- | atEnd buf = failLocMsgP loc1 loc2 (f LexErrKind_EOF)- | otherwise =- let c = fst (nextChar buf)- in if c == '\0' -- decoding errors are mapped to '\0', see utf8DecodeChar#- then failLocMsgP loc2 loc2 (f LexErrKind_UTF8)- else failLocMsgP loc1 loc2 (f (LexErrKind_Char c))--lexTokenStream :: ParserOpts -> StringBuffer -> RealSrcLoc -> ParseResult [Located Token]-lexTokenStream opts buf loc = unP go initState{ options = opts' }- where- new_exts = xunset HaddockBit -- disable Haddock- $ xunset UsePosPragsBit -- parse LINE/COLUMN pragmas as tokens- $ xset RawTokenStreamBit -- include comments- $ pExtsBitmap opts- opts' = opts { pExtsBitmap = new_exts }- initState = initParserState opts' buf loc- go = do- ltok <- lexer False return- case ltok of- L _ ITeof -> return []- _ -> liftM (ltok:) go--linePrags = Map.singleton "line" linePrag--fileHeaderPrags = Map.fromList([("options", lex_string_prag IToptions_prag),- ("options_ghc", lex_string_prag IToptions_prag),- ("options_haddock", lex_string_prag_comment ITdocOptions),- ("language", token ITlanguage_prag),- ("include", lex_string_prag ITinclude_prag)])--ignoredPrags = Map.fromList (map ignored pragmas)- where ignored opt = (opt, nested_comment lexToken)- impls = ["hugs", "nhc98", "jhc", "yhc", "catch", "derive"]- options_pragmas = map ("options_" ++) impls- -- CFILES is a hugs-only thing.- pragmas = options_pragmas ++ ["cfiles", "contract"]--oneWordPrags = Map.fromList [- ("rules", rulePrag),- ("inline",- strtoken (\s -> (ITinline_prag (SourceText s) Inline FunLike))),- ("inlinable",- strtoken (\s -> (ITinline_prag (SourceText s) Inlinable FunLike))),- ("inlineable",- strtoken (\s -> (ITinline_prag (SourceText s) Inlinable FunLike))),- -- Spelling variant- ("notinline",- strtoken (\s -> (ITinline_prag (SourceText s) NoInline FunLike))),- ("specialize", strtoken (\s -> ITspec_prag (SourceText s))),- ("source", strtoken (\s -> ITsource_prag (SourceText s))),- ("warning", strtoken (\s -> ITwarning_prag (SourceText s))),- ("deprecated", strtoken (\s -> ITdeprecated_prag (SourceText s))),- ("scc", strtoken (\s -> ITscc_prag (SourceText s))),- ("unpack", strtoken (\s -> ITunpack_prag (SourceText s))),- ("nounpack", strtoken (\s -> ITnounpack_prag (SourceText s))),- ("ann", strtoken (\s -> ITann_prag (SourceText s))),- ("minimal", strtoken (\s -> ITminimal_prag (SourceText s))),- ("overlaps", strtoken (\s -> IToverlaps_prag (SourceText s))),- ("overlappable", strtoken (\s -> IToverlappable_prag (SourceText s))),- ("overlapping", strtoken (\s -> IToverlapping_prag (SourceText s))),- ("incoherent", strtoken (\s -> ITincoherent_prag (SourceText s))),- ("ctype", strtoken (\s -> ITctype (SourceText s))),- ("complete", strtoken (\s -> ITcomplete_prag (SourceText s))),- ("column", columnPrag)- ]--twoWordPrags = Map.fromList [- ("inline conlike",- strtoken (\s -> (ITinline_prag (SourceText s) Inline ConLike))),- ("notinline conlike",- strtoken (\s -> (ITinline_prag (SourceText s) NoInline ConLike))),- ("specialize inline",- strtoken (\s -> (ITspec_inline_prag (SourceText s) True))),- ("specialize notinline",- strtoken (\s -> (ITspec_inline_prag (SourceText s) False)))- ]--dispatch_pragmas :: Map String Action -> Action-dispatch_pragmas prags span buf len = case Map.lookup (clean_pragma (lexemeToString buf len)) prags of- Just found -> found span buf len- Nothing -> lexError LexUnknownPragma--known_pragma :: Map String Action -> AlexAccPred ExtsBitmap-known_pragma prags _ (AI _ startbuf) _ (AI _ curbuf)- = isKnown && nextCharIsNot curbuf pragmaNameChar- where l = lexemeToString startbuf (byteDiff startbuf curbuf)- isKnown = isJust $ Map.lookup (clean_pragma l) prags- pragmaNameChar c = isAlphaNum c || c == '_'--clean_pragma :: String -> String-clean_pragma prag = canon_ws (map toLower (unprefix prag))- where unprefix prag' = case stripPrefix "{-#" prag' of- Just rest -> rest- Nothing -> prag'- canonical prag' = case prag' of- "noinline" -> "notinline"- "specialise" -> "specialize"- "constructorlike" -> "conlike"- _ -> prag'- canon_ws s = unwords (map canonical (words s))----{--%************************************************************************-%* *- Helper functions for generating annotations in the parser-%* *-%************************************************************************--}----- |Given a 'RealSrcSpan' that surrounds a 'HsPar' or 'HsParTy', generate--- 'AddEpAnn' values for the opening and closing bordering on the start--- and end of the span-mkParensEpAnn :: RealSrcSpan -> (AddEpAnn, AddEpAnn)-mkParensEpAnn ss = (AddEpAnn AnnOpenP (EpaSpan lo),AddEpAnn AnnCloseP (EpaSpan lc))- where- f = srcSpanFile ss- sl = srcSpanStartLine ss- sc = srcSpanStartCol ss- el = srcSpanEndLine ss- ec = srcSpanEndCol ss- lo = mkRealSrcSpan (realSrcSpanStart ss) (mkRealSrcLoc f sl (sc+1))- lc = mkRealSrcSpan (mkRealSrcLoc f el (ec - 1)) (realSrcSpanEnd ss)--queueComment :: RealLocated Token -> P()-queueComment c = P $ \s -> POk s {- comment_q = commentToAnnotation c : comment_q s- } ()--allocateComments- :: RealSrcSpan- -> [LEpaComment]- -> ([LEpaComment], [LEpaComment])-allocateComments ss comment_q =- let- (before,rest) = break (\(L l _) -> isRealSubspanOf (anchor l) ss) comment_q- (middle,after) = break (\(L l _) -> not (isRealSubspanOf (anchor l) ss)) rest- comment_q' = before ++ after- newAnns = middle- in- (comment_q', newAnns)--allocatePriorComments- :: RealSrcSpan- -> [LEpaComment]- -> Maybe [LEpaComment]- -> (Maybe [LEpaComment], [LEpaComment], [LEpaComment])-allocatePriorComments ss comment_q mheader_comments =- let- cmp (L l _) = anchor l <= ss- (before,after) = partition cmp comment_q- newAnns = before- comment_q'= after- in- case mheader_comments of- Nothing -> (Just newAnns, comment_q', [])- Just _ -> (mheader_comments, comment_q', newAnns)--allocateFinalComments- :: RealSrcSpan- -> [LEpaComment]- -> Maybe [LEpaComment]- -> (Maybe [LEpaComment], [LEpaComment], [LEpaComment])-allocateFinalComments ss comment_q mheader_comments =- let- cmp (L l _) = anchor l <= ss- (before,after) = partition cmp comment_q- newAnns = after- comment_q'= before- in- case mheader_comments of- Nothing -> (Just newAnns, [], comment_q')- Just _ -> (mheader_comments, [], comment_q' ++ newAnns)--commentToAnnotation :: RealLocated Token -> LEpaComment-commentToAnnotation (L l (ITdocCommentNext s ll)) = mkLEpaComment l ll (EpaDocCommentNext s)-commentToAnnotation (L l (ITdocCommentPrev s ll)) = mkLEpaComment l ll (EpaDocCommentPrev s)-commentToAnnotation (L l (ITdocCommentNamed s ll)) = mkLEpaComment l ll (EpaDocCommentNamed s)-commentToAnnotation (L l (ITdocSection n s ll)) = mkLEpaComment l ll (EpaDocSection n s)-commentToAnnotation (L l (ITdocOptions s ll)) = mkLEpaComment l ll (EpaDocOptions s)-commentToAnnotation (L l (ITlineComment s ll)) = mkLEpaComment l ll (EpaLineComment s)-commentToAnnotation (L l (ITblockComment s ll)) = mkLEpaComment l ll (EpaBlockComment s)-commentToAnnotation _ = panic "commentToAnnotation"---- see Note [PsSpan in Comments]-mkLEpaComment :: RealSrcSpan -> PsSpan -> EpaCommentTok -> LEpaComment-mkLEpaComment l ll tok = L (realSpanAsAnchor l) (EpaComment tok (psRealSpan ll))---- -----------------------------------------------------------------------isComment :: Token -> Bool-isComment (ITlineComment _ _) = True-isComment (ITblockComment _ _) = True-isComment (ITdocCommentNext _ _) = True-isComment (ITdocCommentPrev _ _) = True-isComment (ITdocCommentNamed _ _) = True-isComment (ITdocSection _ _ _) = True-isComment (ITdocOptions _ _) = True-isComment _ = False--bol,column_prag,layout,layout_do,layout_if,layout_left,line_prag1,line_prag1a,line_prag2,line_prag2a,option_prags :: Int-bol = 1-column_prag = 2-layout = 3-layout_do = 4-layout_if = 5-layout_left = 6-line_prag1 = 7-line_prag1a = 8-line_prag2 = 9-line_prag2a = 10-option_prags = 11-alex_action_1 = warnTab-alex_action_2 = nested_comment lexToken-alex_action_3 = lineCommentToken-alex_action_4 = lineCommentToken-alex_action_5 = lineCommentToken-alex_action_6 = lineCommentToken-alex_action_7 = lineCommentToken-alex_action_8 = lineCommentToken-alex_action_10 = begin line_prag1-alex_action_11 = begin line_prag1-alex_action_14 = do_bol-alex_action_15 = hopefully_open_brace-alex_action_17 = begin line_prag1-alex_action_18 = new_layout_context True dontGenerateSemic ITvbar-alex_action_19 = pop-alex_action_20 = new_layout_context True generateSemic ITvocurly-alex_action_21 = new_layout_context False generateSemic ITvocurly-alex_action_22 = do_layout_left-alex_action_23 = begin bol-alex_action_24 = dispatch_pragmas linePrags-alex_action_25 = setLineAndFile line_prag1a-alex_action_26 = failLinePrag1-alex_action_27 = popLinePrag1-alex_action_28 = setLineAndFile line_prag2a-alex_action_29 = pop-alex_action_30 = setColumn-alex_action_31 = dispatch_pragmas twoWordPrags-alex_action_32 = dispatch_pragmas oneWordPrags-alex_action_33 = dispatch_pragmas ignoredPrags-alex_action_34 = endPrag-alex_action_35 = dispatch_pragmas fileHeaderPrags-alex_action_36 = nested_comment lexToken-alex_action_37 = warnThen Opt_WarnUnrecognisedPragmas PsWarnUnrecognisedPragma- (nested_comment lexToken)-alex_action_38 = multiline_doc_comment-alex_action_39 = nested_doc_comment-alex_action_40 = token (ITopenExpQuote NoE NormalSyntax)-alex_action_41 = token (ITopenTExpQuote NoE)-alex_action_42 = token (ITcloseQuote NormalSyntax)-alex_action_43 = token ITcloseTExpQuote-alex_action_44 = token (ITopenExpQuote HasE NormalSyntax)-alex_action_45 = token (ITopenTExpQuote HasE)-alex_action_46 = token ITopenPatQuote-alex_action_47 = layout_token ITopenDecQuote-alex_action_48 = token ITopenTypQuote-alex_action_49 = lex_quasiquote_tok-alex_action_50 = lex_qquasiquote_tok-alex_action_51 = token (ITopenExpQuote NoE UnicodeSyntax)-alex_action_52 = token (ITcloseQuote UnicodeSyntax)-alex_action_53 = special (IToparenbar NormalSyntax)-alex_action_54 = special (ITcparenbar NormalSyntax)-alex_action_55 = special (IToparenbar UnicodeSyntax)-alex_action_56 = special (ITcparenbar UnicodeSyntax)-alex_action_57 = skip_one_varid ITdupipvarid-alex_action_58 = skip_one_varid ITlabelvarid-alex_action_59 = token IToubxparen-alex_action_60 = token ITcubxparen-alex_action_61 = special IToparen-alex_action_62 = special ITcparen-alex_action_63 = special ITobrack-alex_action_64 = special ITcbrack-alex_action_65 = special ITcomma-alex_action_66 = special ITsemi-alex_action_67 = special ITbackquote-alex_action_68 = open_brace-alex_action_69 = close_brace-alex_action_70 = qdo_token ITdo-alex_action_71 = qdo_token ITmdo-alex_action_72 = idtoken qvarid-alex_action_73 = idtoken qconid-alex_action_74 = varid-alex_action_75 = idtoken conid-alex_action_76 = idtoken qvarid-alex_action_77 = idtoken qconid-alex_action_78 = varid-alex_action_79 = idtoken conid-alex_action_80 = varsym_tight_infix-alex_action_81 = varsym_prefix-alex_action_82 = varsym_suffix-alex_action_83 = varsym_loose_infix-alex_action_84 = idtoken qvarsym-alex_action_85 = idtoken qconsym-alex_action_86 = consym-alex_action_87 = tok_num positive 0 0 decimal-alex_action_88 = tok_num positive 2 2 binary-alex_action_89 = tok_num positive 2 2 octal-alex_action_90 = tok_num positive 2 2 hexadecimal-alex_action_91 = tok_num negative 1 1 decimal-alex_action_92 = tok_num negative 3 3 binary-alex_action_93 = tok_num negative 3 3 octal-alex_action_94 = tok_num negative 3 3 hexadecimal-alex_action_95 = tok_frac 0 tok_float-alex_action_96 = tok_frac 0 tok_float-alex_action_97 = tok_frac 0 tok_hex_float-alex_action_98 = tok_frac 0 tok_hex_float-alex_action_99 = tok_primint positive 0 1 decimal-alex_action_100 = tok_primint positive 2 3 binary-alex_action_101 = tok_primint positive 2 3 octal-alex_action_102 = tok_primint positive 2 3 hexadecimal-alex_action_103 = tok_primint negative 1 2 decimal-alex_action_104 = tok_primint negative 3 4 binary-alex_action_105 = tok_primint negative 3 4 octal-alex_action_106 = tok_primint negative 3 4 hexadecimal-alex_action_107 = tok_primword 0 2 decimal-alex_action_108 = tok_primword 2 4 binary-alex_action_109 = tok_primword 2 4 octal-alex_action_110 = tok_primword 2 4 hexadecimal-alex_action_111 = tok_frac 1 tok_primfloat-alex_action_112 = tok_frac 2 tok_primdouble-alex_action_113 = tok_frac 1 tok_primfloat-alex_action_114 = tok_frac 2 tok_primdouble-alex_action_115 = lex_char_tok-alex_action_116 = lex_string_tok--#define ALEX_GHC 1-#define ALEX_LATIN1 1--- -------------------------------------------------------------------------------- ALEX TEMPLATE------ This code is in the PUBLIC DOMAIN; you may copy it freely and use--- it for any purpose whatsoever.---- -------------------------------------------------------------------------------- INTERNALS and main scanner engine--#ifdef ALEX_GHC-# define ILIT(n) n#-# define IBOX(n) (I# (n))-# define FAST_INT Int#--- Do not remove this comment. Required to fix CPP parsing when using GCC and a clang-compiled alex.-# if __GLASGOW_HASKELL__ > 706-# define GTE(n,m) (tagToEnum# (n >=# m))-# define EQ(n,m) (tagToEnum# (n ==# m))-# else-# define GTE(n,m) (n >=# m)-# define EQ(n,m) (n ==# m)-# endif-# define PLUS(n,m) (n +# m)-# define MINUS(n,m) (n -# m)-# define TIMES(n,m) (n *# m)-# define NEGATE(n) (negateInt# (n))-# define IF_GHC(x) (x)-#else-# define ILIT(n) (n)-# define IBOX(n) (n)-# define FAST_INT Int-# define GTE(n,m) (n >= m)-# define EQ(n,m) (n == m)-# define PLUS(n,m) (n + m)-# define MINUS(n,m) (n - m)-# define TIMES(n,m) (n * m)-# define NEGATE(n) (negate (n))-# define IF_GHC(x)-#endif--#ifdef ALEX_GHC-data AlexAddr = AlexA# Addr#--- Do not remove this comment. Required to fix CPP parsing when using GCC and a clang-compiled alex.-#if __GLASGOW_HASKELL__ < 503-uncheckedShiftL# = shiftL#-#endif--{-# INLINE alexIndexInt16OffAddr #-}-alexIndexInt16OffAddr :: AlexAddr -> Int# -> Int#-alexIndexInt16OffAddr (AlexA# arr) off =-#ifdef WORDS_BIGENDIAN- narrow16Int# i- where- i = word2Int# ((high `uncheckedShiftL#` 8#) `or#` low)- high = int2Word# (ord# (indexCharOffAddr# arr (off' +# 1#)))- low = int2Word# (ord# (indexCharOffAddr# arr off'))- off' = off *# 2#-#else-#if __GLASGOW_HASKELL__ >= 901- int16ToInt#-#endif- (indexInt16OffAddr# arr off)-#endif-#else-alexIndexInt16OffAddr arr off = arr ! off-#endif--#ifdef ALEX_GHC-{-# INLINE alexIndexInt32OffAddr #-}-alexIndexInt32OffAddr :: AlexAddr -> Int# -> Int#-alexIndexInt32OffAddr (AlexA# arr) off =-#ifdef WORDS_BIGENDIAN- narrow32Int# i- where- i = word2Int# ((b3 `uncheckedShiftL#` 24#) `or#`- (b2 `uncheckedShiftL#` 16#) `or#`- (b1 `uncheckedShiftL#` 8#) `or#` b0)- b3 = int2Word# (ord# (indexCharOffAddr# arr (off' +# 3#)))- b2 = int2Word# (ord# (indexCharOffAddr# arr (off' +# 2#)))- b1 = int2Word# (ord# (indexCharOffAddr# arr (off' +# 1#)))- b0 = int2Word# (ord# (indexCharOffAddr# arr off'))- off' = off *# 4#-#else-#if __GLASGOW_HASKELL__ >= 901- int32ToInt#-#endif- (indexInt32OffAddr# arr off)-#endif-#else-alexIndexInt32OffAddr arr off = arr ! off-#endif--#ifdef ALEX_GHC--#if __GLASGOW_HASKELL__ < 503-quickIndex arr i = arr ! i-#else--- GHC >= 503, unsafeAt is available from Data.Array.Base.-quickIndex = unsafeAt-#endif-#else-quickIndex arr i = arr ! i-#endif---- -------------------------------------------------------------------------------- Main lexing routines--data AlexReturn a- = AlexEOF- | AlexError !AlexInput- | AlexSkip !AlexInput !Int- | AlexToken !AlexInput !Int a---- alexScan :: AlexInput -> StartCode -> AlexReturn a-alexScan input__ IBOX(sc)- = alexScanUser undefined input__ IBOX(sc)--alexScanUser user__ input__ IBOX(sc)- = case alex_scan_tkn user__ input__ ILIT(0) input__ sc AlexNone of- (AlexNone, input__') ->- case alexGetByte input__ of- Nothing ->-#ifdef ALEX_DEBUG- trace ("End of input.") $-#endif- AlexEOF- Just _ ->-#ifdef ALEX_DEBUG- trace ("Error.") $-#endif- AlexError input__'-- (AlexLastSkip input__'' len, _) ->-#ifdef ALEX_DEBUG- trace ("Skipping.") $-#endif- AlexSkip input__'' len-- (AlexLastAcc k input__''' len, _) ->-#ifdef ALEX_DEBUG- trace ("Accept.") $-#endif- AlexToken input__''' len (alex_actions ! k)----- Push the input through the DFA, remembering the most recent accepting--- state it encountered.--alex_scan_tkn user__ orig_input len input__ s last_acc =- input__ `seq` -- strict in the input- let- new_acc = (check_accs (alex_accept `quickIndex` IBOX(s)))- in- new_acc `seq`- case alexGetByte input__ of- Nothing -> (new_acc, input__)- Just (c, new_input) ->-#ifdef ALEX_DEBUG- trace ("State: " ++ show IBOX(s) ++ ", char: " ++ show c) $-#endif- case fromIntegral c of { IBOX(ord_c) ->- let- base = alexIndexInt32OffAddr alex_base s- offset = PLUS(base,ord_c)- check = alexIndexInt16OffAddr alex_check offset-- new_s = if GTE(offset,ILIT(0)) && EQ(check,ord_c)- then alexIndexInt16OffAddr alex_table offset- else alexIndexInt16OffAddr alex_deflt s- in- case new_s of- ILIT(-1) -> (new_acc, input__)- -- on an error, we want to keep the input *before* the- -- character that failed, not after.- _ -> alex_scan_tkn user__ orig_input-#ifdef ALEX_LATIN1- PLUS(len,ILIT(1))- -- issue 119: in the latin1 encoding, *each* byte is one character-#else- (if c < 0x80 || c >= 0xC0 then PLUS(len,ILIT(1)) else len)- -- note that the length is increased ONLY if this is the 1st byte in a char encoding)-#endif- new_input new_s new_acc- }- where- check_accs (AlexAccNone) = last_acc- check_accs (AlexAcc a ) = AlexLastAcc a input__ IBOX(len)- check_accs (AlexAccSkip) = AlexLastSkip input__ IBOX(len)-#ifndef ALEX_NOPRED- check_accs (AlexAccPred a predx rest)- | predx user__ orig_input IBOX(len) input__- = AlexLastAcc a input__ IBOX(len)- | otherwise- = check_accs rest- check_accs (AlexAccSkipPred predx rest)- | predx user__ orig_input IBOX(len) input__- = AlexLastSkip input__ IBOX(len)- | otherwise- = check_accs rest-#endif--data AlexLastAcc- = AlexNone- | AlexLastAcc !Int !AlexInput !Int- | AlexLastSkip !AlexInput !Int--data AlexAcc user- = AlexAccNone- | AlexAcc Int- | AlexAccSkip-#ifndef ALEX_NOPRED- | AlexAccPred Int (AlexAccPred user) (AlexAcc user)- | AlexAccSkipPred (AlexAccPred user) (AlexAcc user)--type AlexAccPred user = user -> AlexInput -> Int -> AlexInput -> Bool---- -------------------------------------------------------------------------------- Predicates on a rule--alexAndPred p1 p2 user__ in1 len in2- = p1 user__ in1 len in2 && p2 user__ in1 len in2----alexPrevCharIsPred :: Char -> AlexAccPred _-alexPrevCharIs c _ input__ _ _ = c == alexInputPrevChar input__--alexPrevCharMatches f _ input__ _ _ = f (alexInputPrevChar input__)----alexPrevCharIsOneOfPred :: Array Char Bool -> AlexAccPred _-alexPrevCharIsOneOf arr _ input__ _ _ = arr ! alexInputPrevChar input__----alexRightContext :: Int -> AlexAccPred _-alexRightContext IBOX(sc) user__ _ _ input__ =- case alex_scan_tkn user__ input__ ILIT(0) input__ sc AlexNone of- (AlexNone, _) -> False- _ -> True- -- TODO: there's no need to find the longest- -- match when checking the right context, just- -- the first match will do.-#endif
+ ghc-lib/stage0/libraries/ghc-boot/build/GHC/Platform/Host.hs view
@@ -0,0 +1,12 @@+module GHC.Platform.Host where++import GHC.Platform.ArchOS++hostPlatformArch :: Arch+hostPlatformArch = ArchX86_64++hostPlatformOS :: OS+hostPlatformOS = OSDarwin++hostPlatformArchOS :: ArchOS+hostPlatformArchOS = ArchOS hostPlatformArch hostPlatformOS